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

Parent Directory | Revision Log | Patch

	trunk/mkinitrd-magellan/grubby/grubby.c revision 914 by niro, Wed Oct 28 00:16:16 2009 UTC	trunk/grubby/grubby.c revision 2708 by niro, Wed Jul 16 10:56:09 2014 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
42	#define DEBUG 0	#define DEBUG 0
43		#endif
44
45	#if DEBUG	#if DEBUG
46	#define dbgPrintf(format, args...) fprintf(stderr, format , ## args)	#define dbgPrintf(format, args...) fprintf(stderr, format , ## args)
#	Line 44	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 56  struct lineElement {	Line 75  struct lineElement {
75	};	};
76
77	enum lineType_e {	enum lineType_e {
78	LT_WHITESPACE = 1 << 0,	LT_WHITESPACE   = 1 << 0,
79	LT_TITLE      = 1 << 1,	LT_TITLE        = 1 << 1,
80	LT_KERNEL     = 1 << 2,	LT_KERNEL       = 1 << 2,
81	LT_INITRD     = 1 << 3,	LT_INITRD       = 1 << 3,
82	LT_HYPER      = 1 << 4,	LT_HYPER        = 1 << 4,
83	LT_DEFAULT    = 1 << 5,	LT_DEFAULT      = 1 << 5,
84	LT_MBMODULE   = 1 << 6,	LT_MBMODULE     = 1 << 6,
85	LT_ROOT       = 1 << 7,	LT_ROOT         = 1 << 7,
86	LT_FALLBACK   = 1 << 8,	LT_FALLBACK     = 1 << 8,
87	LT_KERNELARGS = 1 << 9,	LT_KERNELARGS   = 1 << 9,
88	LT_BOOT       = 1 << 10,	LT_BOOT         = 1 << 10,
89	LT_BOOTROOT   = 1 << 11,	LT_BOOTROOT     = 1 << 11,
90	LT_LBA        = 1 << 12,	LT_LBA          = 1 << 12,
91	LT_OTHER      = 1 << 13,	LT_OTHER        = 1 << 13,
92	LT_GENERIC    = 1 << 14,	LT_GENERIC      = 1 << 14,
93	LT_UNKNOWN    = 1 << 15,	LT_ECHO    = 1 << 16,
94		LT_MENUENTRY    = 1 << 17,
95		LT_ENTRY_END    = 1 << 18,
96		LT_SET_VARIABLE = 1 << 19,
97		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 99  struct singleEntry {	Line 127  struct singleEntry {
127	#define NEED_TITLE   (1 << 2)	#define NEED_TITLE   (1 << 2)
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)
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 110  struct keywordTypes {	Line 141  struct keywordTypes {
141	char separatorChar;	char separatorChar;
142	};	};
143
144		struct configFileInfo;
145
146		typedef const char *(*findConfigFunc)(struct configFileInfo *);
147		typedef const int (*writeLineFunc)(struct configFileInfo *,
148		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;
155		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;
162	int defaultSupportSaved;	int defaultSupportSaved;
163	enum lineType_e entrySeparator;	int defaultIsSaved;
164		int defaultIsUnquoted;
165		enum lineType_e entryStart;
166		enum lineType_e entryEnd;
167	int needsBootPrefix;	int needsBootPrefix;
168	int argsInQuotes;	int argsInQuotes;
169	int maxTitleLength;	int maxTitleLength;
170	int titleBracketed;	int titleBracketed;
171		int titlePosition;
172	int mbHyperFirst;	int mbHyperFirst;
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 138  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	"/etc/grub.conf",    /* defaultConfig */	.findConfig = grubFindConfig,
217	grubKeywords,    /* keywords */	.keywords = grubKeywords,
218	1,    /* defaultIsIndex */	.defaultIsIndex = 1,
219	1,    /* defaultSupportSaved */	.defaultSupportSaved = 1,
220	LT_TITLE,    /* entrySeparator */	.entryStart = LT_TITLE,
221	1,    /* needsBootPrefix */	.needsBootPrefix = 1,
222	0,    /* argsInQuotes */	.mbHyperFirst = 1,
223	0,    /* maxTitleLength */	.mbInitRdIsModule = 1,
224	0,                                      /* titleBracketed */	.mbAllowExtraInitRds = 1,
225	1,                                      /* mbHyperFirst */	};
226	1,                                      /* mbInitRdIsModule */
227	0,                                      /* mbConcatArgs */	struct keywordTypes grub2Keywords[] = {
228	1,                                      /* mbAllowExtraInitRds */	{ "menuentry",  LT_MENUENTRY,   ' ' },
229		{ "}",          LT_ENTRY_END,   ' ' },
230		{ "echo",       LT_ECHO,        ' ' },
231		{ "set",        LT_SET_VARIABLE,' ', '=' },
232		{ "root",       LT_BOOTROOT,    ' ' },
233		{ "default",    LT_DEFAULT,     ' ' },
234		{ "fallback",   LT_FALLBACK,    ' ' },
235		{ "linux",      LT_KERNEL,      ' ' },
236		{ "linuxefi",   LT_KERNEL_EFI,  ' ' },
237		{ "linux16",    LT_KERNEL_16,   ' ' },
238		{ "initrd",     LT_INITRD,      ' ', ' ' },
239		{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
240		{ "initrd16",   LT_INITRD_16,   ' ', ' ' },
241		{ "module",     LT_MBMODULE,    ' ' },
242		{ "kernel",     LT_HYPER,       ' ' },
243		{ "devicetree", LT_DEVTREE,  ' ' },
244		{ NULL, 0, 0 },
245		};
246
247		const char *grub2FindConfig(struct configFileInfo *cfi) {
248		static const char *configFiles[] = {
249		"/boot/grub/grub-efi.cfg",
250		"/boot/grub/grub.cfg",
251		NULL
252		};
253		static int i = -1;
254		static const char *grub_cfg = "/boot/grub/grub.cfg";
255		int rc = -1;
256
257		if (i == -1) {
258		for (i = 0; configFiles[i] != NULL; i++) {
259		dbgPrintf("Checking \"%s\": ", configFiles[i]);
260		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");
269		return configFiles[i];
270		}
271		}
272		}
273
274		/* Ubuntu renames grub2 to grub, so check for the grub.d directory
275		* that isn't in grub1, and if it exists, return the config file path
276		* that they use. */
277		if (configFiles[i] == NULL && !access("/etc/grub.d/", R_OK)) {
278		dbgPrintf("found\n");
279		return grub_cfg;
280		}
281
282		dbgPrintf("not found\n");
283		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 = {
478		.findConfig = grub2FindConfig,
479		.getEnv = grub2GetEnv,
480		.setEnv = grub2SetEnv,
481		.keywords = grub2Keywords,
482		.defaultIsIndex = 1,
483		.defaultSupportSaved = 1,
484		.defaultIsVariable = 1,
485		.entryStart = LT_MENUENTRY,
486		.entryEnd = LT_ENTRY_END,
487		.titlePosition = 1,
488		.needsBootPrefix = 1,
489		.mbHyperFirst = 1,
490		.mbInitRdIsModule = 1,
491		.mbAllowExtraInitRds = 1,
492	};	};
493
494	struct keywordTypes yabootKeywords[] = {	struct keywordTypes yabootKeywords[] = {
#	Line 249  struct keywordTypes extlinuxKeywords[] =	Line 586  struct keywordTypes extlinuxKeywords[] =
586	};	};
587	int useextlinuxmenu;	int useextlinuxmenu;
588	struct configFileInfo eliloConfigType = {	struct configFileInfo eliloConfigType = {
589	"/boot/efi/EFI/redhat/elilo.conf",    /* defaultConfig */	.defaultConfig = "/boot/efi/EFI/redhat/elilo.conf",
590	eliloKeywords,    /* keywords */	.keywords = eliloKeywords,
591	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
592	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
593	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
594	1,                    /* needsBootPrefix */	.mbConcatArgs = 1,
	1,    /* argsInQuotes */
	0,    /* maxTitleLength */
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	1,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
595	};	};
596
597	struct configFileInfo liloConfigType = {	struct configFileInfo liloConfigType = {
598	"/etc/lilo.conf",    /* defaultConfig */	.defaultConfig = "/etc/lilo.conf",
599	liloKeywords,    /* keywords */	.keywords = liloKeywords,
600	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
601	0,    /* defaultSupportSaved */	.argsInQuotes = 1,
602	LT_KERNEL,    /* entrySeparator */	.maxTitleLength = 15,
	0,    /* needsBootPrefix */
	1,    /* argsInQuotes */
	15,    /* maxTitleLength */
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
603	};	};
604
605	struct configFileInfo yabootConfigType = {	struct configFileInfo yabootConfigType = {
606	"/etc/yaboot.conf",    /* defaultConfig */	.defaultConfig = "/etc/yaboot.conf",
607	yabootKeywords,    /* keywords */	.keywords = yabootKeywords,
608	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
609	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
610	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
611	1,    /* needsBootPrefix */	.maxTitleLength = 15,
612	1,    /* argsInQuotes */	.mbAllowExtraInitRds = 1,
	15,    /* maxTitleLength */
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	1,                                      /* mbAllowExtraInitRds */
613	};	};
614
615	struct configFileInfo siloConfigType = {	struct configFileInfo siloConfigType = {
616	"/etc/silo.conf",    /* defaultConfig */	.defaultConfig = "/etc/silo.conf",
617	siloKeywords,    /* keywords */	.keywords = siloKeywords,
618	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
619	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
620	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
621	1,    /* needsBootPrefix */	.maxTitleLength = 15,
	1,    /* argsInQuotes */
	15,    /* maxTitleLength */
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
622	};	};
623
624	struct configFileInfo ziplConfigType = {	struct configFileInfo ziplConfigType = {
625	"/etc/zipl.conf",    /* defaultConfig */	.defaultConfig = "/etc/zipl.conf",
626	ziplKeywords,    /* keywords */	.keywords = ziplKeywords,
627	0,    /* defaultIsIndex */	.entryStart = LT_TITLE,
628	0,    /* defaultSupportSaved */	.argsInQuotes = 1,
629	LT_TITLE,    /* entrySeparator */	.titleBracketed = 1,
	0,    /* needsBootPrefix */
	1,    /* argsInQuotes */
	0,    /* maxTitleLength */
	1,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
630	};	};
631
632	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
633	"/boot/extlinux/extlinux.conf",         /* defaultConfig */	.defaultConfig = "/boot/extlinux/extlinux.conf",
634	extlinuxKeywords,                       /* keywords */	.keywords = extlinuxKeywords,
635	0,                                      /* defaultIsIndex */	.caseInsensitive = 1,
636	0,                                      /* defaultSupportSaved */	.entryStart = LT_TITLE,
637	LT_TITLE,                               /* entrySeparator */	.needsBootPrefix = 1,
638	1,                                      /* needsBootPrefix */	.maxTitleLength = 255,
639	0,                                      /* argsInQuotes */	.mbAllowExtraInitRds = 1,
640	255,                                    /* maxTitleLength */	.defaultIsUnquoted = 1,
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	1,                                      /* mbAllowExtraInitRds */
641	};	};
642
643	struct grubConfig {	struct grubConfig {
#	Line 356  struct grubConfig {	Line 652  struct grubConfig {
652	struct configFileInfo * cfi;	struct configFileInfo * cfi;
653	};	};
654
655		blkid_cache blkid;
656
657	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index);	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index);
658	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
659	const char * path, const char * prefix,	const char * path, const char * prefix,
660	int * index);	int * index);
661		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
662		int * index);
663	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
664	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
665	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 369  static int lineWrite(FILE * out, struct	Line 669  static int lineWrite(FILE * out, struct
669	static int getNextLine(char ** bufPtr, struct singleLine * line,	static int getNextLine(char ** bufPtr, struct singleLine * line,
670	struct configFileInfo * cfi);	struct configFileInfo * cfi);
671	static char * getRootSpecifier(char * str);	static char * getRootSpecifier(char * str);
672		static void requote(struct singleLine *line, struct configFileInfo * cfi);
673	static void insertElement(struct singleLine * line,	static void insertElement(struct singleLine * line,
674	const char * item, int insertHere,	const char * item, int insertHere,
675	struct configFileInfo * cfi);	struct configFileInfo * cfi);
#	Line 423  static char * sdupprintf(const char *for	Line 724  static char * sdupprintf(const char *for
724	return buf;	return buf;
725	}	}
726
727		static enum lineType_e preferredLineType(enum lineType_e type,
728		struct configFileInfo *cfi) {
729		if (isEfi && cfi == &grub2ConfigType) {
730		switch (type) {
731		case LT_KERNEL:
732		return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
733		case LT_INITRD:
734		return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
735		default:
736		return type;
737		}
738		#if defined(__i386__) || defined(__x86_64__)
739		} else if (cfi == &grub2ConfigType) {
740		switch (type) {
741		case LT_KERNEL:
742		return LT_KERNEL_16;
743		case LT_INITRD:
744		return LT_INITRD_16;
745		default:
746		return type;
747		}
748		#endif
749		}
750		return type;
751		}
752
753	static struct keywordTypes * getKeywordByType(enum lineType_e type,	static struct keywordTypes * getKeywordByType(enum lineType_e type,
754	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
755	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
	for (kw = cfi->keywords; kw->key; kw++) {
756	if (kw->type == type)	if (kw->type == type)
757	return kw;	return kw;
758	}	}
759	return NULL;	return NULL;
760	}	}
761
762	static char * getpathbyspec(char *device) {	static char *getKeyByType(enum lineType_e type, struct configFileInfo * cfi) {
763	static blkid_cache blkid;	struct keywordTypes *kt = getKeywordByType(type, cfi);
764		if (kt)
765		return kt->key;
766		return "unknown";
767		}
768
769		static char * getpathbyspec(char *device) {
770	if (!blkid)	if (!blkid)
771	blkid_get_cache(&blkid, NULL);	blkid_get_cache(&blkid, NULL);
772
773	return blkid_get_devname(blkid, device, NULL);	return blkid_get_devname(blkid, device, NULL);
774	}	}
775
776		static char * getuuidbydev(char *device) {
777		if (!blkid)
778		blkid_get_cache(&blkid, NULL);
779
780		return blkid_get_tag_value(blkid, "UUID", device);
781		}
782
783	static enum lineType_e getTypeByKeyword(char * keyword,	static enum lineType_e getTypeByKeyword(char * keyword,
784	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
785	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
786	for (kw = cfi->keywords; kw->key; kw++) {	if (cfi->caseInsensitive) {
787	if (!strcmp(keyword, kw->key))	if (!strcasecmp(keyword, kw->key))
788	return kw->type;	return kw->type;
789		} else {
790		if (!strcmp(keyword, kw->key))
791		return kw->type;
792		}
793	}	}
794	return LT_UNKNOWN;	return LT_UNKNOWN;
795	}	}
#	Line 477  static int isBracketedTitle(struct singl	Line 819  static int isBracketedTitle(struct singl
819	return 0;	return 0;
820	}	}
821
822	static int isEntrySeparator(struct singleLine * line,	static int isEntryStart(struct singleLine * line,
823	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
824	return line->type == cfi->entrySeparator || line->type == LT_OTHER ||	return line->type == cfi->entryStart || line->type == LT_OTHER ||
825	(cfi->titleBracketed && isBracketedTitle(line));	(cfi->titleBracketed && isBracketedTitle(line));
826	}	}
827
828	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
829	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct singleLine * line) {
830	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it (leaks a byte) */
831	char * title;	char * title = NULL;
832	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
833	title++;	title = strdup(line->elements[0].item);
834	*(title + strlen(title) - 1) = '\0';	title++;
835		*(title + strlen(title) - 1) = '\0';
836		} else if (line->type == LT_MENUENTRY)
837		title = strdup(line->elements[1].item);
838		else
839		return NULL;
840	return title;	return title;
841	}	}
842
#	Line 532  static void lineInit(struct singleLine *	Line 879  static void lineInit(struct singleLine *
879	}	}
880
881	struct singleLine * lineDup(struct singleLine * line) {	struct singleLine * lineDup(struct singleLine * line) {
	int i;
882	struct singleLine * newLine = malloc(sizeof(*newLine));	struct singleLine * newLine = malloc(sizeof(*newLine));
883
884	newLine->indent = strdup(line->indent);	newLine->indent = strdup(line->indent);
#	Line 542  struct singleLine * lineDup(struct singl	Line 888  struct singleLine * lineDup(struct singl
888	newLine->elements = malloc(sizeof(*newLine->elements) *	newLine->elements = malloc(sizeof(*newLine->elements) *
889	newLine->numElements);	newLine->numElements);
890
891	for (i = 0; i < newLine->numElements; i++) {	for (int i = 0; i < newLine->numElements; i++) {
892	newLine->elements[i].indent = strdup(line->elements[i].indent);	newLine->elements[i].indent = strdup(line->elements[i].indent);
893	newLine->elements[i].item = strdup(line->elements[i].item);	newLine->elements[i].item = strdup(line->elements[i].item);
894	}	}
#	Line 551  struct singleLine * lineDup(struct singl	Line 897  struct singleLine * lineDup(struct singl
897	}	}
898
899	static void lineFree(struct singleLine * line) {	static void lineFree(struct singleLine * line) {
	int i;
900	if (line->indent) free(line->indent);	if (line->indent) free(line->indent);
901
902	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
903	free(line->elements[i].item);	free(line->elements[i].item);
904	free(line->elements[i].indent);	free(line->elements[i].indent);
905	}	}
#	Line 566  static void lineFree(struct singleLine *	Line 910  static void lineFree(struct singleLine *
910
911	static int lineWrite(FILE * out, struct singleLine * line,	static int lineWrite(FILE * out, struct singleLine * line,
912	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
	int i;
913	if (fprintf(out, "%s", line->indent) == -1) return -1;	if (fprintf(out, "%s", line->indent) == -1) return -1;
914
915	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
916		/* Need to handle this, because we strip the quotes from
917		* menuentry when read it. */
918		if (line->type == LT_MENUENTRY && i == 1) {
919		if(!isquote(*line->elements[i].item))
920		fprintf(out, "\'%s\'", line->elements[i].item);
921		else
922		fprintf(out, "%s", line->elements[i].item);
923		fprintf(out, "%s", line->elements[i].indent);
924
925		continue;
926		}
927
928	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
929	if (fputc('"', out) == EOF) return -1;	if (fputc('"', out) == EOF) return -1;
930
#	Line 664  static int getNextLine(char ** bufPtr, s	Line 1018  static int getNextLine(char ** bufPtr, s
1018	if (*line->elements[0].item == '#') {	if (*line->elements[0].item == '#') {
1019	char * fullLine;	char * fullLine;
1020	int len;	int len;
	int i;
1021
1022	len = strlen(line->indent);	len = strlen(line->indent);
1023	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1024	len += strlen(line->elements[i].item) +	len += strlen(line->elements[i].item) +
1025	strlen(line->elements[i].indent);	strlen(line->elements[i].indent);
1026
#	Line 676  static int getNextLine(char ** bufPtr, s	Line 1029  static int getNextLine(char ** bufPtr, s
1029	free(line->indent);	free(line->indent);
1030	line->indent = fullLine;	line->indent = fullLine;
1031
1032	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1033	strcat(fullLine, line->elements[i].item);	strcat(fullLine, line->elements[i].item);
1034	strcat(fullLine, line->elements[i].indent);	strcat(fullLine, line->elements[i].indent);
1035	free(line->elements[i].item);	free(line->elements[i].item);
#	Line 695  static int getNextLine(char ** bufPtr, s	Line 1048  static int getNextLine(char ** bufPtr, s
1048	* elements up more	* elements up more
1049	*/	*/
1050	if (!isspace(kw->separatorChar)) {	if (!isspace(kw->separatorChar)) {
	int i;
1051	char indent[2] = "";	char indent[2] = "";
1052	indent[0] = kw->separatorChar;	indent[0] = kw->separatorChar;
1053	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1054	char *p;	char *p;
	int j;
1055	int numNewElements;	int numNewElements;
1056
1057	numNewElements = 0;	numNewElements = 0;
#	Line 716  static int getNextLine(char ** bufPtr, s	Line 1067  static int getNextLine(char ** bufPtr, s
1067	sizeof(*line->elements) * elementsAlloced);	sizeof(*line->elements) * elementsAlloced);
1068	}	}
1069
1070	for (j = line->numElements; j > i; j--) {	for (int j = line->numElements; j > i; j--) {
1071	line->elements[j + numNewElements] = line->elements[j];	line->elements[j + numNewElements] = line->elements[j];
1072	}	}
1073	line->numElements += numNewElements;	line->numElements += numNewElements;
#	Line 729  static int getNextLine(char ** bufPtr, s	Line 1080  static int getNextLine(char ** bufPtr, s
1080	break;	break;
1081	}	}
1082
1083	free(line->elements[i].indent);	line->elements[i + 1].indent = line->elements[i].indent;
1084	line->elements[i].indent = strdup(indent);	line->elements[i].indent = strdup(indent);
1085	*p++ = '\0';	*p++ = '\0';
1086	i++;	i++;
1087	line->elements[i].item = strdup(p);	line->elements[i].item = strdup(p);
	line->elements[i].indent = strdup("");
	p = line->elements[i].item;
1088	}	}
1089	}	}
1090	}	}
#	Line 745  static int getNextLine(char ** bufPtr, s	Line 1094  static int getNextLine(char ** bufPtr, s
1094	return 0;	return 0;
1095	}	}
1096
1097		static int isnumber(const char *s)
1098		{
1099		int i;
1100		for (i = 0; s[i] != '\0'; i++)
1101		if (s[i] < '0' || s[i] > '9')
1102		return 0;
1103		return i;
1104		}
1105
1106	static struct grubConfig * readConfig(const char * inName,	static struct grubConfig * readConfig(const char * inName,
1107	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
1108	int in;	int in;
#	Line 756  static struct grubConfig * readConfig(co	Line 1114  static struct grubConfig * readConfig(co
1114	struct singleLine * last = NULL, * line, * defaultLine = NULL;	struct singleLine * last = NULL, * line, * defaultLine = NULL;
1115	char * end;	char * end;
1116	struct singleEntry * entry = NULL;	struct singleEntry * entry = NULL;
1117	int i, len;	int len;
1118	char * buf;	char * buf;
1119
1120	if (!strcmp(inName, "-")) {	if (inName == NULL) {
1121		printf("Could not find bootloader configuration\n");
1122		exit(1);
1123		} else if (!strcmp(inName, "-")) {
1124	in = 0;	in = 0;
1125	} else {	} else {
1126	if ((in = open(inName, O_RDONLY)) < 0) {	if ((in = open(inName, O_RDONLY)) < 0) {
#	Line 802  static struct grubConfig * readConfig(co	Line 1163  static struct grubConfig * readConfig(co
1163	cfg->secondaryIndent = strdup(line->indent);	cfg->secondaryIndent = strdup(line->indent);
1164	}	}
1165
1166	if (isEntrySeparator(line, cfi)) {	if (isEntryStart(line, cfi) || (cfg->entries && !sawEntry)) {
1167	sawEntry = 1;	sawEntry = 1;
1168	if (!entry) {	if (!entry) {
1169	cfg->entries = malloc(sizeof(*entry));	cfg->entries = malloc(sizeof(*entry));
#	Line 818  static struct grubConfig * readConfig(co	Line 1179  static struct grubConfig * readConfig(co
1179	entry->next = NULL;	entry->next = NULL;
1180	}	}
1181
1182	if (line->type == LT_DEFAULT && line->numElements == 2) {	if (line->type == LT_SET_VARIABLE) {
1183	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	dbgPrintf("found 'set' command (%d elements): ", line->numElements);
1184	defaultLine = line;	dbgPrintf("%s", line->indent);
1185		for (int i = 0; i < line->numElements; i++)
1186		dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
1187		dbgPrintf("\n");
1188		struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1189		if (kwType && line->numElements == 3 &&
1190		!strcmp(line->elements[1].item, kwType->key) &&
1191		!is_special_grub2_variable(line->elements[2].item)) {
1192		dbgPrintf("Line sets default config\n");
1193		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1194		defaultLine = line;
1195		}
1196
1197	} else if (line->type == LT_KERNEL) {	} else if (iskernel(line->type)) {
1198	/* if by some freak chance this is multiboot and the "module"	/* if by some freak chance this is multiboot and the "module"
1199	* lines came earlier in the template, make sure to use LT_HYPER	* lines came earlier in the template, make sure to use LT_HYPER
1200	* instead of LT_KERNEL now	* instead of LT_KERNEL now
1201	*/	*/
1202	if (entry->multiboot)	if (entry && entry->multiboot)
1203	line->type = LT_HYPER;	line->type = LT_HYPER;
1204
1205	} else if (line->type == LT_MBMODULE) {	} else if (line->type == LT_MBMODULE) {
#	Line 836  static struct grubConfig * readConfig(co	Line 1208  static struct grubConfig * readConfig(co
1208	* This only applies to grub, but that's the only place we	* This only applies to grub, but that's the only place we
1209	* should find LT_MBMODULE lines anyway.	* should find LT_MBMODULE lines anyway.
1210	*/	*/
1211	struct singleLine * l;	for (struct singleLine *l = entry->lines; l; l = l->next) {
	for (l = entry->lines; l; l = l->next) {
1212	if (l->type == LT_HYPER)	if (l->type == LT_HYPER)
1213	break;	break;
1214	else if (l->type == LT_KERNEL) {	else if (iskernel(l->type)) {
1215	l->type = LT_HYPER;	l->type = LT_HYPER;
1216	break;	break;
1217	}	}
#	Line 854  static struct grubConfig * readConfig(co	Line 1225  static struct grubConfig * readConfig(co
1225	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1226	if (*end) cfg->fallbackImage = -1;	if (*end) cfg->fallbackImage = -1;
1227
1228	} else if (line->type == LT_TITLE && line->numElements > 1) {	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1229	/* make the title a single argument (undoing our parsing) */	(line->type == LT_TITLE && line->numElements > 1)) {
1230		/* make the title/default a single argument (undoing our parsing) */
1231	len = 0;	len = 0;
1232	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1233	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
1234	len += strlen(line->elements[i].indent);	len += strlen(line->elements[i].indent);
1235	}	}
1236	buf = malloc(len + 1);	buf = malloc(len + 1);
1237	*buf = '\0';	*buf = '\0';
1238
1239	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1240	strcat(buf, line->elements[i].item);	strcat(buf, line->elements[i].item);
1241	free(line->elements[i].item);	free(line->elements[i].item);
1242
#	Line 878  static struct grubConfig * readConfig(co	Line 1250  static struct grubConfig * readConfig(co
1250	line->elements[line->numElements - 1].indent;	line->elements[line->numElements - 1].indent;
1251	line->elements[1].item = buf;	line->elements[1].item = buf;
1252	line->numElements = 2;	line->numElements = 2;
1253		} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
1254		/* let --remove-kernel="TITLE=what" work */
1255		len = 0;
1256		char *extras;
1257		char *title;
1258
1259		for (int i = 1; i < line->numElements; i++) {
1260		len += strlen(line->elements[i].item);
1261		len += strlen(line->elements[i].indent);
1262		}
1263		buf = malloc(len + 1);
1264		*buf = '\0';
1265
1266		/* allocate mem for extra flags. */
1267		extras = malloc(len + 1);
1268		*extras = '\0';
1269
1270		/* get title. */
1271		for (int i = 0; i < line->numElements; i++) {
1272		if (!strcmp(line->elements[i].item, "menuentry"))
1273		continue;
1274		if (isquote(*line->elements[i].item))
1275		title = line->elements[i].item + 1;
1276		else
1277		title = line->elements[i].item;
1278
1279		len = strlen(title);
1280		if (isquote(title[len-1])) {
1281		strncat(buf, title,len-1);
1282		break;
1283		} else {
1284		strcat(buf, title);
1285		strcat(buf, line->elements[i].indent);
1286		}
1287		}
1288
1289		/* get extras */
1290		int count = 0;
1291		for (int i = 0; i < line->numElements; i++) {
1292		if (count >= 2) {
1293		strcat(extras, line->elements[i].item);
1294		strcat(extras, line->elements[i].indent);
1295		}
1296
1297		if (!strcmp(line->elements[i].item, "menuentry"))
1298		continue;
1299
1300		/* count ' or ", there should be two in menuentry line. */
1301		if (isquote(*line->elements[i].item))
1302		count++;
1303
1304		len = strlen(line->elements[i].item);
1305
1306		if (isquote(line->elements[i].item[len -1]))
1307		count++;
1308
1309		/* ok, we get the final ' or ", others are extras. */
1310		}
1311		line->elements[1].indent =
1312		line->elements[line->numElements - 2].indent;
1313		line->elements[1].item = buf;
1314		line->elements[2].indent =
1315		line->elements[line->numElements - 2].indent;
1316		line->elements[2].item = extras;
1317		line->numElements = 3;
1318	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
1319	/* Strip off any " which may be present; they'll be put back	/* Strip off any " which may be present; they'll be put back
1320	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 887  static struct grubConfig * readConfig(co	Line 1323  static struct grubConfig * readConfig(co
1323	if (line->numElements >= 2) {	if (line->numElements >= 2) {
1324	int last, len;	int last, len;
1325
1326	if (*line->elements[1].item == '"')	if (isquote(*line->elements[1].item))
1327	memmove(line->elements[1].item, line->elements[1].item + 1,	memmove(line->elements[1].item, line->elements[1].item + 1,
1328	strlen(line->elements[1].item + 1) + 1);	strlen(line->elements[1].item + 1) + 1);
1329
1330	last = line->numElements - 1;	last = line->numElements - 1;
1331	len = strlen(line->elements[last].item) - 1;	len = strlen(line->elements[last].item) - 1;
1332	if (line->elements[last].item[len] == '"')	if (isquote(line->elements[last].item[len]))
1333	line->elements[last].item[len] = '\0';	line->elements[last].item[len] = '\0';
1334	}	}
1335	}	}
1336
1337		if (line->type == LT_DEFAULT && line->numElements == 2) {
1338		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1339		defaultLine = line;
1340		}
1341
1342	/* If we find a generic config option which should live at the	/* If we find a generic config option which should live at the
1343	top of the file, move it there. Old versions of grubby were	top of the file, move it there. Old versions of grubby were
1344	probably responsible for putting new images in the wrong	probably responsible for putting new images in the wrong
#	Line 931  static struct grubConfig * readConfig(co	Line 1372  static struct grubConfig * readConfig(co
1372	entry->lines = line;	entry->lines = line;
1373	else	else
1374	last->next = line;	last->next = line;
1375	dbgPrintf("readConfig added %d to %p\n", line->type, entry);	dbgPrintf("readConfig added %s to %p\n", getKeyByType(line->type, cfi), entry);
1376
1377		/* we could have seen this outside of an entry... if so, we
1378		* ignore it like any other line we don't grok */
1379		if (line->type == LT_ENTRY_END && sawEntry)
1380		sawEntry = 0;
1381	} else {	} else {
1382	if (!cfg->theLines)	if (!cfg->theLines)
1383	cfg->theLines = line;	cfg->theLines = line;
1384	else	else
1385	last->next = line;	last->next = line;
1386	dbgPrintf("readConfig added %d to cfg\n", line->type);	dbgPrintf("readConfig added %s to cfg\n", getKeyByType(line->type, cfi));
1387	}	}
1388
1389	last = line;	last = line;
#	Line 945  static struct grubConfig * readConfig(co	Line 1391  static struct grubConfig * readConfig(co
1391
1392	free(incoming);	free(incoming);
1393
1394		dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");
1395	if (defaultLine) {	if (defaultLine) {
1396	if (cfi->defaultSupportSaved &&	if (defaultLine->numElements > 2 &&
1397		cfi->defaultSupportSaved &&
1398		!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1399		cfg->cfi->defaultIsSaved = 1;
1400		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1401		if (cfg->cfi->getEnv) {
1402		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1403		if (defTitle) {
1404		int index = 0;
1405		if (isnumber(defTitle)) {
1406		index = atoi(defTitle);
1407		entry = findEntryByIndex(cfg, index);
1408		} else {
1409		entry = findEntryByTitle(cfg, defTitle, &index);
1410		}
1411		if (entry)
1412		cfg->defaultImage = index;
1413		}
1414		}
1415		} else if (cfi->defaultIsVariable) {
1416		char *value = defaultLine->elements[2].item;
1417		while (*value && (*value == '"' || *value == '\'' ||
1418		*value == ' ' || *value == '\t'))
1419		value++;
1420		cfg->defaultImage = strtol(value, &end, 10);
1421		while (*end && (*end == '"' || *end == '\'' ||
1422		*end == ' ' || *end == '\t'))
1423		end++;
1424		if (*end) cfg->defaultImage = -1;
1425		} else if (cfi->defaultSupportSaved &&
1426	!strncmp(defaultLine->elements[1].item, "saved", 5)) {	!strncmp(defaultLine->elements[1].item, "saved", 5)) {
1427	cfg->defaultImage = DEFAULT_SAVED;	cfg->defaultImage = DEFAULT_SAVED;
1428	} else if (cfi->defaultIsIndex) {	} else if (cfi->defaultIsIndex) {
1429	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
1430	if (*end) cfg->defaultImage = -1;	if (*end) cfg->defaultImage = -1;
1431	} else if (defaultLine->numElements >= 2) {	} else if (defaultLine->numElements >= 2) {
1432	i = 0;	int i = 0;
1433	while ((entry = findEntryByIndex(cfg, i))) {	while ((entry = findEntryByIndex(cfg, i))) {
1434	for (line = entry->lines; line; line = line->next)	for (line = entry->lines; line; line = line->next)
1435	if (line->type == LT_TITLE) break;	if (line->type == LT_TITLE) break;
#	Line 976  static struct grubConfig * readConfig(co	Line 1452  static struct grubConfig * readConfig(co
1452	cfg->defaultImage = -1;	cfg->defaultImage = -1;
1453	}	}
1454	}	}
1455		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1456		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1457		if (defTitle) {
1458		int index = 0;
1459		if (isnumber(defTitle)) {
1460		index = atoi(defTitle);
1461		entry = findEntryByIndex(cfg, index);
1462		} else {
1463		entry = findEntryByTitle(cfg, defTitle, &index);
1464		}
1465		if (entry)
1466		cfg->defaultImage = index;
1467		}
1468	} else {	} else {
1469	cfg->defaultImage = 0;	cfg->defaultImage = 0;
1470	}	}
#	Line 993  static void writeDefault(FILE * out, cha	Line 1482  static void writeDefault(FILE * out, cha
1482
1483	if (cfg->defaultImage == DEFAULT_SAVED)	if (cfg->defaultImage == DEFAULT_SAVED)
1484	fprintf(out, "%sdefault%ssaved\n", indent, separator);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1485	else if (cfg->defaultImage > -1) {	else if (cfg->cfi->defaultIsSaved) {
1486		fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1487		if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1488		char *title;
1489		entry = findEntryByIndex(cfg, cfg->defaultImage);
1490		line = getLineByType(LT_MENUENTRY, entry->lines);
1491		if (!line)
1492		line = getLineByType(LT_TITLE, entry->lines);
1493		if (line) {
1494		title = extractTitle(line);
1495		if (title)
1496		cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1497		}
1498		}
1499		} else if (cfg->defaultImage > -1) {
1500	if (cfg->cfi->defaultIsIndex) {	if (cfg->cfi->defaultIsIndex) {
1501	fprintf(out, "%sdefault%s%d\n", indent, separator,	if (cfg->cfi->defaultIsVariable) {
1502	cfg->defaultImage);	fprintf(out, "%sset default=\"%d\"\n", indent,
1503		cfg->defaultImage);
1504		} else {
1505		fprintf(out, "%sdefault%s%d\n", indent, separator,
1506		cfg->defaultImage);
1507		}
1508	} else {	} else {
1509	int image = cfg->defaultImage;	int image = cfg->defaultImage;
1510
#	Line 1048  static int writeConfig(struct grubConfig	Line 1556  static int writeConfig(struct grubConfig
1556
1557	/* most likely the symlink is relative, so change our	/* most likely the symlink is relative, so change our
1558	directory to the dir of the symlink */	directory to the dir of the symlink */
1559	rc = chdir(dirname(strdupa(outName)));	char *dir = strdupa(outName);
1560		rc = chdir(dirname(dir));
1561	do {	do {
1562	buf = alloca(len + 1);	buf = alloca(len + 1);
1563	rc = readlink(basename(outName), buf, len);	rc = readlink(basename(outName), buf, len);
#	Line 1086  static int writeConfig(struct grubConfig	Line 1595  static int writeConfig(struct grubConfig
1595	}	}
1596
1597	line = cfg->theLines;	line = cfg->theLines;
1598		struct keywordTypes *defaultKw = getKeywordByType(LT_DEFAULT, cfg->cfi);
1599	while (line) {	while (line) {
1600	if (line->type == LT_DEFAULT) {	if (line->type == LT_SET_VARIABLE && defaultKw &&
1601		line->numElements == 3 &&
1602		!strcmp(line->elements[1].item, defaultKw->key) &&
1603		!is_special_grub2_variable(line->elements[2].item)) {
1604		writeDefault(out, line->indent, line->elements[0].indent, cfg);
1605		needs &= ~MAIN_DEFAULT;
1606		} else if (line->type == LT_DEFAULT) {
1607	writeDefault(out, line->indent, line->elements[0].indent, cfg);	writeDefault(out, line->indent, line->elements[0].indent, cfg);
1608	needs &= ~MAIN_DEFAULT;	needs &= ~MAIN_DEFAULT;
1609	} else if (line->type == LT_FALLBACK) {	} else if (line->type == LT_FALLBACK) {
#	Line 1155  static int numEntries(struct grubConfig	Line 1671  static int numEntries(struct grubConfig
1671	return i;	return i;
1672	}	}
1673
1674		static char *findDiskForRoot()
1675		{
1676		int fd;
1677		char buf[65536];
1678		char *devname;
1679		char *chptr;
1680		int rc;
1681
1682		if ((fd = open(_PATH_MOUNTED, O_RDONLY)) < 0) {
1683		fprintf(stderr, "grubby: failed to open %s: %s\n",
1684		_PATH_MOUNTED, strerror(errno));
1685		return NULL;
1686		}
1687
1688		rc = read(fd, buf, sizeof(buf) - 1);
1689		if (rc <= 0) {
1690		fprintf(stderr, "grubby: failed to read %s: %s\n",
1691		_PATH_MOUNTED, strerror(errno));
1692		close(fd);
1693		return NULL;
1694		}
1695		close(fd);
1696		buf[rc] = '\0';
1697		chptr = buf;
1698
1699		char *foundanswer = NULL;
1700
1701		while (chptr && chptr != buf+rc) {
1702		devname = chptr;
1703
1704		/*
1705		* The first column of a mtab entry is the device, but if the entry is a
1706		* special device it won't start with /, so move on to the next line.
1707		*/
1708		if (*devname != '/') {
1709		chptr = strchr(chptr, '\n');
1710		if (chptr)
1711		chptr++;
1712		continue;
1713		}
1714
1715		/* Seek to the next space */
1716		chptr = strchr(chptr, ' ');
1717		if (!chptr) {
1718		fprintf(stderr, "grubby: error parsing %s: %s\n",
1719		_PATH_MOUNTED, strerror(errno));
1720		return NULL;
1721		}
1722
1723		/*
1724		* The second column of a mtab entry is the mount point, we are looking
1725		* for '/' obviously.
1726		*/
1727		if (*(++chptr) == '/' && *(++chptr) == ' ') {
1728		/* remember the last / entry in mtab */
1729		foundanswer = devname;
1730		}
1731
1732		/* Next line */
1733		chptr = strchr(chptr, '\n');
1734		if (chptr)
1735		chptr++;
1736		}
1737
1738		/* Return the last / entry found */
1739		if (foundanswer) {
1740		chptr = strchr(foundanswer, ' ');
1741		*chptr = '\0';
1742		return strdup(foundanswer);
1743		}
1744
1745		return NULL;
1746		}
1747
1748		void printEntry(struct singleEntry * entry, FILE *f) {
1749		int i;
1750		struct singleLine * line;
1751
1752		for (line = entry->lines; line; line = line->next) {
1753		log_message(f, "DBG: %s", line->indent);
1754		for (i = 0; i < line->numElements; i++) {
1755		/* Need to handle this, because we strip the quotes from
1756		* menuentry when read it. */
1757		if (line->type == LT_MENUENTRY && i == 1) {
1758		if(!isquote(*line->elements[i].item))
1759		log_message(f, "\'%s\'", line->elements[i].item);
1760		else
1761		log_message(f, "%s", line->elements[i].item);
1762		log_message(f, "%s", line->elements[i].indent);
1763
1764		continue;
1765		}
1766
1767		log_message(f, "%s%s",
1768		line->elements[i].item, line->elements[i].indent);
1769		}
1770		log_message(f, "\n");
1771		}
1772		}
1773
1774		void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1775		{
1776		static int once;
1777		va_list argp, argq;
1778
1779		va_start(argp, fmt);
1780
1781		va_copy(argq, argp);
1782		if (!once) {
1783		log_time(NULL);
1784		log_message(NULL, "command line: %s\n", saved_command_line);
1785		}
1786		log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1787		log_vmessage(NULL, fmt, argq);
1788
1789		printEntry(entry, NULL);
1790		va_end(argq);
1791
1792		if (!debug) {
1793		once = 1;
1794		va_end(argp);
1795		return;
1796		}
1797
1798		if (okay) {
1799		va_end(argp);
1800		return;
1801		}
1802
1803		if (!once)
1804		log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1805		once = 1;
1806		fprintf(stderr, "DBG: Image entry failed: ");
1807		vfprintf(stderr, fmt, argp);
1808		printEntry(entry, stderr);
1809		va_end(argp);
1810		}
1811
1812		#define beginswith(s, c) ((s) && (s)[0] == (c))
1813
1814		static int endswith(const char *s, char c)
1815		{
1816		int slen;
1817
1818		if (!s || !s[0])
1819		return 0;
1820		slen = strlen(s) - 1;
1821
1822		return s[slen] == c;
1823		}
1824
1825	int suitableImage(struct singleEntry * entry, const char * bootPrefix,	int suitableImage(struct singleEntry * entry, const char * bootPrefix,
1826	int skipRemoved, int flags) {	int skipRemoved, int flags) {
1827	struct singleLine * line;	struct singleLine * line;
1828	char * fullName;	char * fullName;
1829	int i;	int i;
	struct stat sb, sb2;
1830	char * dev;	char * dev;
1831	char * rootspec;	char * rootspec;
1832		char * rootdev;
1833
1834	if (skipRemoved && entry->skip) return 0;	if (skipRemoved && entry->skip) {
1835		notSuitablePrintf(entry, 0, "marked to skip\n");
1836		return 0;
1837		}
1838
1839	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1840	if (!line || line->numElements < 2) return 0;	if (!line) {
1841		notSuitablePrintf(entry, 0, "no line found\n");
1842		return 0;
1843		}
1844		if (line->numElements < 2) {
1845		notSuitablePrintf(entry, 0, "line has only %d elements\n",
1846		line->numElements);
1847		return 0;
1848		}
1849
1850	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	if (flags & GRUBBY_BADIMAGE_OKAY) {
1851		notSuitablePrintf(entry, 1, "\n");
1852		return 1;
1853		}
1854
1855	fullName = alloca(strlen(bootPrefix) +	fullName = alloca(strlen(bootPrefix) +
1856	strlen(line->elements[1].item) + 1);	strlen(line->elements[1].item) + 1);
1857	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
1858	sprintf(fullName, "%s%s", bootPrefix,	int rootspec_offset = rootspec ? strlen(rootspec) : 0;
1859	line->elements[1].item + (rootspec ? strlen(rootspec) : 0));	int hasslash = endswith(bootPrefix, '/') ||
1860	if (access(fullName, R_OK)) return 0;	beginswith(line->elements[1].item + rootspec_offset, '/');
1861		sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1862		line->elements[1].item + rootspec_offset);
1863		if (access(fullName, R_OK)) {
1864		notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1865		return 0;
1866		}
1867	for (i = 2; i < line->numElements; i++)	for (i = 2; i < line->numElements; i++)
1868	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1869	if (i < line->numElements) {	if (i < line->numElements) {
#	Line 1195  int suitableImage(struct singleEntry * e	Line 1881  int suitableImage(struct singleEntry * e
1881	line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);
1882
1883	/* failed to find one */	/* failed to find one */
1884	if (!line) return 0;	if (!line) {
1885		notSuitablePrintf(entry, 0, "no line found\n");
1886		return 0;
1887		}
1888
1889	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
1890	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1891	if (i < line->numElements)	if (i < line->numElements)
1892	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1893	else {	else {
1894		notSuitablePrintf(entry, 0, "no root= entry found\n");
1895	/* it failed too...  can't find root= */	/* it failed too...  can't find root= */
1896	return 0;	return 0;
1897	}	}
#	Line 1209  int suitableImage(struct singleEntry * e	Line 1899  int suitableImage(struct singleEntry * e
1899	}	}
1900
1901	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1902	if (!dev)	if (!getpathbyspec(dev)) {
1903		notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1904	return 0;	return 0;
1905		} else
1906		dev = getpathbyspec(dev);
1907
1908	i = stat(dev, &sb);	rootdev = findDiskForRoot();
1909	if (i)	if (!rootdev) {
1910		notSuitablePrintf(entry, 0, "can't find root device\n");
1911	return 0;	return 0;
1912		}
1913
1914	stat("/", &sb2);	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1915		notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1916		getuuidbydev(rootdev), getuuidbydev(dev));
1917		free(rootdev);
1918		return 0;
1919		}
1920
1921	if (sb.st_rdev != sb2.st_dev)	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1922		notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1923		getuuidbydev(rootdev), getuuidbydev(dev));
1924		free(rootdev);
1925	return 0;	return 0;
1926		}
1927
1928		free(rootdev);
1929		notSuitablePrintf(entry, 1, "\n");
1930
1931	return 1;	return 1;
1932	}	}
#	Line 1263  struct singleEntry * findEntryByPath(str	Line 1970  struct singleEntry * findEntryByPath(str
1970	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
1971	if (!entry) return NULL;	if (!entry) return NULL;
1972
1973	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1974	if (!line) return NULL;	if (!line) return NULL;
1975
1976	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1301  struct singleEntry * findEntryByPath(str	Line 2008  struct singleEntry * findEntryByPath(str
2008
2009	if (!strncmp(kernel, "TITLE=", 6)) {	if (!strncmp(kernel, "TITLE=", 6)) {
2010	prefix = "";	prefix = "";
2011	checkType = LT_TITLE;	checkType = LT_TITLE|LT_MENUENTRY;
2012	kernel += 6;	kernel += 6;
2013	}	}
2014
#	Line 1312  struct singleEntry * findEntryByPath(str	Line 2019  struct singleEntry * findEntryByPath(str
2019
2020	/* check all the lines matching checkType */	/* check all the lines matching checkType */
2021	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
2022	line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?	enum lineType_e ct = checkType;
2023	LT_KERNEL|LT_MBMODULE|LT_HYPER :	if (entry->multiboot && checkType == LT_KERNEL)
2024	checkType, line);	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2025	if (!line) break;  /* not found in this entry */	else if (checkType & LT_KERNEL)
2026		ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2027		line = getLineByType(ct, line);
2028		if (!line)
2029		break;  /* not found in this entry */
2030
2031	if (line && line->numElements >= 2) {	if (line && line->type != LT_MENUENTRY &&
2032		line->numElements >= 2) {
2033	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
2034	if (!strcmp(line->elements[1].item +	if (!strcmp(line->elements[1].item +
2035	((rootspec != NULL) ? strlen(rootspec) : 0),	((rootspec != NULL) ? strlen(rootspec) : 0),
2036	kernel + strlen(prefix)))	kernel + strlen(prefix)))
2037	break;	break;
2038	}	}
2039		if(line->type == LT_MENUENTRY &&
2040		!strcmp(line->elements[1].item, kernel))
2041		break;
2042	}	}
2043
2044	/* make sure this entry has a kernel identifier; this skips	/* make sure this entry has a kernel identifier; this skips
2045	* non-Linux boot entries (could find netbsd etc, though, which is	* non-Linux boot entries (could find netbsd etc, though, which is
2046	* unfortunate)	* unfortunate)
2047	*/	*/
2048	if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2049	break; /* found 'im! */	break; /* found 'im! */
2050	}	}
2051
#	Line 1340  struct singleEntry * findEntryByPath(str	Line 2055  struct singleEntry * findEntryByPath(str
2055	return entry;	return entry;
2056	}	}
2057
2058		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2059		int * index) {
2060		struct singleEntry * entry;
2061		struct singleLine * line;
2062		int i;
2063		char * newtitle;
2064
2065		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2066		if (index && i < *index)
2067		continue;
2068		line = getLineByType(LT_TITLE, entry->lines);
2069		if (!line)
2070		line = getLineByType(LT_MENUENTRY, entry->lines);
2071		if (!line)
2072		continue;
2073		newtitle = grub2ExtractTitle(line);
2074		if (!newtitle)
2075		continue;
2076		if (!strcmp(title, newtitle))
2077		break;
2078		}
2079
2080		if (!entry)
2081		return NULL;
2082
2083		if (index)
2084		*index = i;
2085		return entry;
2086		}
2087
2088	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2089	struct singleEntry * entry;	struct singleEntry * entry;
2090
#	Line 1362  struct singleEntry * findTemplate(struct	Line 2107  struct singleEntry * findTemplate(struct
2107	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2108	int index;	int index;
2109
2110	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2111		if (cfg->cfi->getEnv) {
2112		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2113		if (defTitle) {
2114		int index = 0;
2115		if (isnumber(defTitle)) {
2116		index = atoi(defTitle);
2117		entry = findEntryByIndex(cfg, index);
2118		} else {
2119		entry = findEntryByTitle(cfg, defTitle, &index);
2120		}
2121		if (entry)
2122		cfg->defaultImage = index;
2123		}
2124		}
2125		} else if (cfg->defaultImage > -1) {
2126	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2127	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2128	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1415  void markRemovedImage(struct grubConfig	Line 2175  void markRemovedImage(struct grubConfig
2175	const char * prefix) {	const char * prefix) {
2176	struct singleEntry * entry;	struct singleEntry * entry;
2177
2178	if (!image) return;	if (!image)
2179		return;
2180
2181		/* check and see if we're removing the default image */
2182		if (isdigit(*image)) {
2183		entry = findEntryByPath(cfg, image, prefix, NULL);
2184		if(entry)
2185		entry->skip = 1;
2186		return;
2187		}
2188
2189	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2190	entry->skip = 1;	entry->skip = 1;
#	Line 1423  void markRemovedImage(struct grubConfig	Line 2192  void markRemovedImage(struct grubConfig
2192
2193	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2194	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2195	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2196	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2197	int i, j;	int i, j;
2198
2199	if (newIsDefault) {	if (newIsDefault) {
2200	config->defaultImage = 0;	config->defaultImage = 0;
2201	return;	return;
2202		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2203		if (findEntryByIndex(config, index))
2204		config->defaultImage = index;
2205		else
2206		config->defaultImage = -1;
2207		return;
2208	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2209	i = 0;	i = 0;
2210	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1442  void setDefaultImage(struct grubConfig *	Line 2217  void setDefaultImage(struct grubConfig *
2217
2218	/* 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
2219	changes */	changes */
2220	if (config->defaultImage == DEFAULT_SAVED)	if ((config->defaultImage == DEFAULT_SAVED) ||
2221		(config->defaultImage == DEFAULT_SAVED_GRUB2))
2222	/* default is set to saved, we don't want to change it */	/* default is set to saved, we don't want to change it */
2223	return;	return;
2224
#	Line 1480  void setFallbackImage(struct grubConfig	Line 2256  void setFallbackImage(struct grubConfig
2256
2257	if (config->fallbackImage == -1) return;	if (config->fallbackImage == -1) return;
2258
2259	entry = findEntryByIndex(config, config->fallbackImage);	entry = findEntryByIndex(config, config->fallbackImage);
2260	if (!entry || entry->skip) {	if (!entry || entry->skip) {
2261	config->fallbackImage = -1;	config->fallbackImage = -1;
2262	return;	return;
2263		}
2264
2265		if (hasNew)
2266		config->fallbackImage++;
2267
2268		/* count the number of entries erased before this one */
2269		for (j = 0; j < config->fallbackImage; j++) {
2270		entry2 = findEntryByIndex(config, j);
2271		if (entry2->skip) config->fallbackImage--;
2272		}
2273		}
2274
2275		void displayEntry(struct singleEntry * entry, const char * prefix, int index) {
2276		struct singleLine * line;
2277		char * root = NULL;
2278		int i;
2279		int j;
2280
2281		printf("index=%d\n", index);
2282
2283		line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2284		if (!line) {
2285		printf("non linux entry\n");
2286		return;
2287		}
2288
2289		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2290		printf("kernel=%s\n", line->elements[1].item);
2291		else
2292		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2293
2294		if (line->numElements >= 3) {
2295		printf("args=\"");
2296		i = 2;
2297		while (i < line->numElements) {
2298		if (!strncmp(line->elements[i].item, "root=", 5)) {
2299		root = line->elements[i].item + 5;
2300		} else {
2301		printf("%s%s", line->elements[i].item,
2302		line->elements[i].indent);
2303		}
2304
2305		i++;
2306		}
2307		printf("\"\n");
2308		} else {
2309		line = getLineByType(LT_KERNELARGS, entry->lines);
2310		if (line) {
2311		char * s;
2312
2313		printf("args=\"");
2314		i = 1;
2315		while (i < line->numElements) {
2316		if (!strncmp(line->elements[i].item, "root=", 5)) {
2317		root = line->elements[i].item + 5;
2318		} else {
2319		s = line->elements[i].item;
2320
2321		printf("%s%s", s, line->elements[i].indent);
2322		}
2323
2324		i++;
2325		}
2326
2327		s = line->elements[i - 1].indent;
2328		printf("\"\n");
2329		}
2330		}
2331
2332		if (!root) {
2333		line = getLineByType(LT_ROOT, entry->lines);
2334		if (line && line->numElements >= 2)
2335		root=line->elements[1].item;
2336		}
2337
2338		if (root) {
2339		char * s = alloca(strlen(root) + 1);
2340
2341		strcpy(s, root);
2342		if (s[strlen(s) - 1] == '"')
2343		s[strlen(s) - 1] = '\0';
2344		/* make sure the root doesn't have a trailing " */
2345		printf("root=%s\n", s);
2346		}
2347
2348		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2349
2350		if (line && line->numElements >= 2) {
2351		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2352		printf("initrd=");
2353		else
2354		printf("initrd=%s", prefix);
2355
2356		for (i = 1; i < line->numElements; i++)
2357		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2358		printf("\n");
2359		}
2360
2361		line = getLineByType(LT_TITLE, entry->lines);
2362		if (line) {
2363		printf("title=%s\n", line->elements[1].item);
2364		} else {
2365		char * title;
2366		line = getLineByType(LT_MENUENTRY, entry->lines);
2367		title = grub2ExtractTitle(line);
2368		if (title)
2369		printf("title=%s\n", title);
2370		}
2371
2372		for (j = 0, line = entry->lines; line; line = line->next) {
2373		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2374		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2375		printf("mbmodule%d=", j);
2376		else
2377		printf("mbmodule%d=%s", j, prefix);
2378
2379		for (i = 1; i < line->numElements; i++)
2380		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2381		printf("\n");
2382		j++;
2383		}
2384		}
2385		}
2386
2387		int isSuseSystem(void) {
2388		const char * path;
2389		const static char default_path[] = "/etc/SuSE-release";
2390
2391		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2392		path = default_path;
2393
2394		if (!access(path, R_OK))
2395		return 1;
2396		return 0;
2397		}
2398
2399		int isSuseGrubConf(const char * path) {
2400		FILE * grubConf;
2401		char * line = NULL;
2402		size_t len = 0, res = 0;
2403
2404		grubConf = fopen(path, "r");
2405		if (!grubConf) {
2406		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2407		return 0;
2408		}
2409
2410		while ((res = getline(&line, &len, grubConf)) != -1) {
2411		if (!strncmp(line, "setup", 5)) {
2412		fclose(grubConf);
2413		free(line);
2414		return 1;
2415		}
2416		}
2417
2418		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2419		path);
2420
2421		fclose(grubConf);
2422		free(line);
2423		return 0;
2424		}
2425
2426		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2427		FILE * grubConf;
2428		char * line = NULL;
2429		size_t res = 0, len = 0;
2430
2431		if (!path) return 1;
2432		if (!lbaPtr) return 1;
2433
2434		grubConf = fopen(path, "r");
2435		if (!grubConf) return 1;
2436
2437		while ((res = getline(&line, &len, grubConf)) != -1) {
2438		if (line[res - 1] == '\n')
2439		line[res - 1] = '\0';
2440		else if (len > res)
2441		line[res] = '\0';
2442		else {
2443		line = realloc(line, res + 1);
2444		line[res] = '\0';
2445		}
2446
2447		if (!strncmp(line, "setup", 5)) {
2448		if (strstr(line, "--force-lba")) {
2449		*lbaPtr = 1;
2450		} else {
2451		*lbaPtr = 0;
2452		}
2453		dbgPrintf("lba: %i\n", *lbaPtr);
2454		break;
2455		}
2456		}
2457
2458		free(line);
2459		fclose(grubConf);
2460		return 0;
2461		}
2462
2463		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2464		FILE * grubConf;
2465		char * line = NULL;
2466		size_t res = 0, len = 0;
2467		char * lastParamPtr = NULL;
2468		char * secLastParamPtr = NULL;
2469		char installDeviceNumber = '\0';
2470		char * bounds = NULL;
2471
2472		if (!path) return 1;
2473		if (!devicePtr) return 1;
2474
2475		grubConf = fopen(path, "r");
2476		if (!grubConf) return 1;
2477
2478		while ((res = getline(&line, &len, grubConf)) != -1) {
2479		if (strncmp(line, "setup", 5))
2480		continue;
2481
2482		if (line[res - 1] == '\n')
2483		line[res - 1] = '\0';
2484		else if (len > res)
2485		line[res] = '\0';
2486		else {
2487		line = realloc(line, res + 1);
2488		line[res] = '\0';
2489		}
2490
2491		lastParamPtr = bounds = line + res;
2492
2493		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2494		while (!isspace(*lastParamPtr))
2495		lastParamPtr--;
2496		lastParamPtr++;
2497
2498		secLastParamPtr = lastParamPtr - 2;
2499		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2500
2501		if (lastParamPtr + 3 > bounds) {
2502		dbgPrintf("lastParamPtr going over boundary");
2503		fclose(grubConf);
2504		free(line);
2505		return 1;
2506		}
2507		if (!strncmp(lastParamPtr, "(hd", 3))
2508		lastParamPtr += 3;
2509		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2510
2511		/*
2512		* Second last parameter will decide wether last parameter is
2513		* an IMAGE_DEVICE or INSTALL_DEVICE
2514		*/
2515		while (!isspace(*secLastParamPtr))
2516		secLastParamPtr--;
2517		secLastParamPtr++;
2518
2519		if (secLastParamPtr + 3 > bounds) {
2520		dbgPrintf("secLastParamPtr going over boundary");
2521		fclose(grubConf);
2522		free(line);
2523		return 1;
2524		}
2525		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2526		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2527		secLastParamPtr += 3;
2528		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2529		installDeviceNumber = *secLastParamPtr;
2530		} else {
2531		installDeviceNumber = *lastParamPtr;
2532		}
2533
2534		*devicePtr = malloc(6);
2535		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2536		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2537		fclose(grubConf);
2538		free(line);
2539		return 0;
2540	}	}
2541
2542	if (hasNew)	free(line);
2543	config->fallbackImage++;	fclose(grubConf);
2544		return 1;
	/* count the number of entries erased before this one */
	for (j = 0; j < config->fallbackImage; j++) {
	entry2 = findEntryByIndex(config, j);
	if (entry2->skip) config->fallbackImage--;
	}
2545	}	}
2546
2547	void displayEntry(struct singleEntry * entry, const char * prefix, int index) {	int grubGetBootFromDeviceMap(const char * device,
2548	struct singleLine * line;	char ** bootPtr) {
2549	char * root = NULL;	FILE * deviceMap;
2550	int i;	char * line = NULL;
2551		size_t res = 0, len = 0;
2552		char * devicePtr;
2553		char * bounds = NULL;
2554		const char * path;
2555		const static char default_path[] = "/boot/grub/device.map";
2556
2557		if (!device) return 1;
2558		if (!bootPtr) return 1;
2559
2560		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2561		path = default_path;
2562
2563		dbgPrintf("opening grub device.map file from: %s\n", path);
2564		deviceMap = fopen(path, "r");
2565		if (!deviceMap)
2566		return 1;
2567
2568	printf("index=%d\n", index);	while ((res = getline(&line, &len, deviceMap)) != -1) {
2569		if (!strncmp(line, "#", 1))
2570		continue;
2571
2572	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	if (line[res - 1] == '\n')
2573	if (!line) {	line[res - 1] = '\0';
2574	printf("non linux entry\n");	else if (len > res)
2575	return;	line[res] = '\0';
2576		else {
2577		line = realloc(line, res + 1);
2578		line[res] = '\0';
2579		}
2580
2581		devicePtr = line;
2582		bounds = line + res;
2583
2584		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2585		devicePtr++;
2586		dbgPrintf("device: %s\n", devicePtr);
2587
2588		if (!strncmp(devicePtr, device, strlen(device))) {
2589		devicePtr += strlen(device);
2590		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2591		devicePtr++;
2592
2593		*bootPtr = strdup(devicePtr);
2594		break;
2595		}
2596	}	}
2597
2598	printf("kernel=%s\n", line->elements[1].item);	free(line);
2599		fclose(deviceMap);
2600		return 0;
2601		}
2602
2603	if (line->numElements >= 3) {	int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2604	printf("args=\"");	char * grubDevice;
	i = 2;
	while (i < line->numElements) {
	if (!strncmp(line->elements[i].item, "root=", 5)) {
	root = line->elements[i].item + 5;
	} else {
	printf("%s%s", line->elements[i].item,
	line->elements[i].indent);
	}
2605
2606	i++;	if (suseGrubConfGetInstallDevice(path, &grubDevice))
2607	}	dbgPrintf("error looking for grub installation device\n");
2608	printf("\"\n");	else
2609	} else {	dbgPrintf("grubby installation device: %s\n", grubDevice);
	line = getLineByType(LT_KERNELARGS, entry->lines);
	if (line) {
	char * s;
2610
2611	printf("args=\"");	if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2612	i = 1;	dbgPrintf("error looking for grub boot device\n");
2613	while (i < line->numElements) {	else
2614	if (!strncmp(line->elements[i].item, "root=", 5)) {	dbgPrintf("grubby boot device: %s\n", *bootPtr);
	root = line->elements[i].item + 5;
	} else {
	s = line->elements[i].item;
2615
2616	printf("%s%s", s, line->elements[i].indent);	free(grubDevice);
2617	}	return 0;
2618		}
2619
2620	i++;	int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2621	}	/*
2622		* This SuSE grub configuration file at this location is not your average
2623		* grub configuration file, but instead the grub commands used to setup
2624		* grub on that system.
2625		*/
2626		const char * path;
2627		const static char default_path[] = "/etc/grub.conf";
2628
2629	s = line->elements[i - 1].indent;	if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2630	printf("\"\n");	path = default_path;
	}
	}
2631
2632	if (!root) {	if (!isSuseGrubConf(path)) return 1;
	line = getLineByType(LT_ROOT, entry->lines);
	if (line && line->numElements >= 2)
	root=line->elements[1].item;
	}
2633
2634	if (root) {	if (lbaPtr) {
2635	char * s = alloca(strlen(root) + 1);	*lbaPtr = 0;
2636		if (suseGrubConfGetLba(path, lbaPtr))
2637	strcpy(s, root);	return 1;
	if (s[strlen(s) - 1] == '"')
	s[strlen(s) - 1] = '\0';
	/* make sure the root doesn't have a trailing " */
	printf("root=%s\n", s);
2638	}	}
2639
2640	line = getLineByType(LT_INITRD, entry->lines);	if (bootPtr) {
2641		*bootPtr = NULL;
2642	if (line && line->numElements >= 2) {	suseGrubConfGetBoot(path, bootPtr);
	printf("initrd=%s", prefix);
	for (i = 1; i < line->numElements; i++)
	printf("%s%s", line->elements[i].item, line->elements[i].indent);
	printf("\n");
2643	}	}
2644
2645		return 0;
2646	}	}
2647
2648	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
#	Line 1582  int parseSysconfigGrub(int * lbaPtr, cha	Line 2652  int parseSysconfigGrub(int * lbaPtr, cha
2652	char * start;	char * start;
2653	char * param;	char * param;
2654
2655	in = fopen("/etc/sysconfig/grub", "r");	in = fopen("/etc/conf.d/grub", "r");
2656	if (!in) return 1;	if (!in) return 1;
2657
2658	if (lbaPtr) *lbaPtr = 0;	if (lbaPtr) *lbaPtr = 0;
#	Line 1623  int parseSysconfigGrub(int * lbaPtr, cha	Line 2693  int parseSysconfigGrub(int * lbaPtr, cha
2693	}	}
2694
2695	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2696	char * boot;	char * boot = NULL;
2697	int lba;	int lba;
2698
2699	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2700	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2701	if (boot) printf("boot=%s\n", boot);	free(boot);
2702		return;
2703		}
2704		} else {
2705		if (parseSysconfigGrub(&lba, &boot)) {
2706		free(boot);
2707		return;
2708		}
2709		}
2710
2711		if (lba) printf("lba\n");
2712		if (boot) {
2713		printf("boot=%s\n", boot);
2714		free(boot);
2715	}	}
2716	}	}
2717
#	Line 1644  int displayInfo(struct grubConfig * conf	Line 2727  int displayInfo(struct grubConfig * conf
2727	return 1;	return 1;
2728	}	}
2729
2730	/* this is a horrible hack to support /etc/sysconfig/grub; there must	/* this is a horrible hack to support /etc/conf.d/grub; there must
2731	be a better way */	be a better way */
2732	if (config->cfi == &grubConfigType) {	if (config->cfi == &grubConfigType) {
2733	dumpSysconfigGrub();	dumpSysconfigGrub();
#	Line 1677  struct singleLine * addLineTmpl(struct s	Line 2760  struct singleLine * addLineTmpl(struct s
2760	{	{
2761	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2762
2763		if (isEfi && cfi == &grub2ConfigType) {
2764		enum lineType_e old = newLine->type;
2765		newLine->type = preferredLineType(newLine->type, cfi);
2766		if (old != newLine->type)
2767		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2768		}
2769
2770	if (val) {	if (val) {
2771	/* override the inherited value with our own.	/* override the inherited value with our own.
2772	* 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 1686  struct singleLine * addLineTmpl(struct s	Line 2776  struct singleLine * addLineTmpl(struct s
2776	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2777
2778	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2779	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)) {
2780	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2781	if (rootspec != NULL) {	if (rootspec != NULL) {
2782	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 1723  struct singleLine *  addLine(struct sing	Line 2813  struct singleLine *  addLine(struct sing
2813	/* 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
2814	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2815	*/	*/
2816	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2817	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2818	tmpl.type = type;	tmpl.type = type;
#	Line 1733  struct singleLine *  addLine(struct sing	Line 2822  struct singleLine *  addLine(struct sing
2822	sprintf(tmpl.elements[0].item, "[%s]", val);	sprintf(tmpl.elements[0].item, "[%s]", val);
2823	tmpl.elements[0].indent = "";	tmpl.elements[0].indent = "";
2824	val = NULL;	val = NULL;
2825		} else if (type == LT_MENUENTRY) {
2826		char *lineend = "--class gnu-linux --class gnu --class os {";
2827		if (!val) {
2828		fprintf(stderr, "Line type LT_MENUENTRY requires a value\n");
2829		abort();
2830		}
2831		kw = getKeywordByType(type, cfi);
2832		if (!kw) {
2833		fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
2834		abort();
2835		}
2836		tmpl.indent = "";
2837		tmpl.type = type;
2838		tmpl.numElements = 3;
2839		tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
2840		tmpl.elements[0].item = kw->key;
2841		tmpl.elements[0].indent = alloca(2);
2842		sprintf(tmpl.elements[0].indent, "%c", kw->nextChar);
2843		tmpl.elements[1].item = (char *)val;
2844		tmpl.elements[1].indent = alloca(2);
2845		sprintf(tmpl.elements[1].indent, "%c", kw->nextChar);
2846		tmpl.elements[2].item = alloca(strlen(lineend)+1);
2847		strcpy(tmpl.elements[2].item, lineend);
2848		tmpl.elements[2].indent = "";
2849	} else {	} else {
2850	kw = getKeywordByType(type, cfi);	kw = getKeywordByType(type, cfi);
2851	if (!kw) abort();	if (!kw) {
2852		fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
2853		abort();
2854		}
2855	tmpl.type = type;	tmpl.type = type;
2856	tmpl.numElements = val ? 2 : 1;	tmpl.numElements = val ? 2 : 1;
2857	tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);	tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
#	Line 1759  struct singleLine *  addLine(struct sing	Line 2875  struct singleLine *  addLine(struct sing
2875	if (!line->next && !prev) prev = line;	if (!line->next && !prev) prev = line;
2876	}	}
2877
2878	if (prev == entry->lines)	struct singleLine *menuEntry;
2879	tmpl.indent = defaultIndent ?: "";	menuEntry = getLineByType(LT_MENUENTRY, entry->lines);
2880	else	if (tmpl.type == LT_ENTRY_END) {
2881	tmpl.indent = prev->indent;	if (menuEntry)
2882		tmpl.indent = menuEntry->indent;
2883		else
2884		tmpl.indent = defaultIndent ?: "";
2885		} else if (tmpl.type != LT_MENUENTRY) {
2886		if (menuEntry)
2887		tmpl.indent = "\t";
2888		else if (prev == entry->lines)
2889		tmpl.indent = defaultIndent ?: "";
2890		else
2891		tmpl.indent = prev->indent;
2892		}
2893
2894	return addLineTmpl(entry, &tmpl, prev, val, cfi);	return addLineTmpl(entry, &tmpl, prev, val, cfi);
2895	}	}
#	Line 1789  void removeLine(struct singleEntry * ent	Line 2916  void removeLine(struct singleEntry * ent
2916	free(line);	free(line);
2917	}	}
2918
2919		static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
2920		{
2921		struct singleLine newLine = {
2922		.indent = tmplLine->indent,
2923		.type = tmplLine->type,
2924		.next = tmplLine->next,
2925		};
2926		int firstQuotedItem = -1;
2927		int quoteLen = 0;
2928		int j;
2929		int element = 0;
2930		char *c;
2931
2932		c = malloc(strlen(tmplLine->elements[0].item) + 1);
2933		strcpy(c, tmplLine->elements[0].item);
2934		insertElement(&newLine, c, element++, cfi);
2935		free(c);
2936		c = NULL;
2937
2938		for (j = 1; j < tmplLine->numElements; j++) {
2939		if (firstQuotedItem == -1) {
2940		quoteLen += strlen(tmplLine->elements[j].item);
2941
2942		if (isquote(tmplLine->elements[j].item[0])) {
2943		firstQuotedItem = j;
2944		quoteLen += strlen(tmplLine->elements[j].indent);
2945		} else {
2946		c = malloc(quoteLen + 1);
2947		strcpy(c, tmplLine->elements[j].item);
2948		insertElement(&newLine, c, element++, cfi);
2949		free(c);
2950		quoteLen = 0;
2951		}
2952		} else {
2953		int itemlen = strlen(tmplLine->elements[j].item);
2954		quoteLen += itemlen;
2955		quoteLen += strlen(tmplLine->elements[j].indent);
2956
2957		if (isquote(tmplLine->elements[j].item[itemlen - 1])) {
2958		c = malloc(quoteLen + 1);
2959		c[0] = '\0';
2960		for (int i = firstQuotedItem; i < j+1; i++) {
2961		strcat(c, tmplLine->elements[i].item);
2962		strcat(c, tmplLine->elements[i].indent);
2963		}
2964		insertElement(&newLine, c, element++, cfi);
2965		free(c);
2966
2967		firstQuotedItem = -1;
2968		quoteLen = 0;
2969		}
2970		}
2971		}
2972		while (tmplLine->numElements)
2973		removeElement(tmplLine, 0);
2974		if (tmplLine->elements)
2975		free(tmplLine->elements);
2976
2977		tmplLine->numElements = newLine.numElements;
2978		tmplLine->elements = newLine.elements;
2979		}
2980
2981	static void insertElement(struct singleLine * line,	static void insertElement(struct singleLine * line,
2982	const char * item, int insertHere,	const char * item, int insertHere,
2983	struct configFileInfo * cfi)	struct configFileInfo * cfi)
#	Line 1895  int updateActualImage(struct grubConfig	Line 3084  int updateActualImage(struct grubConfig
3084	const char ** arg;	const char ** arg;
3085	int useKernelArgs, useRoot;	int useKernelArgs, useRoot;
3086	int firstElement;	int firstElement;
3087	int *usedElements, *usedArgs;	int *usedElements;
3088	int doreplace;	int doreplace;
3089
3090	if (!image) return 0;	if (!image) return 0;
#	Line 1930  int updateActualImage(struct grubConfig	Line 3119  int updateActualImage(struct grubConfig
3119	useRoot = (getKeywordByType(LT_ROOT, cfg->cfi)	useRoot = (getKeywordByType(LT_ROOT, cfg->cfi)
3120	&& !multibootArgs);	&& !multibootArgs);
3121
	for (k = 0, arg = newArgs; *arg; arg++, k++) ;
	usedArgs = calloc(k, sizeof(*usedArgs));
3122	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3123
3124	if (multibootArgs && !entry->multiboot)	if (multibootArgs && !entry->multiboot)
#	Line 1960  int updateActualImage(struct grubConfig	Line 3146  int updateActualImage(struct grubConfig
3146	firstElement = 2;	firstElement = 2;
3147
3148	} else {	} else {
3149	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3150	if (!line) {	if (!line) {
3151	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3152	continue;	continue;
#	Line 2008  int updateActualImage(struct grubConfig	Line 3194  int updateActualImage(struct grubConfig
3194	usedElements = calloc(line->numElements, sizeof(*usedElements));	usedElements = calloc(line->numElements, sizeof(*usedElements));
3195
3196	for (k = 0, arg = newArgs; *arg; arg++, k++) {	for (k = 0, arg = newArgs; *arg; arg++, k++) {
	if (usedArgs[k]) continue;
3197
3198	doreplace = 1;	doreplace = 1;
3199	for (i = firstElement; i < line->numElements; i++) {	for (i = firstElement; i < line->numElements; i++) {
#	Line 2023  int updateActualImage(struct grubConfig	Line 3208  int updateActualImage(struct grubConfig
3208	continue;	continue;
3209	if (!argMatch(line->elements[i].item, *arg)) {	if (!argMatch(line->elements[i].item, *arg)) {
3210	usedElements[i]=1;	usedElements[i]=1;
	usedArgs[k]=1;
3211	break;	break;
3212	}	}
3213	}	}
#	Line 2093  int updateActualImage(struct grubConfig	Line 3277  int updateActualImage(struct grubConfig
3277	}	}
3278	}	}
3279
	free(usedArgs);
3280	free(newArgs);	free(newArgs);
3281	free(oldArgs);	free(oldArgs);
3282
#	Line 2119  int updateImage(struct grubConfig * cfg,	Line 3302  int updateImage(struct grubConfig * cfg,
3302	return rc;	return rc;
3303	}	}
3304
3305		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3306		const char * image, const char * prefix, const char * initrd) {
3307		struct singleEntry * entry;
3308		struct singleLine * line, * kernelLine, *endLine = NULL;
3309		int index = 0;
3310
3311		if (!image) return 0;
3312
3313		for (; (entry = findEntryByPath(cfg, newMBKernel, prefix, &index)); index++) {
3314		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3315		if (!kernelLine) continue;
3316
3317		if (prefix) {
3318		int prefixLen = strlen(prefix);
3319		if (!strncmp(initrd, prefix, prefixLen))
3320		initrd += prefixLen;
3321		}
3322		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3323		if (endLine)
3324		removeLine(entry, endLine);
3325		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3326		kernelLine->indent, initrd);
3327		if (!line)
3328		return 1;
3329		if (endLine) {
3330		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3331		if (!line)
3332		return 1;
3333		}
3334
3335		break;
3336		}
3337
3338		return 0;
3339		}
3340
3341		int updateInitrd(struct grubConfig * cfg, const char * image,
3342		const char * prefix, const char * initrd) {
3343		struct singleEntry * entry;
3344		struct singleLine * line, * kernelLine, *endLine = NULL;
3345		int index = 0;
3346
3347		if (!image) return 0;
3348
3349		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3350		kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3351		if (!kernelLine) continue;
3352
3353		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3354		if (line)
3355		removeLine(entry, line);
3356		if (prefix) {
3357		int prefixLen = strlen(prefix);
3358		if (!strncmp(initrd, prefix, prefixLen))
3359		initrd += prefixLen;
3360		}
3361		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3362		if (endLine)
3363		removeLine(entry, endLine);
3364		enum lineType_e lt;
3365		switch(kernelLine->type) {
3366		case LT_KERNEL:
3367		lt = LT_INITRD;
3368		break;
3369		case LT_KERNEL_EFI:
3370		lt = LT_INITRD_EFI;
3371		break;
3372		case LT_KERNEL_16:
3373		lt = LT_INITRD_16;
3374		break;
3375		default:
3376		lt = preferredLineType(LT_INITRD, cfg->cfi);
3377		}
3378		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3379		if (!line)
3380		return 1;
3381		if (endLine) {
3382		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3383		if (!line)
3384		return 1;
3385		}
3386
3387		break;
3388		}
3389
3390		return 0;
3391		}
3392
3393	int checkDeviceBootloader(const char * device, const unsigned char * boot) {	int checkDeviceBootloader(const char * device, const unsigned char * boot) {
3394	int fd;	int fd;
3395	unsigned char bootSect[512];	unsigned char bootSect[512];
#	Line 2142  int checkDeviceBootloader(const char * d	Line 3413  int checkDeviceBootloader(const char * d
3413	if (memcmp(boot, bootSect, 3))	if (memcmp(boot, bootSect, 3))
3414	return 0;	return 0;
3415
3416	if (boot[1] == 0xeb) {	if (boot[1] == JMP_SHORT_OPCODE) {
3417	offset = boot[2] + 2;	offset = boot[2] + 2;
3418	} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {	} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {
3419	offset = (boot[3] << 8) + boot[2] + 2;	offset = (boot[3] << 8) + boot[2] + 2;
3420	} else if (boot[0] == 0xeb) {	} else if (boot[0] == JMP_SHORT_OPCODE) {
3421	offset = boot[1] + 2;	offset = boot[1] + 2;
3422		/*
3423		* it looks like grub, when copying stage1 into the mbr, patches stage1
3424		* right after the JMP location, replacing other instructions such as
3425		* JMPs for NOOPs. So, relax the check a little bit by skipping those
3426		* different bytes.
3427		*/
3428		if ((bootSect[offset + 1] == NOOP_OPCODE)
3429		&& (bootSect[offset + 2] == NOOP_OPCODE)) {
3430		offset = offset + 3;
3431		}
3432	} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {	} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {
3433	offset = (boot[2] << 8) + boot[1] + 2;	offset = (boot[2] << 8) + boot[1] + 2;
3434	} else {	} else {
#	Line 2289  int checkForLilo(struct grubConfig * con	Line 3570  int checkForLilo(struct grubConfig * con
3570	return checkDeviceBootloader(line->elements[1].item, boot);	return checkDeviceBootloader(line->elements[1].item, boot);
3571	}	}
3572
3573		int checkForGrub2(struct grubConfig * config) {
3574		if (!access("/etc/grub.d/", R_OK))
3575		return 2;
3576
3577		return 1;
3578		}
3579
3580	int checkForGrub(struct grubConfig * config) {	int checkForGrub(struct grubConfig * config) {
3581	int fd;	int fd;
3582	unsigned char bootSect[512];	unsigned char bootSect[512];
3583	char * boot;	char * boot;
3584		int onSuse = isSuseSystem();
3585
3586	if (parseSysconfigGrub(NULL, &boot))
3587	return 0;	if (onSuse) {
3588		if (parseSuseGrubConf(NULL, &boot))
3589		return 0;
3590		} else {
3591		if (parseSysconfigGrub(NULL, &boot))
3592		return 0;
3593		}
3594
3595	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3596	if (!boot)	if (!boot)
#	Line 2314  int checkForGrub(struct grubConfig * con	Line 3609  int checkForGrub(struct grubConfig * con
3609	}	}
3610	close(fd);	close(fd);
3611
3612		/* The more elaborate checks do not work on SuSE. The checks done
3613		* seem to be reasonble (at least for now), so just return success
3614		*/
3615		if (onSuse)
3616		return 2;
3617
3618	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3619	}	}
3620
#	Line 2347  int checkForExtLinux(struct grubConfig *	Line 3648  int checkForExtLinux(struct grubConfig *
3648	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3649	}	}
3650
3651		int checkForYaboot(struct grubConfig * config) {
3652		/*
3653		* This is a simplistic check that we consider good enough for own puporses
3654		*
3655		* If we were to properly check if yaboot is *installed* we'd need to:
3656		* 1) get the system boot device (LT_BOOT)
3657		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3658		*    the content on the boot device
3659		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3660		* 4) check again if binary and boot device contents match
3661		*/
3662		if (!access("/etc/yaboot.conf", R_OK))
3663		return 2;
3664
3665		return 1;
3666		}
3667
3668		int checkForElilo(struct grubConfig * config) {
3669		if (!access("/etc/elilo.conf", R_OK))
3670		return 2;
3671
3672		return 1;
3673		}
3674
3675	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3676	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3677
#	Line 2361  static char * getRootSpecifier(char * st	Line 3686  static char * getRootSpecifier(char * st
3686	static char * getInitrdVal(struct grubConfig * config,	static char * getInitrdVal(struct grubConfig * config,
3687	const char * prefix, struct singleLine *tmplLine,	const char * prefix, struct singleLine *tmplLine,
3688	const char * newKernelInitrd,	const char * newKernelInitrd,
3689	char ** extraInitrds, int extraInitrdCount)	const char ** extraInitrds, int extraInitrdCount)
3690	{	{
3691	char *initrdVal, *end;	char *initrdVal, *end;
3692	int i;	int i;
#	Line 2406  static char * getInitrdVal(struct grubCo	Line 3731  static char * getInitrdVal(struct grubCo
3731
3732	int addNewKernel(struct grubConfig * config, struct singleEntry * template,	int addNewKernel(struct grubConfig * config, struct singleEntry * template,
3733	const char * prefix,	const char * prefix,
3734	char * newKernelPath, char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3735	char * newKernelArgs, char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3736	char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3737	char * newMBKernel, char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs,
3738		const char * newDevTreePath) {
3739	struct singleEntry * new;	struct singleEntry * new;
3740	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3741	int needs;	int needs;
#	Line 2450  int addNewKernel(struct grubConfig * con	Line 3776  int addNewKernel(struct grubConfig * con
3776	needs |= NEED_MB;	needs |= NEED_MB;
3777	new->multiboot = 1;	new->multiboot = 1;
3778	}	}
3779		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3780		needs |= NEED_DEVTREE;
3781
3782	if (template) {	if (template) {
3783	for (masterLine = template->lines;	for (masterLine = template->lines;
#	Line 2463  int addNewKernel(struct grubConfig * con	Line 3791  int addNewKernel(struct grubConfig * con
3791	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3792	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3793
3794	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3795	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3796	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3797	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 2541  int addNewKernel(struct grubConfig * con	Line 3868  int addNewKernel(struct grubConfig * con
3868	/* template is multi but new is not,	/* template is multi but new is not,
3869	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3870	*/	*/
3871	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3872	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3873	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3874	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3875		config->cfi)->key);
3876	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3877	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3878		config->cfi);
3879	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3880	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3881	char *initrdVal;	char *initrdVal;
3882	/* template is multi but new is not,	/* template is multi but new is not,
3883	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3884	*/	*/
3885	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3886	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3887	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3888	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3889		config->cfi)->key);
3890	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3891	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3892	free(initrdVal);	free(initrdVal);
3893	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3894	}	}
3895
3896	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3897	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3898	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3899	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 2590  int addNewKernel(struct grubConfig * con	Line 3919  int addNewKernel(struct grubConfig * con
3919	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3920	}	}
3921
3922		} else if (tmplLine->type == LT_MENUENTRY &&
3923		(needs & NEED_TITLE)) {
3924		requote(tmplLine, config->cfi);
3925		char *nkt = malloc(strlen(newKernelTitle)+3);
3926		strcpy(nkt, "'");
3927		strcat(nkt, newKernelTitle);
3928		strcat(nkt, "'");
3929		newLine = addLineTmpl(new, tmplLine, newLine, nkt, config->cfi);
3930		free(nkt);
3931		needs &= ~NEED_TITLE;
3932	} else if (tmplLine->type == LT_TITLE &&	} else if (tmplLine->type == LT_TITLE &&
3933	(needs & NEED_TITLE)) {	(needs & NEED_TITLE)) {
3934	if (tmplLine->numElements >= 2) {	if (tmplLine->numElements >= 2) {
#	Line 2603  int addNewKernel(struct grubConfig * con	Line 3942  int addNewKernel(struct grubConfig * con
3942	tmplLine->indent, newKernelTitle);	tmplLine->indent, newKernelTitle);
3943	needs &= ~NEED_TITLE;	needs &= ~NEED_TITLE;
3944	}	}
3945		} else if (tmplLine->type == LT_ECHO) {
3946		requote(tmplLine, config->cfi);
3947		static const char *prefix = "'Loading ";
3948		if (tmplLine->numElements > 1 &&
3949		strstr(tmplLine->elements[1].item, prefix) &&
3950		masterLine->next &&
3951		iskernel(masterLine->next->type)) {
3952		char *newTitle = malloc(strlen(prefix) +
3953		strlen(newKernelTitle) + 2);
3954
3955		strcpy(newTitle, prefix);
3956		strcat(newTitle, newKernelTitle);
3957		strcat(newTitle, "'");
3958		newLine = addLine(new, config->cfi, LT_ECHO,
3959		tmplLine->indent, newTitle);
3960		free(newTitle);
3961		} else {
3962		/* pass through other lines from the template */
3963		newLine = addLineTmpl(new, tmplLine, newLine, NULL,
3964		config->cfi);
3965		}
3966		} else if (tmplLine->type == LT_DEVTREE &&
3967		tmplLine->numElements == 2 && newDevTreePath) {
3968		newLine = addLineTmpl(new, tmplLine, newLine,
3969		newDevTreePath + strlen(prefix),
3970		config->cfi);
3971		needs &= ~NEED_DEVTREE;
3972		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
3973		const char *ndtp = newDevTreePath;
3974		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
3975		ndtp += strlen(prefix);
3976		newLine = addLine(new, config->cfi, LT_DEVTREE,
3977		config->secondaryIndent,
3978		ndtp);
3979		needs &= ~NEED_DEVTREE;
3980		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
3981	} else {	} else {
3982	/* pass through other lines from the template */	/* pass through other lines from the template */
3983	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
#	Line 2614  int addNewKernel(struct grubConfig * con	Line 3988  int addNewKernel(struct grubConfig * con
3988	/* don't have a template, so start the entry with the	/* don't have a template, so start the entry with the
3989	* appropriate starting line	* appropriate starting line
3990	*/	*/
3991	switch (config->cfi->entrySeparator) {	switch (config->cfi->entryStart) {
3992	case LT_KERNEL:	case LT_KERNEL:
3993		case LT_KERNEL_EFI:
3994		case LT_KERNEL_16:
3995	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
3996	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
3997	} else {	} else {
3998	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
3999		preferredLineType(LT_KERNEL, config->cfi),
4000	config->primaryIndent,	config->primaryIndent,
4001	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4002	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 2633  int addNewKernel(struct grubConfig * con	Line 4010  int addNewKernel(struct grubConfig * con
4010	needs &= ~NEED_MB;	needs &= ~NEED_MB;
4011	break;	break;
4012
4013		case LT_MENUENTRY: {
4014		char *nkt = malloc(strlen(newKernelTitle)+3);
4015		strcpy(nkt, "'");
4016		strcat(nkt, newKernelTitle);
4017		strcat(nkt, "'");
4018		newLine = addLine(new, config->cfi, LT_MENUENTRY,
4019		config->primaryIndent, nkt);
4020		free(nkt);
4021		needs &= ~NEED_TITLE;
4022		needs |= NEED_END;
4023		break;
4024		}
4025	case LT_TITLE:	case LT_TITLE:
4026	if( useextlinuxmenu != 0 ){ // We just need useextlinuxmenu to not be zero (set above)	if( useextlinuxmenu != 0 ){ // We just need useextlinuxmenu to not be zero (set above)
4027	char * templabel;	char * templabel;
#	Line 2666  int addNewKernel(struct grubConfig * con	Line 4055  int addNewKernel(struct grubConfig * con
4055
4056	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4057	* 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,
4058	* all the lines following the entrySeparator.	* all the lines following the entryStart.
4059	*/	*/
4060	if (needs & NEED_TITLE) {	if (needs & NEED_TITLE) {
4061	newLine = addLine(new, config->cfi, LT_TITLE,	newLine = addLine(new, config->cfi, LT_TITLE,
#	Line 2683  int addNewKernel(struct grubConfig * con	Line 4072  int addNewKernel(struct grubConfig * con
4072	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
4073	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4074	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4075	config->cfi)) ?	config->cfi))
4076	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
4077		: preferredLineType(LT_KERNEL, config->cfi),
4078	config->secondaryIndent,	config->secondaryIndent,
4079	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4080	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 2700  int addNewKernel(struct grubConfig * con	Line 4090  int addNewKernel(struct grubConfig * con
4090	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4091	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4092	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4093	config->cfi)) ?	config->cfi))
4094	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
4095		: preferredLineType(LT_INITRD, config->cfi),
4096	config->secondaryIndent,	config->secondaryIndent,
4097	initrdVal);	initrdVal);
4098	free(initrdVal);	free(initrdVal);
4099	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4100	}	}
4101		if (needs & NEED_DEVTREE) {
4102		newLine = addLine(new, config->cfi, LT_DEVTREE,
4103		config->secondaryIndent,
4104		newDevTreePath);
4105		needs &= ~NEED_DEVTREE;
4106		}
4107
4108		/* NEEDS_END must be last on bootloaders that need it... */
4109		if (needs & NEED_END) {
4110		newLine = addLine(new, config->cfi, LT_ENTRY_END,
4111		config->secondaryIndent, NULL);
4112		needs &= ~NEED_END;
4113		}
4114	if (needs) {	if (needs) {
4115	printf(_("grubby: needs=%d, aborting\n"), needs);	printf(_("grubby: needs=%d, aborting\n"), needs);
4116	abort();	abort();
#	Line 2728  static void traceback(int signum)	Line 4131  static void traceback(int signum)
4131	memset(array, '\0', sizeof (array));	memset(array, '\0', sizeof (array));
4132	size = backtrace(array, 40);	size = backtrace(array, 40);
4133
4134	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",	fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4135	(unsigned long)size);	(unsigned long)size);
4136	backtrace_symbols_fd(array, size, STDERR_FILENO);	backtrace_symbols_fd(array, size, STDERR_FILENO);
4137	exit(1);	exit(1);
#	Line 2736  static void traceback(int signum)	Line 4139  static void traceback(int signum)
4139
4140	int main(int argc, const char ** argv) {	int main(int argc, const char ** argv) {
4141	poptContext optCon;	poptContext optCon;
4142	char * grubConfig = NULL;	const char * grubConfig = NULL;
4143	char * outputFile = NULL;	char * outputFile = NULL;
4144	int arg = 0;	int arg = 0;
4145	int flags = 0;	int flags = 0;
4146	int badImageOkay = 0;	int badImageOkay = 0;
4147		int configureGrub2 = 0;
4148	int configureLilo = 0, configureELilo = 0, configureGrub = 0;	int configureLilo = 0, configureELilo = 0, configureGrub = 0;
4149	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;
4150	int configureExtLinux = 0;	int configureExtLinux = 0;
#	Line 2752  int main(int argc, const char ** argv) {	Line 4156  int main(int argc, const char ** argv) {
4156	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4157	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4158	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4159	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4160	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4161	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4162	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 2762  int main(int argc, const char ** argv) {	Line 4166  int main(int argc, const char ** argv) {
4166	char * removeArgs = NULL;	char * removeArgs = NULL;
4167	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4168	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4169		char * envPath = NULL;
4170	const char * chptr = NULL;	const char * chptr = NULL;
4171	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4172	struct grubConfig * config;	struct grubConfig * config;
4173	struct singleEntry * template = NULL;	struct singleEntry * template = NULL;
4174	int copyDefault = 0, makeDefault = 0;	int copyDefault = 0, makeDefault = 0;
4175	int displayDefault = 0;	int displayDefault = 0;
4176		int displayDefaultIndex = 0;
4177		int displayDefaultTitle = 0;
4178		int defaultIndex = -1;
4179	struct poptOption options[] = {	struct poptOption options[] = {
4180	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4181	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 2785  int main(int argc, const char ** argv) {	Line 4193  int main(int argc, const char ** argv) {
4193	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4194	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4195	_("bootfs") },	_("bootfs") },
4196	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4197	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4198	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4199	#endif	#endif
4200	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4201	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
#	Line 2798  int main(int argc, const char ** argv) {	Line 4206  int main(int argc, const char ** argv) {
4206	"the kernel referenced by the default image does not exist, "	"the kernel referenced by the default image does not exist, "
4207	"the first linux entry whose kernel does exist is used as the "	"the first linux entry whose kernel does exist is used as the "
4208	"template"), NULL },	"template"), NULL },
4209		{ "debug", 0, 0, &debug, 0,
4210		_("print debugging information for failures") },
4211	{ "default-kernel", 0, 0, &displayDefault, 0,	{ "default-kernel", 0, 0, &displayDefault, 0,
4212	_("display the path of the default kernel") },	_("display the path of the default kernel") },
4213		{ "default-index", 0, 0, &displayDefaultIndex, 0,
4214		_("display the index of the default kernel") },
4215		{ "default-title", 0, 0, &displayDefaultTitle, 0,
4216		_("display the title of the default kernel") },
4217		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4218		_("device tree file for new stanza"), _("dtb-path") },
4219	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4220	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4221		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4222		_("force grub2 stanzas to use efi") },
4223		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4224		_("path for environment data"),
4225		_("path") },
4226	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4227	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4228	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
4229	_("configure grub bootloader") },	_("configure grub bootloader") },
4230		{ "grub2", 0, POPT_ARG_NONE, &configureGrub2, 0,
4231		_("configure grub2 bootloader") },
4232	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,
4233	_("display boot information for specified kernel"),	_("display boot information for specified kernel"),
4234	_("kernel-path") },	_("kernel-path") },
4235	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4236	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4237	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4238	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4239	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4240	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4241	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 2832  int main(int argc, const char ** argv) {	Line 4255  int main(int argc, const char ** argv) {
4255	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4256	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4257	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4258		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4259		_("make the given entry index the default entry"),
4260		_("entry-index") },
4261	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4262	_("configure silo bootloader") },	_("configure silo bootloader") },
4263	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 2853  int main(int argc, const char ** argv) {	Line 4279  int main(int argc, const char ** argv) {
4279
4280	signal(SIGSEGV, traceback);	signal(SIGSEGV, traceback);
4281
4282		int i = 0;
4283		for (int j = 1; j < argc; j++)
4284		i += strlen(argv[j]) + 1;
4285		saved_command_line = malloc(i);
4286		if (!saved_command_line) {
4287		fprintf(stderr, "grubby: %m\n");
4288		exit(1);
4289		}
4290		saved_command_line[0] = '\0';
4291		for (int j = 1; j < argc; j++) {
4292		strcat(saved_command_line, argv[j]);
4293		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4294		}
4295
4296	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4297	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4298
#	Line 2885  int main(int argc, const char ** argv) {	Line 4325  int main(int argc, const char ** argv) {
4325	return 1;	return 1;
4326	}	}
4327
4328	if ((configureLilo + configureGrub + configureELilo +	if ((configureLilo + configureGrub2 + configureGrub + configureELilo +
4329	configureYaboot + configureSilo + configureZipl +	configureYaboot + configureSilo + configureZipl +
4330	configureExtLinux ) > 1) {	configureExtLinux ) > 1) {
4331	fprintf(stderr, _("grubby: cannot specify multiple bootloaders\n"));	fprintf(stderr, _("grubby: cannot specify multiple bootloaders\n"));
#	Line 2894  int main(int argc, const char ** argv) {	Line 4334  int main(int argc, const char ** argv) {
4334	fprintf(stderr,	fprintf(stderr,
4335	_("grubby: cannot specify config file with --bootloader-probe\n"));	_("grubby: cannot specify config file with --bootloader-probe\n"));
4336	return 1;	return 1;
4337		} else if (configureGrub2) {
4338		cfi = &grub2ConfigType;
4339		if (envPath)
4340		cfi->envFile = envPath;
4341	} else if (configureLilo) {	} else if (configureLilo) {
4342	cfi = &liloConfigType;	cfi = &liloConfigType;
4343	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 2912  int main(int argc, const char ** argv) {	Line 4356  int main(int argc, const char ** argv) {
4356	}	}
4357
4358	if (!cfi) {	if (!cfi) {
4359		if (grub2FindConfig(&grub2ConfigType))
4360		cfi = &grub2ConfigType;
4361		else
4362	#ifdef __ia64__	#ifdef __ia64__
4363	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4364	#elif __powerpc__	#elif __powerpc__
4365	cfi = &yabootConfigType;	cfi = &yabootConfigType;
4366	#elif __sparc__	#elif __sparc__
4367	cfi = &siloConfigType;	cfi = &siloConfigType;
4368	#elif __s390__	#elif __s390__
4369	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4370	#elif __s390x__	#elif __s390x__
4371	cfi = &ziplConfigtype;	cfi = &ziplConfigtype;
4372	#else	#else
4373	cfi = &grubConfigType;	cfi = &grubConfigType;
4374	#endif	#endif
4375	}	}
4376
4377	if (!grubConfig)	if (!grubConfig) {
4378	grubConfig = cfi->defaultConfig;	if (cfi->findConfig)
4379		grubConfig = cfi->findConfig(cfi);
4380		if (!grubConfig)
4381		grubConfig = cfi->defaultConfig;
4382		}
4383
4384	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4385	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4386	defaultKernel)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4387		(defaultIndex >= 0))) {
4388	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4389	"specified option"));	"specified option"));
4390	return 1;	return 1;
4391	}	}
4392
4393	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4394	removeKernelPath)) {	removeKernelPath)) {
4395	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4396	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 2948  int main(int argc, const char ** argv) {	Line 4400  int main(int argc, const char ** argv) {
4400	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4401	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4402	return 1;	return 1;
4403	} else if (!newKernelPath && (newKernelTitle  || newKernelInitrd ||	} else if (!newKernelPath && (newKernelTitle  || copyDefault ||
4404	newKernelInitrd || copyDefault     ||	(newKernelInitrd && !updateKernelPath)||
4405	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4406	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
4407	return 1;	return 1;
#	Line 2974  int main(int argc, const char ** argv) {	Line 4426  int main(int argc, const char ** argv) {
4426	makeDefault = 1;	makeDefault = 1;
4427	defaultKernel = NULL;	defaultKernel = NULL;
4428	}	}
4429		else if (defaultKernel && (defaultIndex >= 0)) {
4430		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4431		"may not be used together\n"));
4432		return 1;
4433		}
4434
4435	if (!strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4436	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
4437	"is used\n"));	"is used\n"));
4438	return 1;	return 1;
4439	}	}
4440
4441	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4442	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4443	&& !removeMBKernel) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4444		&& (defaultIndex == -1)) {
4445	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4446	return 1;	return 1;
4447	}	}
#	Line 3010  int main(int argc, const char ** argv) {	Line 4468  int main(int argc, const char ** argv) {
4468	}	}
4469
4470	if (bootloaderProbe) {	if (bootloaderProbe) {
4471	int lrc = 0, grc = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4472	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4473
4474		const char *grub2config = grub2FindConfig(&grub2ConfigType);
4475		if (grub2config) {
4476		gconfig = readConfig(grub2config, &grub2ConfigType);
4477		if (!gconfig)
4478		gr2c = 1;
4479		else
4480		gr2c = checkForGrub2(gconfig);
4481		}
4482
4483	if (!access(grubConfigType.defaultConfig, F_OK)) {	const char *grubconfig = grubFindConfig(&grubConfigType);
4484	gconfig = readConfig(grubConfigType.defaultConfig, &grubConfigType);	if (!access(grubconfig, F_OK)) {
4485		gconfig = readConfig(grubconfig, &grubConfigType);
4486	if (!gconfig)	if (!gconfig)
4487	grc = 1;	grc = 1;
4488	else	else
#	Line 3029  int main(int argc, const char ** argv) {	Line 4497  int main(int argc, const char ** argv) {
4497	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4498	}	}
4499
4500		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4501		econfig = readConfig(eliloConfigType.defaultConfig,
4502		&eliloConfigType);
4503		if (!econfig)
4504		erc = 1;
4505		else
4506		erc = checkForElilo(econfig);
4507		}
4508
4509	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4510	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4511	if (!lconfig)	if (!lconfig)
4512	erc = 1;	extrc = 1;
4513	else	else
4514	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4515	}	}
4516
4517	if (lrc == 1 || grc == 1) return 1;
4518		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4519		yconfig = readConfig(yabootConfigType.defaultConfig,
4520		&yabootConfigType);
4521		if (!yconfig)
4522		yrc = 1;
4523		else
4524		yrc = checkForYaboot(yconfig);
4525		}
4526
4527		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4528		erc == 1)
4529		return 1;
4530
4531	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4532		if (gr2c == 2) printf("grub2\n");
4533	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4534	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4535		if (yrc == 2) printf("yaboot\n");
4536		if (erc == 2) printf("elilo\n");
4537
4538	return 0;	return 0;
4539	}	}
4540
4541		if (grubConfig == NULL) {
4542		printf("Could not find bootloader configuration file.\n");
4543		exit(1);
4544		}
4545
4546	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4547	if (!config) return 1;	if (!config) return 1;
4548
#	Line 3055  int main(int argc, const char ** argv) {	Line 4552  int main(int argc, const char ** argv) {
4552	char * rootspec;	char * rootspec;
4553
4554	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4555		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4556		cfi->defaultIsSaved)
4557		config->defaultImage = 0;
4558	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4559	if (!entry) return 0;	if (!entry) return 0;
4560	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4561
4562	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4563	if (!line) return 0;	if (!line) return 0;
4564
4565	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3067  int main(int argc, const char ** argv) {	Line 4567  int main(int argc, const char ** argv) {
4567	((rootspec != NULL) ? strlen(rootspec) : 0));	((rootspec != NULL) ? strlen(rootspec) : 0));
4568
4569	return 0;	return 0;
4570
4571		} else if (displayDefaultTitle) {
4572		struct singleLine * line;
4573		struct singleEntry * entry;
4574
4575		if (config->defaultImage == -1) return 0;
4576		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4577		cfi->defaultIsSaved)
4578		config->defaultImage = 0;
4579		entry = findEntryByIndex(config, config->defaultImage);
4580		if (!entry) return 0;
4581
4582		if (!configureGrub2) {
4583		line = getLineByType(LT_TITLE, entry->lines);
4584		if (!line) return 0;
4585		printf("%s\n", line->elements[1].item);
4586
4587		} else {
4588		char * title;
4589
4590		dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
4591		line = getLineByType(LT_MENUENTRY, entry->lines);
4592		if (!line) return 0;
4593		title = grub2ExtractTitle(line);
4594		if (title)
4595		printf("%s\n", title);
4596		}
4597		return 0;
4598
4599		} else if (displayDefaultIndex) {
4600		if (config->defaultImage == -1) return 0;
4601		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4602		cfi->defaultIsSaved)
4603		config->defaultImage = 0;
4604		printf("%i\n", config->defaultImage);
4605		return 0;
4606
4607	} else if (kernelInfo)	} else if (kernelInfo)
4608	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
4609
#	Line 3078  int main(int argc, const char ** argv) {	Line 4615  int main(int argc, const char ** argv) {
4615	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4616	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4617	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4618	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4619	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4620	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4621	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4622		if (updateKernelPath && newKernelInitrd) {
4623		if (newMBKernel) {
4624		if (addMBInitrd(config, newMBKernel, updateKernelPath,
4625		bootPrefix, newKernelInitrd))
4626		return 1;
4627		} else {
4628		if (updateInitrd(config, updateKernelPath, bootPrefix,
4629		newKernelInitrd))
4630		return 1;
4631		}
4632		}
4633	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4634	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4635	extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4636	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4637
4638
4639	if (numEntries(config) == 0) {	if (numEntries(config) == 0) {
#	Line 3095  int main(int argc, const char ** argv) {	Line 4643  int main(int argc, const char ** argv) {
4643	}	}
4644
4645	if (!outputFile)	if (!outputFile)
4646	outputFile = grubConfig;	outputFile = (char *)grubConfig;
4647
4648	return writeConfig(config, outputFile, bootPrefix);	return writeConfig(config, outputFile, bootPrefix);
4649	}	}

---

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

Legend: Removed from v.914   changed lines   Added in v.2708