Diff of /trunk/grubby/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 2992 by niro, Thu Jun 30 10:35:14 2016 UTC
#	Line 36	Line 36
36	#include <signal.h>	#include <signal.h>
37	#include <blkid/blkid.h>	#include <blkid/blkid.h>
38
39		#include "log.h"
40
41		#ifndef DEBUG
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 */	.titlePosition = 1,
226	1,                                      /* mbInitRdIsModule */	};
227	0,                                      /* mbConcatArgs */
228	1,                                      /* mbAllowExtraInitRds */	struct keywordTypes grub2Keywords[] = {
229		{ "menuentry",  LT_MENUENTRY,   ' ' },
230		{ "}",          LT_ENTRY_END,   ' ' },
231		{ "echo",       LT_ECHO,        ' ' },
232		{ "set",        LT_SET_VARIABLE,' ', '=' },
233		{ "root",       LT_BOOTROOT,    ' ' },
234		{ "default",    LT_DEFAULT,     ' ' },
235		{ "fallback",   LT_FALLBACK,    ' ' },
236		{ "linux",      LT_KERNEL,      ' ' },
237		{ "linuxefi",   LT_KERNEL_EFI,  ' ' },
238		{ "linux16",    LT_KERNEL_16,   ' ' },
239		{ "initrd",     LT_INITRD,      ' ', ' ' },
240		{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
241		{ "initrd16",   LT_INITRD_16,   ' ', ' ' },
242		{ "module",     LT_MBMODULE,    ' ' },
243		{ "kernel",     LT_HYPER,       ' ' },
244		{ "devicetree", LT_DEVTREE,  ' ' },
245		{ NULL, 0, 0 },
246		};
247
248		const char *grub2FindConfig(struct configFileInfo *cfi) {
249		static const char *configFiles[] = {
250		"/boot/grub/grub-efi.cfg",
251		"/boot/grub/grub.cfg",
252		NULL
253		};
254		static int i = -1;
255		static const char *grub_cfg = "/boot/grub/grub.cfg";
256		int rc = -1;
257
258		if (i == -1) {
259		for (i = 0; configFiles[i] != NULL; i++) {
260		dbgPrintf("Checking \"%s\": ", configFiles[i]);
261		if ((rc = access(configFiles[i], R_OK))) {
262		if (errno == EACCES) {
263		printf("Unable to access bootloader configuration file "
264		"\"%s\": %m\n", configFiles[i]);
265		exit(1);
266		}
267		continue;
268		} else {
269		dbgPrintf("found\n");
270		return configFiles[i];
271		}
272		}
273		}
274
275		/* Ubuntu renames grub2 to grub, so check for the grub.d directory
276		* that isn't in grub1, and if it exists, return the config file path
277		* that they use. */
278		if (configFiles[i] == NULL && !access("/etc/grub.d/", R_OK)) {
279		dbgPrintf("found\n");
280		return grub_cfg;
281		}
282
283		dbgPrintf("not found\n");
284		return configFiles[i];
285		}
286
287		/* kind of hacky.  It'll give the first 1024 bytes, ish. */
288		static char *grub2GetEnv(struct configFileInfo *info, char *name)
289		{
290		static char buf[1025];
291		char *s = NULL;
292		char *ret = NULL;
293		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
294		int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
295
296		if (rc < 0)
297		return NULL;
298
299		FILE *f = popen(s, "r");
300		if (!f)
301		goto out;
302
303		memset(buf, '\0', sizeof (buf));
304		ret = fgets(buf, 1024, f);
305		pclose(f);
306
307		if (ret) {
308		ret += strlen(name) + 1;
309		ret[strlen(ret) - 1] = '\0';
310		}
311		dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
312		out:
313		free(s);
314		return ret;
315		}
316
317		static int sPopCount(const char *s, const char *c)
318		{
319		int ret = 0;
320		if (!s)
321		return -1;
322		for (int i = 0; s[i] != '\0'; i++)
323		for (int j = 0; c[j] != '\0'; j++)
324		if (s[i] == c[j])
325		ret++;
326		return ret;
327		}
328
329		static char *shellEscape(const char *s)
330		{
331		int l = strlen(s) + sPopCount(s, "'") * 2;
332
333		char *ret = calloc(l+1, sizeof (*ret));
334		if (!ret)
335		return NULL;
336		for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
337		if (s[i] == '\'')
338		ret[j++] = '\\';
339		ret[j] = s[i];
340		}
341		return ret;
342		}
343
344		static void unquote(char *s)
345		{
346		int l = strlen(s);
347
348		if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
349		memmove(s, s+1, l-2);
350		s[l-2] = '\0';
351		}
352		}
353
354		static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
355		{
356		char *s = NULL;
357		int rc = 0;
358		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
359
360		unquote(value);
361		value = shellEscape(value);
362		if (!value)
363		return -1;
364
365		rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
366		free(value);
367		if (rc <0)
368		return -1;
369
370		dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
371		rc = system(s);
372		free(s);
373		return rc;
374		}
375
376		/* this is a gigantic hack to avoid clobbering grub2 variables... */
377		static int is_special_grub2_variable(const char *name)
378		{
379		if (!strcmp(name,"\"${next_entry}\""))
380		return 1;
381		if (!strcmp(name,"\"${prev_saved_entry}\""))
382		return 1;
383		return 0;
384		}
385
386		int sizeOfSingleLine(struct singleLine * line) {
387		int count = 0;
388
389		for (int i = 0; i < line->numElements; i++) {
390		int indentSize = 0;
391
392		count = count + strlen(line->elements[i].item);
393
394		indentSize = strlen(line->elements[i].indent);
395		if (indentSize > 0)
396		count = count + indentSize;
397		else
398		/* be extra safe and add room for whitespaces */
399		count = count + 1;
400		}
401
402		/* room for trailing terminator */
403		count = count + 1;
404
405		return count;
406		}
407
408		static int isquote(char q)
409		{
410		if (q == '\'' || q == '\"')
411		return 1;
412		return 0;
413		}
414
415		static int iskernel(enum lineType_e type) {
416		return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
417		}
418
419		static int isinitrd(enum lineType_e type) {
420		return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
421		}
422
423		char *grub2ExtractTitle(struct singleLine * line) {
424		char * current;
425		char * current_indent;
426		int current_len;
427		int current_indent_len;
428		int i;
429
430		/* bail out if line does not start with menuentry */
431		if (strcmp(line->elements[0].item, "menuentry"))
432		return NULL;
433
434		i = 1;
435		current = line->elements[i].item;
436		current_len = strlen(current);
437
438		/* if second word is quoted, strip the quotes and return single word */
439		if (isquote(*current) && isquote(current[current_len - 1])) {
440		char *tmp;
441
442		tmp = strdup(current+1);
443		if (!tmp)
444		return NULL;
445		tmp[strlen(tmp)-1] = '\0';
446		return tmp;
447		}
448
449		/* if no quotes, return second word verbatim */
450		if (!isquote(*current))
451		return current;
452
453		/* second element start with a quote, so we have to find the element
454		* whose last character is also quote (assuming it's the closing one) */
455		int resultMaxSize;
456		char * result;
457		/* need to ensure that ' does not match " as we search */
458		char quote_char = *current;
459
460		resultMaxSize = sizeOfSingleLine(line);
461		result = malloc(resultMaxSize);
462		snprintf(result, resultMaxSize, "%s", ++current);
463
464		i++;
465		for (; i < line->numElements; ++i) {
466		current = line->elements[i].item;
467		current_len = strlen(current);
468		current_indent = line->elements[i].indent;
469		current_indent_len = strlen(current_indent);
470
471		strncat(result, current_indent, current_indent_len);
472		if (current[current_len-1] != quote_char) {
473		strncat(result, current, current_len);
474		} else {
475		strncat(result, current, current_len - 1);
476		break;
477		}
478		}
479		return result;
480		}
481
482		struct configFileInfo grub2ConfigType = {
483		.findConfig = grub2FindConfig,
484		.getEnv = grub2GetEnv,
485		.setEnv = grub2SetEnv,
486		.keywords = grub2Keywords,
487		.defaultIsIndex = 1,
488		.defaultSupportSaved = 1,
489		.defaultIsVariable = 1,
490		.entryStart = LT_MENUENTRY,
491		.entryEnd = LT_ENTRY_END,
492		.titlePosition = 1,
493		.needsBootPrefix = 1,
494		.mbHyperFirst = 1,
495		.mbInitRdIsModule = 1,
496		.mbAllowExtraInitRds = 1,
497	};	};
498
499	struct keywordTypes yabootKeywords[] = {	struct keywordTypes yabootKeywords[] = {
#	Line 245  struct keywordTypes extlinuxKeywords[] =	Line 587  struct keywordTypes extlinuxKeywords[] =
587	{ "initrd",    LT_INITRD,      ' ', ',' },	{ "initrd",    LT_INITRD,      ' ', ',' },
588	{ "append",    LT_KERNELARGS,  ' ' },	{ "append",    LT_KERNELARGS,  ' ' },
589	{ "prompt",     LT_UNKNOWN,     ' ' },	{ "prompt",     LT_UNKNOWN,     ' ' },
590		{ "fdt",        LT_DEVTREE,     ' ' },
591		{ "fdtdir",     LT_DEVTREE,     ' ' },
592	{ NULL,    0, 0 },	{ NULL,    0, 0 },
593	};	};
594	int useextlinuxmenu;	int useextlinuxmenu;
595	struct configFileInfo eliloConfigType = {	struct configFileInfo eliloConfigType = {
596	"/boot/efi/EFI/redhat/elilo.conf",    /* defaultConfig */	.defaultConfig = "/boot/efi/EFI/redhat/elilo.conf",
597	eliloKeywords,    /* keywords */	.keywords = eliloKeywords,
598	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
599	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
600	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
601	1,                    /* needsBootPrefix */	.mbConcatArgs = 1,
602	1,    /* argsInQuotes */	.titlePosition = 1,
	0,    /* maxTitleLength */
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	1,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
603	};	};
604
605	struct configFileInfo liloConfigType = {	struct configFileInfo liloConfigType = {
606	"/etc/lilo.conf",    /* defaultConfig */	.defaultConfig = "/etc/lilo.conf",
607	liloKeywords,    /* keywords */	.keywords = liloKeywords,
608	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
609	0,    /* defaultSupportSaved */	.argsInQuotes = 1,
610	LT_KERNEL,    /* entrySeparator */	.maxTitleLength = 15,
611	0,    /* needsBootPrefix */	.titlePosition = 1,
	1,    /* argsInQuotes */
	15,    /* maxTitleLength */
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
612	};	};
613
614	struct configFileInfo yabootConfigType = {	struct configFileInfo yabootConfigType = {
615	"/etc/yaboot.conf",    /* defaultConfig */	.defaultConfig = "/etc/yaboot.conf",
616	yabootKeywords,    /* keywords */	.keywords = yabootKeywords,
617	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
618	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
619	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
620	1,    /* needsBootPrefix */	.maxTitleLength = 15,
621	1,    /* argsInQuotes */	.mbAllowExtraInitRds = 1,
622	15,    /* maxTitleLength */	.titlePosition = 1,
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	1,                                      /* mbAllowExtraInitRds */
623	};	};
624
625	struct configFileInfo siloConfigType = {	struct configFileInfo siloConfigType = {
626	"/etc/silo.conf",    /* defaultConfig */	.defaultConfig = "/etc/silo.conf",
627	siloKeywords,    /* keywords */	.keywords = siloKeywords,
628	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
629	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
630	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
631	1,    /* needsBootPrefix */	.maxTitleLength = 15,
632	1,    /* argsInQuotes */	.titlePosition = 1,
	15,    /* maxTitleLength */
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
633	};	};
634
635	struct configFileInfo ziplConfigType = {	struct configFileInfo ziplConfigType = {
636	"/etc/zipl.conf",    /* defaultConfig */	.defaultConfig = "/etc/zipl.conf",
637	ziplKeywords,    /* keywords */	.keywords = ziplKeywords,
638	0,    /* defaultIsIndex */	.entryStart = LT_TITLE,
639	0,    /* defaultSupportSaved */	.argsInQuotes = 1,
640	LT_TITLE,    /* entrySeparator */	.titleBracketed = 1,
	0,    /* needsBootPrefix */
	1,    /* argsInQuotes */
	0,    /* maxTitleLength */
	1,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
641	};	};
642
643	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
644	"/boot/extlinux/extlinux.conf",         /* defaultConfig */	.defaultConfig = "/boot/extlinux/extlinux.conf",
645	extlinuxKeywords,                       /* keywords */	.keywords = extlinuxKeywords,
646	0,                                      /* defaultIsIndex */	.caseInsensitive = 1,
647	0,                                      /* defaultSupportSaved */	.entryStart = LT_TITLE,
648	LT_TITLE,                               /* entrySeparator */	.needsBootPrefix = 1,
649	1,                                      /* needsBootPrefix */	.maxTitleLength = 255,
650	0,                                      /* argsInQuotes */	.mbAllowExtraInitRds = 1,
651	255,                                    /* maxTitleLength */	.defaultIsUnquoted = 1,
652	0,                                      /* titleBracketed */	.titlePosition = 1,
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	1,                                      /* mbAllowExtraInitRds */
653	};	};
654
655	struct grubConfig {	struct grubConfig {
#	Line 356  struct grubConfig {	Line 664  struct grubConfig {
664	struct configFileInfo * cfi;	struct configFileInfo * cfi;
665	};	};
666
667		blkid_cache blkid;
668
669	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index);	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index);
670	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
671	const char * path, const char * prefix,	const char * path, const char * prefix,
672	int * index);	int * index);
673		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
674		int * index);
675	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
676	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
677	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 369  static int lineWrite(FILE * out, struct	Line 681  static int lineWrite(FILE * out, struct
681	static int getNextLine(char ** bufPtr, struct singleLine * line,	static int getNextLine(char ** bufPtr, struct singleLine * line,
682	struct configFileInfo * cfi);	struct configFileInfo * cfi);
683	static char * getRootSpecifier(char * str);	static char * getRootSpecifier(char * str);
684		static void requote(struct singleLine *line, struct configFileInfo * cfi);
685	static void insertElement(struct singleLine * line,	static void insertElement(struct singleLine * line,
686	const char * item, int insertHere,	const char * item, int insertHere,
687	struct configFileInfo * cfi);	struct configFileInfo * cfi);
#	Line 423  static char * sdupprintf(const char *for	Line 736  static char * sdupprintf(const char *for
736	return buf;	return buf;
737	}	}
738
739		static enum lineType_e preferredLineType(enum lineType_e type,
740		struct configFileInfo *cfi) {
741		if (isEfi && cfi == &grub2ConfigType) {
742		switch (type) {
743		case LT_KERNEL:
744		return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
745		case LT_INITRD:
746		return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
747		default:
748		return type;
749		}
750		#if defined(__i386__) || defined(__x86_64__)
751		} else if (cfi == &grub2ConfigType) {
752		switch (type) {
753		case LT_KERNEL:
754		return LT_KERNEL_16;
755		case LT_INITRD:
756		return LT_INITRD_16;
757		default:
758		return type;
759		}
760		#endif
761		}
762		return type;
763		}
764
765	static struct keywordTypes * getKeywordByType(enum lineType_e type,	static struct keywordTypes * getKeywordByType(enum lineType_e type,
766	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
767	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
	for (kw = cfi->keywords; kw->key; kw++) {
768	if (kw->type == type)	if (kw->type == type)
769	return kw;	return kw;
770	}	}
771	return NULL;	return NULL;
772	}	}
773
774	static char * getpathbyspec(char *device) {	static char *getKeyByType(enum lineType_e type, struct configFileInfo * cfi) {
775	static blkid_cache blkid;	struct keywordTypes *kt = getKeywordByType(type, cfi);
776		if (kt)
777		return kt->key;
778		return "unknown";
779		}
780
781		static char * getpathbyspec(char *device) {
782	if (!blkid)	if (!blkid)
783	blkid_get_cache(&blkid, NULL);	blkid_get_cache(&blkid, NULL);
784
785	return blkid_get_devname(blkid, device, NULL);	return blkid_get_devname(blkid, device, NULL);
786	}	}
787
788		static char * getuuidbydev(char *device) {
789		if (!blkid)
790		blkid_get_cache(&blkid, NULL);
791
792		return blkid_get_tag_value(blkid, "UUID", device);
793		}
794
795	static enum lineType_e getTypeByKeyword(char * keyword,	static enum lineType_e getTypeByKeyword(char * keyword,
796	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
797	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
798	for (kw = cfi->keywords; kw->key; kw++) {	if (cfi->caseInsensitive) {
799	if (!strcmp(keyword, kw->key))	if (!strcasecmp(keyword, kw->key))
800	return kw->type;	return kw->type;
801		} else {
802		if (!strcmp(keyword, kw->key))
803		return kw->type;
804		}
805	}	}
806	return LT_UNKNOWN;	return LT_UNKNOWN;
807	}	}
#	Line 477  static int isBracketedTitle(struct singl	Line 831  static int isBracketedTitle(struct singl
831	return 0;	return 0;
832	}	}
833
834	static int isEntrySeparator(struct singleLine * line,	static int isEntryStart(struct singleLine * line,
835	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
836	return line->type == cfi->entrySeparator || line->type == LT_OTHER ||	return line->type == cfi->entryStart || line->type == LT_OTHER ||
837	(cfi->titleBracketed && isBracketedTitle(line));	(cfi->titleBracketed && isBracketedTitle(line));
838	}	}
839
840	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
841	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct grubConfig *cfg, struct singleLine * line) {
842	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it */
843	char * title;	char * title = NULL;
844	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
845	title++;	char *tmp = line->elements[cfg->cfi->titlePosition].item;
846	*(title + strlen(title) - 1) = '\0';	if (cfg->cfi->titleBracketed) {
847		tmp++;
848		title = strdup(tmp);
849		*(title + strlen(title) - 1) = '\0';
850		} else {
851		title = strdup(tmp);
852		}
853		} else if (line->type == LT_MENUENTRY)
854		title = strdup(line->elements[1].item);
855		else
856		return NULL;
857	return title;	return title;
858	}	}
859
#	Line 532  static void lineInit(struct singleLine *	Line 896  static void lineInit(struct singleLine *
896	}	}
897
898	struct singleLine * lineDup(struct singleLine * line) {	struct singleLine * lineDup(struct singleLine * line) {
	int i;
899	struct singleLine * newLine = malloc(sizeof(*newLine));	struct singleLine * newLine = malloc(sizeof(*newLine));
900
901	newLine->indent = strdup(line->indent);	newLine->indent = strdup(line->indent);
#	Line 542  struct singleLine * lineDup(struct singl	Line 905  struct singleLine * lineDup(struct singl
905	newLine->elements = malloc(sizeof(*newLine->elements) *	newLine->elements = malloc(sizeof(*newLine->elements) *
906	newLine->numElements);	newLine->numElements);
907
908	for (i = 0; i < newLine->numElements; i++) {	for (int i = 0; i < newLine->numElements; i++) {
909	newLine->elements[i].indent = strdup(line->elements[i].indent);	newLine->elements[i].indent = strdup(line->elements[i].indent);
910	newLine->elements[i].item = strdup(line->elements[i].item);	newLine->elements[i].item = strdup(line->elements[i].item);
911	}	}
#	Line 551  struct singleLine * lineDup(struct singl	Line 914  struct singleLine * lineDup(struct singl
914	}	}
915
916	static void lineFree(struct singleLine * line) {	static void lineFree(struct singleLine * line) {
	int i;
917	if (line->indent) free(line->indent);	if (line->indent) free(line->indent);
918
919	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
920	free(line->elements[i].item);	free(line->elements[i].item);
921	free(line->elements[i].indent);	free(line->elements[i].indent);
922	}	}
#	Line 566  static void lineFree(struct singleLine *	Line 927  static void lineFree(struct singleLine *
927
928	static int lineWrite(FILE * out, struct singleLine * line,	static int lineWrite(FILE * out, struct singleLine * line,
929	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
	int i;
930	if (fprintf(out, "%s", line->indent) == -1) return -1;	if (fprintf(out, "%s", line->indent) == -1) return -1;
931
932	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
933		/* Need to handle this, because we strip the quotes from
934		* menuentry when read it. */
935		if (line->type == LT_MENUENTRY && i == 1) {
936		if(!isquote(*line->elements[i].item)) {
937		int substring = 0;
938		/* If the line contains nested quotes, we did not strip
939		* the "interna" quotes and we must use the right quotes
940		* again when writing the updated file. */
941		for (int j = i; j < line->numElements; j++) {
942		if (strchr(line->elements[i].item, '\'') != NULL) {
943		substring = 1;
944		fprintf(out, "\"%s\"", line->elements[i].item);
945		break;
946		}
947		}
948		if (!substring)
949		fprintf(out, "\'%s\'", line->elements[i].item);
950		} else {
951		fprintf(out, "%s", line->elements[i].item);
952		}
953		fprintf(out, "%s", line->elements[i].indent);
954
955		continue;
956		}
957
958	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
959	if (fputc('"', out) == EOF) return -1;	if (fputc('"', out) == EOF) return -1;
960
#	Line 664  static int getNextLine(char ** bufPtr, s	Line 1048  static int getNextLine(char ** bufPtr, s
1048	if (*line->elements[0].item == '#') {	if (*line->elements[0].item == '#') {
1049	char * fullLine;	char * fullLine;
1050	int len;	int len;
	int i;
1051
1052	len = strlen(line->indent);	len = strlen(line->indent);
1053	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1054	len += strlen(line->elements[i].item) +	len += strlen(line->elements[i].item) +
1055	strlen(line->elements[i].indent);	strlen(line->elements[i].indent);
1056
#	Line 676  static int getNextLine(char ** bufPtr, s	Line 1059  static int getNextLine(char ** bufPtr, s
1059	free(line->indent);	free(line->indent);
1060	line->indent = fullLine;	line->indent = fullLine;
1061
1062	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1063	strcat(fullLine, line->elements[i].item);	strcat(fullLine, line->elements[i].item);
1064	strcat(fullLine, line->elements[i].indent);	strcat(fullLine, line->elements[i].indent);
1065	free(line->elements[i].item);	free(line->elements[i].item);
#	Line 695  static int getNextLine(char ** bufPtr, s	Line 1078  static int getNextLine(char ** bufPtr, s
1078	* elements up more	* elements up more
1079	*/	*/
1080	if (!isspace(kw->separatorChar)) {	if (!isspace(kw->separatorChar)) {
	int i;
1081	char indent[2] = "";	char indent[2] = "";
1082	indent[0] = kw->separatorChar;	indent[0] = kw->separatorChar;
1083	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1084	char *p;	char *p;
	int j;
1085	int numNewElements;	int numNewElements;
1086
1087	numNewElements = 0;	numNewElements = 0;
#	Line 716  static int getNextLine(char ** bufPtr, s	Line 1097  static int getNextLine(char ** bufPtr, s
1097	sizeof(*line->elements) * elementsAlloced);	sizeof(*line->elements) * elementsAlloced);
1098	}	}
1099
1100	for (j = line->numElements; j > i; j--) {	for (int j = line->numElements; j > i; j--) {
1101	line->elements[j + numNewElements] = line->elements[j];	line->elements[j + numNewElements] = line->elements[j];
1102	}	}
1103	line->numElements += numNewElements;	line->numElements += numNewElements;
#	Line 729  static int getNextLine(char ** bufPtr, s	Line 1110  static int getNextLine(char ** bufPtr, s
1110	break;	break;
1111	}	}
1112
1113	free(line->elements[i].indent);	line->elements[i + 1].indent = line->elements[i].indent;
1114	line->elements[i].indent = strdup(indent);	line->elements[i].indent = strdup(indent);
1115	*p++ = '\0';	*p++ = '\0';
1116	i++;	i++;
1117	line->elements[i].item = strdup(p);	line->elements[i].item = strdup(p);
	line->elements[i].indent = strdup("");
	p = line->elements[i].item;
1118	}	}
1119	}	}
1120	}	}
#	Line 745  static int getNextLine(char ** bufPtr, s	Line 1124  static int getNextLine(char ** bufPtr, s
1124	return 0;	return 0;
1125	}	}
1126
1127		static int isnumber(const char *s)
1128		{
1129		int i;
1130		for (i = 0; s[i] != '\0'; i++)
1131		if (s[i] < '0' || s[i] > '9')
1132		return 0;
1133		return i;
1134		}
1135
1136	static struct grubConfig * readConfig(const char * inName,	static struct grubConfig * readConfig(const char * inName,
1137	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
1138	int in;	int in;
#	Line 756  static struct grubConfig * readConfig(co	Line 1144  static struct grubConfig * readConfig(co
1144	struct singleLine * last = NULL, * line, * defaultLine = NULL;	struct singleLine * last = NULL, * line, * defaultLine = NULL;
1145	char * end;	char * end;
1146	struct singleEntry * entry = NULL;	struct singleEntry * entry = NULL;
1147	int i, len;	int len;
1148	char * buf;	char * buf;
1149
1150	if (!strcmp(inName, "-")) {	if (inName == NULL) {
1151		printf("Could not find bootloader configuration\n");
1152		exit(1);
1153		} else if (!strcmp(inName, "-")) {
1154	in = 0;	in = 0;
1155	} else {	} else {
1156	if ((in = open(inName, O_RDONLY)) < 0) {	if ((in = open(inName, O_RDONLY)) < 0) {
#	Line 802  static struct grubConfig * readConfig(co	Line 1193  static struct grubConfig * readConfig(co
1193	cfg->secondaryIndent = strdup(line->indent);	cfg->secondaryIndent = strdup(line->indent);
1194	}	}
1195
1196	if (isEntrySeparator(line, cfi)) {	if (isEntryStart(line, cfi) || (cfg->entries && !sawEntry)) {
1197	sawEntry = 1;	sawEntry = 1;
1198	if (!entry) {	if (!entry) {
1199	cfg->entries = malloc(sizeof(*entry));	cfg->entries = malloc(sizeof(*entry));
#	Line 818  static struct grubConfig * readConfig(co	Line 1209  static struct grubConfig * readConfig(co
1209	entry->next = NULL;	entry->next = NULL;
1210	}	}
1211
1212	if (line->type == LT_DEFAULT && line->numElements == 2) {	if (line->type == LT_SET_VARIABLE) {
1213	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	dbgPrintf("found 'set' command (%d elements): ", line->numElements);
1214	defaultLine = line;	dbgPrintf("%s", line->indent);
1215		for (int i = 0; i < line->numElements; i++)
1216		dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
1217		dbgPrintf("\n");
1218		struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1219		if (kwType && line->numElements == 3 &&
1220		!strcmp(line->elements[1].item, kwType->key) &&
1221		!is_special_grub2_variable(line->elements[2].item)) {
1222		dbgPrintf("Line sets default config\n");
1223		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1224		defaultLine = line;
1225		}
1226
1227	} else if (line->type == LT_KERNEL) {	} else if (iskernel(line->type)) {
1228	/* if by some freak chance this is multiboot and the "module"	/* if by some freak chance this is multiboot and the "module"
1229	* lines came earlier in the template, make sure to use LT_HYPER	* lines came earlier in the template, make sure to use LT_HYPER
1230	* instead of LT_KERNEL now	* instead of LT_KERNEL now
1231	*/	*/
1232	if (entry->multiboot)	if (entry && entry->multiboot)
1233	line->type = LT_HYPER;	line->type = LT_HYPER;
1234
1235	} else if (line->type == LT_MBMODULE) {	} else if (line->type == LT_MBMODULE) {
#	Line 836  static struct grubConfig * readConfig(co	Line 1238  static struct grubConfig * readConfig(co
1238	* This only applies to grub, but that's the only place we	* This only applies to grub, but that's the only place we
1239	* should find LT_MBMODULE lines anyway.	* should find LT_MBMODULE lines anyway.
1240	*/	*/
1241	struct singleLine * l;	for (struct singleLine *l = entry->lines; l; l = l->next) {
	for (l = entry->lines; l; l = l->next) {
1242	if (l->type == LT_HYPER)	if (l->type == LT_HYPER)
1243	break;	break;
1244	else if (l->type == LT_KERNEL) {	else if (iskernel(l->type)) {
1245	l->type = LT_HYPER;	l->type = LT_HYPER;
1246	break;	break;
1247	}	}
#	Line 854  static struct grubConfig * readConfig(co	Line 1255  static struct grubConfig * readConfig(co
1255	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1256	if (*end) cfg->fallbackImage = -1;	if (*end) cfg->fallbackImage = -1;
1257
1258	} else if (line->type == LT_TITLE && line->numElements > 1) {	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1259	/* make the title a single argument (undoing our parsing) */	(line->type == LT_TITLE && line->numElements > 1)) {
1260		/* make the title/default a single argument (undoing our parsing) */
1261	len = 0;	len = 0;
1262	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1263	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
1264	len += strlen(line->elements[i].indent);	len += strlen(line->elements[i].indent);
1265	}	}
1266	buf = malloc(len + 1);	buf = malloc(len + 1);
1267	*buf = '\0';	*buf = '\0';
1268
1269	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1270	strcat(buf, line->elements[i].item);	strcat(buf, line->elements[i].item);
1271	free(line->elements[i].item);	free(line->elements[i].item);
1272
#	Line 878  static struct grubConfig * readConfig(co	Line 1280  static struct grubConfig * readConfig(co
1280	line->elements[line->numElements - 1].indent;	line->elements[line->numElements - 1].indent;
1281	line->elements[1].item = buf;	line->elements[1].item = buf;
1282	line->numElements = 2;	line->numElements = 2;
1283		} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
1284		/* let --remove-kernel="TITLE=what" work */
1285		len = 0;
1286		char *extras;
1287		char *title;
1288		/* initially unseen value */
1289		char quote_char = '\0';
1290
1291		for (int i = 1; i < line->numElements; i++) {
1292		len += strlen(line->elements[i].item);
1293		len += strlen(line->elements[i].indent);
1294		}
1295		buf = malloc(len + 1);
1296		*buf = '\0';
1297
1298		/* allocate mem for extra flags. */
1299		extras = malloc(len + 1);
1300		*extras = '\0';
1301
1302		/* get title. */
1303		for (int i = 0; i < line->numElements; i++) {
1304		if (!strcmp(line->elements[i].item, "menuentry"))
1305		continue;
1306		if (isquote(*line->elements[i].item) && quote_char == '\0') {
1307		/* ensure we properly pair off quotes */
1308		quote_char = *line->elements[i].item;
1309		title = line->elements[i].item + 1;
1310		} else {
1311		title = line->elements[i].item;
1312		}
1313
1314		len = strlen(title);
1315		if (title[len-1] == quote_char) {
1316		strncat(buf, title,len-1);
1317		break;
1318		} else {
1319		strcat(buf, title);
1320		strcat(buf, line->elements[i].indent);
1321		}
1322		}
1323
1324		/* get extras */
1325		int count = 0;
1326		quote_char = '\0';
1327		for (int i = 0; i < line->numElements; i++) {
1328		if (count >= 2) {
1329		strcat(extras, line->elements[i].item);
1330		strcat(extras, line->elements[i].indent);
1331		}
1332
1333		if (!strcmp(line->elements[i].item, "menuentry"))
1334		continue;
1335
1336		/* count ' or ", there should be two in menuentry line. */
1337		if (isquote(*line->elements[i].item) && quote_char == '\0') {
1338		/* ensure we properly pair off quotes */
1339		quote_char = *line->elements[i].item;
1340		count++;
1341		}
1342
1343		len = strlen(line->elements[i].item);
1344
1345		if (line->elements[i].item[len -1] == quote_char)
1346		count++;
1347
1348		/* ok, we get the final ' or ", others are extras. */
1349		}
1350		line->elements[1].indent =
1351		line->elements[line->numElements - 2].indent;
1352		line->elements[1].item = buf;
1353		line->elements[2].indent =
1354		line->elements[line->numElements - 2].indent;
1355		line->elements[2].item = extras;
1356		line->numElements = 3;
1357	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
1358	/* Strip off any " which may be present; they'll be put back	/* Strip off any " which may be present; they'll be put back
1359	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 1362  static struct grubConfig * readConfig(co
1362	if (line->numElements >= 2) {	if (line->numElements >= 2) {
1363	int last, len;	int last, len;
1364
1365	if (*line->elements[1].item == '"')	if (isquote(*line->elements[1].item))
1366	memmove(line->elements[1].item, line->elements[1].item + 1,	memmove(line->elements[1].item, line->elements[1].item + 1,
1367	strlen(line->elements[1].item + 1) + 1);	strlen(line->elements[1].item + 1) + 1);
1368
1369	last = line->numElements - 1;	last = line->numElements - 1;
1370	len = strlen(line->elements[last].item) - 1;	len = strlen(line->elements[last].item) - 1;
1371	if (line->elements[last].item[len] == '"')	if (isquote(line->elements[last].item[len]))
1372	line->elements[last].item[len] = '\0';	line->elements[last].item[len] = '\0';
1373	}	}
1374	}	}
1375
1376		if (line->type == LT_DEFAULT && line->numElements == 2) {
1377		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1378		defaultLine = line;
1379		}
1380
1381	/* If we find a generic config option which should live at the	/* If we find a generic config option which should live at the
1382	top of the file, move it there. Old versions of grubby were	top of the file, move it there. Old versions of grubby were
1383	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 1411  static struct grubConfig * readConfig(co
1411	entry->lines = line;	entry->lines = line;
1412	else	else
1413	last->next = line;	last->next = line;
1414	dbgPrintf("readConfig added %d to %p\n", line->type, entry);	dbgPrintf("readConfig added %s to %p\n", getKeyByType(line->type, cfi), entry);
1415
1416		/* we could have seen this outside of an entry... if so, we
1417		* ignore it like any other line we don't grok */
1418		if (line->type == LT_ENTRY_END && sawEntry)
1419		sawEntry = 0;
1420	} else {	} else {
1421	if (!cfg->theLines)	if (!cfg->theLines)
1422	cfg->theLines = line;	cfg->theLines = line;
1423	else	else
1424	last->next = line;	last->next = line;
1425	dbgPrintf("readConfig added %d to cfg\n", line->type);	dbgPrintf("readConfig added %s to cfg\n", getKeyByType(line->type, cfi));
1426	}	}
1427
1428	last = line;	last = line;
#	Line 945  static struct grubConfig * readConfig(co	Line 1430  static struct grubConfig * readConfig(co
1430
1431	free(incoming);	free(incoming);
1432
1433		dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");
1434	if (defaultLine) {	if (defaultLine) {
1435	if (cfi->defaultSupportSaved &&	if (defaultLine->numElements > 2 &&
1436		cfi->defaultSupportSaved &&
1437		!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1438		cfg->cfi->defaultIsSaved = 1;
1439		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1440		if (cfg->cfi->getEnv) {
1441		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1442		if (defTitle) {
1443		int index = 0;
1444		if (isnumber(defTitle)) {
1445		index = atoi(defTitle);
1446		entry = findEntryByIndex(cfg, index);
1447		} else {
1448		entry = findEntryByTitle(cfg, defTitle, &index);
1449		}
1450		if (entry)
1451		cfg->defaultImage = index;
1452		}
1453		}
1454		} else if (cfi->defaultIsVariable) {
1455		char *value = defaultLine->elements[2].item;
1456		while (*value && (*value == '"' || *value == '\'' ||
1457		*value == ' ' || *value == '\t'))
1458		value++;
1459		cfg->defaultImage = strtol(value, &end, 10);
1460		while (*end && (*end == '"' || *end == '\'' ||
1461		*end == ' ' || *end == '\t'))
1462		end++;
1463		if (*end) cfg->defaultImage = -1;
1464		} else if (cfi->defaultSupportSaved &&
1465	!strncmp(defaultLine->elements[1].item, "saved", 5)) {	!strncmp(defaultLine->elements[1].item, "saved", 5)) {
1466	cfg->defaultImage = DEFAULT_SAVED;	cfg->defaultImage = DEFAULT_SAVED;
1467	} else if (cfi->defaultIsIndex) {	} else if (cfi->defaultIsIndex) {
1468	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
1469	if (*end) cfg->defaultImage = -1;	if (*end) cfg->defaultImage = -1;
1470	} else if (defaultLine->numElements >= 2) {	} else if (defaultLine->numElements >= 2) {
1471	i = 0;	int i = 0;
1472	while ((entry = findEntryByIndex(cfg, i))) {	while ((entry = findEntryByIndex(cfg, i))) {
1473	for (line = entry->lines; line; line = line->next)	for (line = entry->lines; line; line = line->next)
1474	if (line->type == LT_TITLE) break;	if (line->type == LT_TITLE) break;
#	Line 964  static struct grubConfig * readConfig(co	Line 1479  static struct grubConfig * readConfig(co
1479	line->elements[1].item)) break;	line->elements[1].item)) break;
1480	} else if (line) {	} else if (line) {
1481	if (!strcmp(defaultLine->elements[1].item,	if (!strcmp(defaultLine->elements[1].item,
1482	extractTitle(line))) break;	extractTitle(cfg, line))) break;
1483	}	}
1484	i++;	i++;
1485	entry = NULL;	entry = NULL;
#	Line 976  static struct grubConfig * readConfig(co	Line 1491  static struct grubConfig * readConfig(co
1491	cfg->defaultImage = -1;	cfg->defaultImage = -1;
1492	}	}
1493	}	}
1494		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1495		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1496		if (defTitle) {
1497		int index = 0;
1498		if (isnumber(defTitle)) {
1499		index = atoi(defTitle);
1500		entry = findEntryByIndex(cfg, index);
1501		} else {
1502		entry = findEntryByTitle(cfg, defTitle, &index);
1503		}
1504		if (entry)
1505		cfg->defaultImage = index;
1506		}
1507	} else {	} else {
1508	cfg->defaultImage = 0;	cfg->defaultImage = 0;
1509	}	}
#	Line 993  static void writeDefault(FILE * out, cha	Line 1521  static void writeDefault(FILE * out, cha
1521
1522	if (cfg->defaultImage == DEFAULT_SAVED)	if (cfg->defaultImage == DEFAULT_SAVED)
1523	fprintf(out, "%sdefault%ssaved\n", indent, separator);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1524	else if (cfg->defaultImage > -1) {	else if (cfg->cfi->defaultIsSaved) {
1525		fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1526		if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1527		char *title;
1528		entry = findEntryByIndex(cfg, cfg->defaultImage);
1529		line = getLineByType(LT_MENUENTRY, entry->lines);
1530		if (!line)
1531		line = getLineByType(LT_TITLE, entry->lines);
1532		if (line) {
1533		title = extractTitle(cfg, line);
1534		if (title)
1535		cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1536		}
1537		}
1538		} else if (cfg->defaultImage > -1) {
1539	if (cfg->cfi->defaultIsIndex) {	if (cfg->cfi->defaultIsIndex) {
1540	fprintf(out, "%sdefault%s%d\n", indent, separator,	if (cfg->cfi->defaultIsVariable) {
1541	cfg->defaultImage);	fprintf(out, "%sset default=\"%d\"\n", indent,
1542		cfg->defaultImage);
1543		} else {
1544		fprintf(out, "%sdefault%s%d\n", indent, separator,
1545		cfg->defaultImage);
1546		}
1547	} else {	} else {
1548	int image = cfg->defaultImage;	int image = cfg->defaultImage;
1549
#	Line 1021  static void writeDefault(FILE * out, cha	Line 1568  static void writeDefault(FILE * out, cha
1568	else if (line && (line->numElements == 1) &&	else if (line && (line->numElements == 1) &&
1569	cfg->cfi->titleBracketed) {	cfg->cfi->titleBracketed) {
1570	fprintf(out, "%sdefault%s%s\n", indent, separator,	fprintf(out, "%sdefault%s%s\n", indent, separator,
1571	extractTitle(line));	extractTitle(cfg, line));
1572	}	}
1573	}	}
1574	}	}
#	Line 1048  static int writeConfig(struct grubConfig	Line 1595  static int writeConfig(struct grubConfig
1595
1596	/* most likely the symlink is relative, so change our	/* most likely the symlink is relative, so change our
1597	directory to the dir of the symlink */	directory to the dir of the symlink */
1598	rc = chdir(dirname(strdupa(outName)));	char *dir = strdupa(outName);
1599		rc = chdir(dirname(dir));
1600	do {	do {
1601	buf = alloca(len + 1);	buf = alloca(len + 1);
1602	rc = readlink(basename(outName), buf, len);	rc = readlink(basename(outName), buf, len);
#	Line 1086  static int writeConfig(struct grubConfig	Line 1634  static int writeConfig(struct grubConfig
1634	}	}
1635
1636	line = cfg->theLines;	line = cfg->theLines;
1637		struct keywordTypes *defaultKw = getKeywordByType(LT_DEFAULT, cfg->cfi);
1638	while (line) {	while (line) {
1639	if (line->type == LT_DEFAULT) {	if (line->type == LT_SET_VARIABLE && defaultKw &&
1640		line->numElements == 3 &&
1641		!strcmp(line->elements[1].item, defaultKw->key) &&
1642		!is_special_grub2_variable(line->elements[2].item)) {
1643		writeDefault(out, line->indent, line->elements[0].indent, cfg);
1644		needs &= ~MAIN_DEFAULT;
1645		} else if (line->type == LT_DEFAULT) {
1646	writeDefault(out, line->indent, line->elements[0].indent, cfg);	writeDefault(out, line->indent, line->elements[0].indent, cfg);
1647	needs &= ~MAIN_DEFAULT;	needs &= ~MAIN_DEFAULT;
1648	} else if (line->type == LT_FALLBACK) {	} else if (line->type == LT_FALLBACK) {
#	Line 1155  static int numEntries(struct grubConfig	Line 1710  static int numEntries(struct grubConfig
1710	return i;	return i;
1711	}	}
1712
1713		static char *findDiskForRoot()
1714		{
1715		int fd;
1716		char buf[65536];
1717		char *devname;
1718		char *chptr;
1719		int rc;
1720
1721		if ((fd = open(_PATH_MOUNTED, O_RDONLY)) < 0) {
1722		fprintf(stderr, "grubby: failed to open %s: %s\n",
1723		_PATH_MOUNTED, strerror(errno));
1724		return NULL;
1725		}
1726
1727		rc = read(fd, buf, sizeof(buf) - 1);
1728		if (rc <= 0) {
1729		fprintf(stderr, "grubby: failed to read %s: %s\n",
1730		_PATH_MOUNTED, strerror(errno));
1731		close(fd);
1732		return NULL;
1733		}
1734		close(fd);
1735		buf[rc] = '\0';
1736		chptr = buf;
1737
1738		char *foundanswer = NULL;
1739
1740		while (chptr && chptr != buf+rc) {
1741		devname = chptr;
1742
1743		/*
1744		* The first column of a mtab entry is the device, but if the entry is a
1745		* special device it won't start with /, so move on to the next line.
1746		*/
1747		if (*devname != '/') {
1748		chptr = strchr(chptr, '\n');
1749		if (chptr)
1750		chptr++;
1751		continue;
1752		}
1753
1754		/* Seek to the next space */
1755		chptr = strchr(chptr, ' ');
1756		if (!chptr) {
1757		fprintf(stderr, "grubby: error parsing %s: %s\n",
1758		_PATH_MOUNTED, strerror(errno));
1759		return NULL;
1760		}
1761
1762		/*
1763		* The second column of a mtab entry is the mount point, we are looking
1764		* for '/' obviously.
1765		*/
1766		if (*(++chptr) == '/' && *(++chptr) == ' ') {
1767		/* remember the last / entry in mtab */
1768		foundanswer = devname;
1769		}
1770
1771		/* Next line */
1772		chptr = strchr(chptr, '\n');
1773		if (chptr)
1774		chptr++;
1775		}
1776
1777		/* Return the last / entry found */
1778		if (foundanswer) {
1779		chptr = strchr(foundanswer, ' ');
1780		*chptr = '\0';
1781		return strdup(foundanswer);
1782		}
1783
1784		return NULL;
1785		}
1786
1787		void printEntry(struct singleEntry * entry, FILE *f) {
1788		int i;
1789		struct singleLine * line;
1790
1791		for (line = entry->lines; line; line = line->next) {
1792		log_message(f, "DBG: %s", line->indent);
1793		for (i = 0; i < line->numElements; i++) {
1794		/* Need to handle this, because we strip the quotes from
1795		* menuentry when read it. */
1796		if (line->type == LT_MENUENTRY && i == 1) {
1797		if(!isquote(*line->elements[i].item))
1798		log_message(f, "\'%s\'", line->elements[i].item);
1799		else
1800		log_message(f, "%s", line->elements[i].item);
1801		log_message(f, "%s", line->elements[i].indent);
1802
1803		continue;
1804		}
1805
1806		log_message(f, "%s%s",
1807		line->elements[i].item, line->elements[i].indent);
1808		}
1809		log_message(f, "\n");
1810		}
1811		}
1812
1813		void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1814		{
1815		static int once;
1816		va_list argp, argq;
1817
1818		va_start(argp, fmt);
1819
1820		va_copy(argq, argp);
1821		if (!once) {
1822		log_time(NULL);
1823		log_message(NULL, "command line: %s\n", saved_command_line);
1824		}
1825		log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1826		log_vmessage(NULL, fmt, argq);
1827
1828		printEntry(entry, NULL);
1829		va_end(argq);
1830
1831		if (!debug) {
1832		once = 1;
1833		va_end(argp);
1834		return;
1835		}
1836
1837		if (okay) {
1838		va_end(argp);
1839		return;
1840		}
1841
1842		if (!once)
1843		log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1844		once = 1;
1845		fprintf(stderr, "DBG: Image entry failed: ");
1846		vfprintf(stderr, fmt, argp);
1847		printEntry(entry, stderr);
1848		va_end(argp);
1849		}
1850
1851		#define beginswith(s, c) ((s) && (s)[0] == (c))
1852
1853		static int endswith(const char *s, char c)
1854		{
1855		int slen;
1856
1857		if (!s || !s[0])
1858		return 0;
1859		slen = strlen(s) - 1;
1860
1861		return s[slen] == c;
1862		}
1863
1864	int suitableImage(struct singleEntry * entry, const char * bootPrefix,	int suitableImage(struct singleEntry * entry, const char * bootPrefix,
1865	int skipRemoved, int flags) {	int skipRemoved, int flags) {
1866	struct singleLine * line;	struct singleLine * line;
1867	char * fullName;	char * fullName;
1868	int i;	int i;
	struct stat sb, sb2;
1869	char * dev;	char * dev;
1870	char * rootspec;	char * rootspec;
1871		char * rootdev;
1872
1873	if (skipRemoved && entry->skip) return 0;	if (skipRemoved && entry->skip) {
1874		notSuitablePrintf(entry, 0, "marked to skip\n");
1875		return 0;
1876		}
1877
1878	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1879	if (!line || line->numElements < 2) return 0;	if (!line) {
1880		notSuitablePrintf(entry, 0, "no line found\n");
1881		return 0;
1882		}
1883		if (line->numElements < 2) {
1884		notSuitablePrintf(entry, 0, "line has only %d elements\n",
1885		line->numElements);
1886		return 0;
1887		}
1888
1889	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	if (flags & GRUBBY_BADIMAGE_OKAY) {
1890		notSuitablePrintf(entry, 1, "\n");
1891		return 1;
1892		}
1893
1894	fullName = alloca(strlen(bootPrefix) +	fullName = alloca(strlen(bootPrefix) +
1895	strlen(line->elements[1].item) + 1);	strlen(line->elements[1].item) + 1);
1896	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
1897	sprintf(fullName, "%s%s", bootPrefix,	int rootspec_offset = rootspec ? strlen(rootspec) : 0;
1898	line->elements[1].item + (rootspec ? strlen(rootspec) : 0));	int hasslash = endswith(bootPrefix, '/') ||
1899	if (access(fullName, R_OK)) return 0;	beginswith(line->elements[1].item + rootspec_offset, '/');
1900		sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1901		line->elements[1].item + rootspec_offset);
1902		if (access(fullName, R_OK)) {
1903		notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1904		return 0;
1905		}
1906	for (i = 2; i < line->numElements; i++)	for (i = 2; i < line->numElements; i++)
1907	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1908	if (i < line->numElements) {	if (i < line->numElements) {
#	Line 1195  int suitableImage(struct singleEntry * e	Line 1920  int suitableImage(struct singleEntry * e
1920	line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);
1921
1922	/* failed to find one */	/* failed to find one */
1923	if (!line) return 0;	if (!line) {
1924		notSuitablePrintf(entry, 0, "no line found\n");
1925		return 0;
1926		}
1927
1928	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
1929	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1930	if (i < line->numElements)	if (i < line->numElements)
1931	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1932	else {	else {
1933		notSuitablePrintf(entry, 0, "no root= entry found\n");
1934	/* it failed too...  can't find root= */	/* it failed too...  can't find root= */
1935	return 0;	return 0;
1936	}	}
#	Line 1209  int suitableImage(struct singleEntry * e	Line 1938  int suitableImage(struct singleEntry * e
1938	}	}
1939
1940	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1941	if (!dev)	if (!getpathbyspec(dev)) {
1942		notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1943	return 0;	return 0;
1944		} else
1945		dev = getpathbyspec(dev);
1946
1947	i = stat(dev, &sb);	rootdev = findDiskForRoot();
1948	if (i)	if (!rootdev) {
1949		notSuitablePrintf(entry, 0, "can't find root device\n");
1950	return 0;	return 0;
1951		}
1952
1953	stat("/", &sb2);	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1954		notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1955		getuuidbydev(rootdev), getuuidbydev(dev));
1956		free(rootdev);
1957		return 0;
1958		}
1959
1960	if (sb.st_rdev != sb2.st_dev)	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1961		notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1962		getuuidbydev(rootdev), getuuidbydev(dev));
1963		free(rootdev);
1964	return 0;	return 0;
1965		}
1966
1967		free(rootdev);
1968		notSuitablePrintf(entry, 1, "\n");
1969
1970	return 1;	return 1;
1971	}	}
#	Line 1253  struct singleEntry * findEntryByPath(str	Line 1999  struct singleEntry * findEntryByPath(str
1999	}	}
2000
2001	indexVars[i + 1] = -1;	indexVars[i + 1] = -1;
2002
2003	i = 0;	i = 0;
2004	if (index) {	if (index) {
2005	while (i < *index) i++;	while (i < *index) {
2006	if (indexVars[i] == -1) return NULL;	i++;
2007		if (indexVars[i] == -1) return NULL;
2008		}
2009	}	}
2010
2011	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
2012	if (!entry) return NULL;	if (!entry) return NULL;
2013
2014	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2015	if (!line) return NULL;	if (!line) return NULL;
2016
2017	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1301  struct singleEntry * findEntryByPath(str	Line 2049  struct singleEntry * findEntryByPath(str
2049
2050	if (!strncmp(kernel, "TITLE=", 6)) {	if (!strncmp(kernel, "TITLE=", 6)) {
2051	prefix = "";	prefix = "";
2052	checkType = LT_TITLE;	checkType = LT_TITLE|LT_MENUENTRY;
2053	kernel += 6;	kernel += 6;
2054	}	}
2055
#	Line 1312  struct singleEntry * findEntryByPath(str	Line 2060  struct singleEntry * findEntryByPath(str
2060
2061	/* check all the lines matching checkType */	/* check all the lines matching checkType */
2062	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
2063	line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?	enum lineType_e ct = checkType;
2064	LT_KERNEL|LT_MBMODULE|LT_HYPER :	if (entry->multiboot && checkType == LT_KERNEL)
2065	checkType, line);	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2066	if (!line) break;  /* not found in this entry */	else if (checkType & LT_KERNEL)
2067		ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2068		line = getLineByType(ct, line);
2069		if (!line)
2070		break;  /* not found in this entry */
2071
2072	if (line && line->numElements >= 2) {	if (line && line->type != LT_MENUENTRY &&
2073		line->numElements >= 2) {
2074	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
2075	if (!strcmp(line->elements[1].item +	if (!strcmp(line->elements[1].item +
2076	((rootspec != NULL) ? strlen(rootspec) : 0),	((rootspec != NULL) ? strlen(rootspec) : 0),
2077	kernel + strlen(prefix)))	kernel + strlen(prefix)))
2078	break;	break;
2079	}	}
2080		if(line->type == LT_MENUENTRY &&
2081		!strcmp(line->elements[1].item, kernel))
2082		break;
2083	}	}
2084
2085	/* make sure this entry has a kernel identifier; this skips	/* make sure this entry has a kernel identifier; this skips
2086	* non-Linux boot entries (could find netbsd etc, though, which is	* non-Linux boot entries (could find netbsd etc, though, which is
2087	* unfortunate)	* unfortunate)
2088	*/	*/
2089	if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2090	break; /* found 'im! */	break; /* found 'im! */
2091	}	}
2092
#	Line 1340  struct singleEntry * findEntryByPath(str	Line 2096  struct singleEntry * findEntryByPath(str
2096	return entry;	return entry;
2097	}	}
2098
2099		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2100		int * index) {
2101		struct singleEntry * entry;
2102		struct singleLine * line;
2103		int i;
2104		char * newtitle;
2105
2106		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2107		if (index && i < *index)
2108		continue;
2109		line = getLineByType(LT_TITLE, entry->lines);
2110		if (!line)
2111		line = getLineByType(LT_MENUENTRY, entry->lines);
2112		if (!line)
2113		continue;
2114		newtitle = grub2ExtractTitle(line);
2115		if (!newtitle)
2116		continue;
2117		if (!strcmp(title, newtitle))
2118		break;
2119		}
2120
2121		if (!entry)
2122		return NULL;
2123
2124		if (index)
2125		*index = i;
2126		return entry;
2127		}
2128
2129	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2130	struct singleEntry * entry;	struct singleEntry * entry;
2131
#	Line 1362  struct singleEntry * findTemplate(struct	Line 2148  struct singleEntry * findTemplate(struct
2148	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2149	int index;	int index;
2150
2151	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2152		if (cfg->cfi->getEnv) {
2153		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2154		if (defTitle) {
2155		int index = 0;
2156		if (isnumber(defTitle)) {
2157		index = atoi(defTitle);
2158		entry = findEntryByIndex(cfg, index);
2159		} else {
2160		entry = findEntryByTitle(cfg, defTitle, &index);
2161		}
2162		if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2163		cfg->defaultImage = index;
2164		if (indexPtr)
2165		*indexPtr = index;
2166		return entry;
2167		}
2168		}
2169		}
2170		} else if (cfg->defaultImage > -1) {
2171	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2172	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2173	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1415  void markRemovedImage(struct grubConfig	Line 2220  void markRemovedImage(struct grubConfig
2220	const char * prefix) {	const char * prefix) {
2221	struct singleEntry * entry;	struct singleEntry * entry;
2222
2223	if (!image) return;	if (!image)
2224		return;
2225
2226		/* check and see if we're removing the default image */
2227		if (isdigit(*image)) {
2228		entry = findEntryByPath(cfg, image, prefix, NULL);
2229		if(entry)
2230		entry->skip = 1;
2231		return;
2232		}
2233
2234	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2235	entry->skip = 1;	entry->skip = 1;
#	Line 1423  void markRemovedImage(struct grubConfig	Line 2237  void markRemovedImage(struct grubConfig
2237
2238	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2239	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2240	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2241	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2242	int i, j;	int i, j;
2243
2244	if (newIsDefault) {	if (newIsDefault) {
2245	config->defaultImage = 0;	config->defaultImage = 0;
2246	return;	return;
2247		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2248		if (findEntryByIndex(config, index))
2249		config->defaultImage = index;
2250		else
2251		config->defaultImage = -1;
2252		return;
2253	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2254	i = 0;	i = 0;
2255	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1442  void setDefaultImage(struct grubConfig *	Line 2262  void setDefaultImage(struct grubConfig *
2262
2263	/* 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
2264	changes */	changes */
2265	if (config->defaultImage == DEFAULT_SAVED)	if ((config->defaultImage == DEFAULT_SAVED) ||
2266		(config->defaultImage == DEFAULT_SAVED_GRUB2))
2267	/* default is set to saved, we don't want to change it */	/* default is set to saved, we don't want to change it */
2268	return;	return;
2269
#	Line 1500  void displayEntry(struct singleEntry * e	Line 2321  void displayEntry(struct singleEntry * e
2321	struct singleLine * line;	struct singleLine * line;
2322	char * root = NULL;	char * root = NULL;
2323	int i;	int i;
2324		int j;
2325
2326		printf("index=%d\n", index);
2327
2328		line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2329		if (!line) {
2330		printf("non linux entry\n");
2331		return;
2332		}
2333
2334		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2335		printf("kernel=%s\n", line->elements[1].item);
2336		else
2337		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2338
2339		if (line->numElements >= 3) {
2340		printf("args=\"");
2341		i = 2;
2342		while (i < line->numElements) {
2343		if (!strncmp(line->elements[i].item, "root=", 5)) {
2344		root = line->elements[i].item + 5;
2345		} else {
2346		printf("%s%s", line->elements[i].item,
2347		line->elements[i].indent);
2348		}
2349
2350		i++;
2351		}
2352		printf("\"\n");
2353		} else {
2354		line = getLineByType(LT_KERNELARGS, entry->lines);
2355		if (line) {
2356		char * s;
2357
2358		printf("args=\"");
2359		i = 1;
2360		while (i < line->numElements) {
2361		if (!strncmp(line->elements[i].item, "root=", 5)) {
2362		root = line->elements[i].item + 5;
2363		} else {
2364		s = line->elements[i].item;
2365
2366		printf("%s%s", s, line->elements[i].indent);
2367		}
2368
2369		i++;
2370		}
2371
2372		s = line->elements[i - 1].indent;
2373		printf("\"\n");
2374		}
2375		}
2376
2377		if (!root) {
2378		line = getLineByType(LT_ROOT, entry->lines);
2379		if (line && line->numElements >= 2)
2380		root=line->elements[1].item;
2381		}
2382
2383		if (root) {
2384		char * s = alloca(strlen(root) + 1);
2385
2386		strcpy(s, root);
2387		if (s[strlen(s) - 1] == '"')
2388		s[strlen(s) - 1] = '\0';
2389		/* make sure the root doesn't have a trailing " */
2390		printf("root=%s\n", s);
2391		}
2392
2393		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2394
2395		if (line && line->numElements >= 2) {
2396		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2397		printf("initrd=");
2398		else
2399		printf("initrd=%s", prefix);
2400
2401		for (i = 1; i < line->numElements; i++)
2402		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2403		printf("\n");
2404		}
2405
2406		line = getLineByType(LT_TITLE, entry->lines);
2407		if (line) {
2408		printf("title=%s\n", line->elements[1].item);
2409		} else {
2410		char * title;
2411		line = getLineByType(LT_MENUENTRY, entry->lines);
2412		if (line) {
2413		title = grub2ExtractTitle(line);
2414		if (title)
2415		printf("title=%s\n", title);
2416		}
2417		}
2418
2419		for (j = 0, line = entry->lines; line; line = line->next) {
2420		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2421		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2422		printf("mbmodule%d=", j);
2423		else
2424		printf("mbmodule%d=%s", j, prefix);
2425
2426		for (i = 1; i < line->numElements; i++)
2427		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2428		printf("\n");
2429		j++;
2430		}
2431		}
2432		}
2433
2434		int isSuseSystem(void) {
2435		const char * path;
2436		const static char default_path[] = "/etc/SuSE-release";
2437
2438		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2439		path = default_path;
2440
2441		if (!access(path, R_OK))
2442		return 1;
2443		return 0;
2444		}
2445
2446		int isSuseGrubConf(const char * path) {
2447		FILE * grubConf;
2448		char * line = NULL;
2449		size_t len = 0, res = 0;
2450
2451		grubConf = fopen(path, "r");
2452		if (!grubConf) {
2453		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2454		return 0;
2455		}
2456
2457		while ((res = getline(&line, &len, grubConf)) != -1) {
2458		if (!strncmp(line, "setup", 5)) {
2459		fclose(grubConf);
2460		free(line);
2461		return 1;
2462		}
2463		}
2464
2465		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2466		path);
2467
2468		fclose(grubConf);
2469		free(line);
2470		return 0;
2471		}
2472
2473		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2474		FILE * grubConf;
2475		char * line = NULL;
2476		size_t res = 0, len = 0;
2477
2478		if (!path) return 1;
2479		if (!lbaPtr) return 1;
2480
2481		grubConf = fopen(path, "r");
2482		if (!grubConf) return 1;
2483
2484		while ((res = getline(&line, &len, grubConf)) != -1) {
2485		if (line[res - 1] == '\n')
2486		line[res - 1] = '\0';
2487		else if (len > res)
2488		line[res] = '\0';
2489		else {
2490		line = realloc(line, res + 1);
2491		line[res] = '\0';
2492		}
2493
2494		if (!strncmp(line, "setup", 5)) {
2495		if (strstr(line, "--force-lba")) {
2496		*lbaPtr = 1;
2497		} else {
2498		*lbaPtr = 0;
2499		}
2500		dbgPrintf("lba: %i\n", *lbaPtr);
2501		break;
2502		}
2503		}
2504
2505		free(line);
2506		fclose(grubConf);
2507		return 0;
2508		}
2509
2510		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2511		FILE * grubConf;
2512		char * line = NULL;
2513		size_t res = 0, len = 0;
2514		char * lastParamPtr = NULL;
2515		char * secLastParamPtr = NULL;
2516		char installDeviceNumber = '\0';
2517		char * bounds = NULL;
2518
2519		if (!path) return 1;
2520		if (!devicePtr) return 1;
2521
2522		grubConf = fopen(path, "r");
2523		if (!grubConf) return 1;
2524
2525		while ((res = getline(&line, &len, grubConf)) != -1) {
2526		if (strncmp(line, "setup", 5))
2527		continue;
2528
2529		if (line[res - 1] == '\n')
2530		line[res - 1] = '\0';
2531		else if (len > res)
2532		line[res] = '\0';
2533		else {
2534		line = realloc(line, res + 1);
2535		line[res] = '\0';
2536		}
2537
2538		lastParamPtr = bounds = line + res;
2539
2540		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2541		while (!isspace(*lastParamPtr))
2542		lastParamPtr--;
2543		lastParamPtr++;
2544
2545		secLastParamPtr = lastParamPtr - 2;
2546		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2547
2548		if (lastParamPtr + 3 > bounds) {
2549		dbgPrintf("lastParamPtr going over boundary");
2550		fclose(grubConf);
2551		free(line);
2552		return 1;
2553		}
2554		if (!strncmp(lastParamPtr, "(hd", 3))
2555		lastParamPtr += 3;
2556		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2557
2558		/*
2559		* Second last parameter will decide wether last parameter is
2560		* an IMAGE_DEVICE or INSTALL_DEVICE
2561		*/
2562		while (!isspace(*secLastParamPtr))
2563		secLastParamPtr--;
2564		secLastParamPtr++;
2565
2566		if (secLastParamPtr + 3 > bounds) {
2567		dbgPrintf("secLastParamPtr going over boundary");
2568		fclose(grubConf);
2569		free(line);
2570		return 1;
2571		}
2572		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2573		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2574		secLastParamPtr += 3;
2575		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2576		installDeviceNumber = *secLastParamPtr;
2577		} else {
2578		installDeviceNumber = *lastParamPtr;
2579		}
2580
2581		*devicePtr = malloc(6);
2582		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2583		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2584		fclose(grubConf);
2585		free(line);
2586		return 0;
2587		}
2588
2589		free(line);
2590		fclose(grubConf);
2591		return 1;
2592		}
2593
2594		int grubGetBootFromDeviceMap(const char * device,
2595		char ** bootPtr) {
2596		FILE * deviceMap;
2597		char * line = NULL;
2598		size_t res = 0, len = 0;
2599		char * devicePtr;
2600		char * bounds = NULL;
2601		const char * path;
2602		const static char default_path[] = "/boot/grub/device.map";
2603
2604		if (!device) return 1;
2605		if (!bootPtr) return 1;
2606
2607		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2608		path = default_path;
2609
2610		dbgPrintf("opening grub device.map file from: %s\n", path);
2611		deviceMap = fopen(path, "r");
2612		if (!deviceMap)
2613		return 1;
2614
2615		while ((res = getline(&line, &len, deviceMap)) != -1) {
2616		if (!strncmp(line, "#", 1))
2617		continue;
2618
2619	printf("index=%d\n", index);	if (line[res - 1] == '\n')
2620		line[res - 1] = '\0';
2621		else if (len > res)
2622		line[res] = '\0';
2623		else {
2624		line = realloc(line, res + 1);
2625		line[res] = '\0';
2626		}
2627
2628		devicePtr = line;
2629		bounds = line + res;
2630
2631		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2632		devicePtr++;
2633		dbgPrintf("device: %s\n", devicePtr);
2634
2635		if (!strncmp(devicePtr, device, strlen(device))) {
2636		devicePtr += strlen(device);
2637		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2638		devicePtr++;
2639
2640	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	*bootPtr = strdup(devicePtr);
2641	if (!line) {	break;
2642	printf("non linux entry\n");	}
	return;
2643	}	}
2644
2645	printf("kernel=%s\n", line->elements[1].item);	free(line);
2646		fclose(deviceMap);
2647		return 0;
2648		}
2649
2650	if (line->numElements >= 3) {	int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2651	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);
	}
2652
2653	i++;	if (suseGrubConfGetInstallDevice(path, &grubDevice))
2654	}	dbgPrintf("error looking for grub installation device\n");
2655	printf("\"\n");	else
2656	} else {	dbgPrintf("grubby installation device: %s\n", grubDevice);
	line = getLineByType(LT_KERNELARGS, entry->lines);
	if (line) {
	char * s;
2657
2658	printf("args=\"");	if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2659	i = 1;	dbgPrintf("error looking for grub boot device\n");
2660	while (i < line->numElements) {	else
2661	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;
2662
2663	printf("%s%s", s, line->elements[i].indent);	free(grubDevice);
2664	}	return 0;
2665		}
2666
2667	i++;	int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2668	}	/*
2669		* This SuSE grub configuration file at this location is not your average
2670		* grub configuration file, but instead the grub commands used to setup
2671		* grub on that system.
2672		*/
2673		const char * path;
2674		const static char default_path[] = "/etc/grub.conf";
2675
2676	s = line->elements[i - 1].indent;	if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2677	printf("\"\n");	path = default_path;
	}
	}
2678
2679	if (!root) {	if (!isSuseGrubConf(path)) return 1;
	line = getLineByType(LT_ROOT, entry->lines);
	if (line && line->numElements >= 2)
	root=line->elements[1].item;
	}
2680
2681	if (root) {	if (lbaPtr) {
2682	char * s = alloca(strlen(root) + 1);	*lbaPtr = 0;
2683		if (suseGrubConfGetLba(path, lbaPtr))
2684	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);
2685	}	}
2686
2687	line = getLineByType(LT_INITRD, entry->lines);	if (bootPtr) {
2688		*bootPtr = NULL;
2689	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");
2690	}	}
2691
2692		return 0;
2693	}	}
2694
2695	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
#	Line 1582  int parseSysconfigGrub(int * lbaPtr, cha	Line 2699  int parseSysconfigGrub(int * lbaPtr, cha
2699	char * start;	char * start;
2700	char * param;	char * param;
2701
2702	in = fopen("/etc/sysconfig/grub", "r");	in = fopen("/etc/conf.d/grub", "r");
2703	if (!in) return 1;	if (!in) return 1;
2704
2705	if (lbaPtr) *lbaPtr = 0;	if (lbaPtr) *lbaPtr = 0;
#	Line 1623  int parseSysconfigGrub(int * lbaPtr, cha	Line 2740  int parseSysconfigGrub(int * lbaPtr, cha
2740	}	}
2741
2742	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2743	char * boot;	char * boot = NULL;
2744	int lba;	int lba;
2745
2746	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2747	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2748	if (boot) printf("boot=%s\n", boot);	free(boot);
2749		return;
2750		}
2751		} else {
2752		if (parseSysconfigGrub(&lba, &boot)) {
2753		free(boot);
2754		return;
2755		}
2756		}
2757
2758		if (lba) printf("lba\n");
2759		if (boot) {
2760		printf("boot=%s\n", boot);
2761		free(boot);
2762	}	}
2763	}	}
2764
#	Line 1644  int displayInfo(struct grubConfig * conf	Line 2774  int displayInfo(struct grubConfig * conf
2774	return 1;	return 1;
2775	}	}
2776
2777	/* 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
2778	be a better way */	be a better way */
2779	if (config->cfi == &grubConfigType) {	if (config->cfi == &grubConfigType) {
2780	dumpSysconfigGrub();	dumpSysconfigGrub();
#	Line 1677  struct singleLine * addLineTmpl(struct s	Line 2807  struct singleLine * addLineTmpl(struct s
2807	{	{
2808	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2809
2810		if (isEfi && cfi == &grub2ConfigType) {
2811		enum lineType_e old = newLine->type;
2812		newLine->type = preferredLineType(newLine->type, cfi);
2813		if (old != newLine->type)
2814		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2815		}
2816
2817	if (val) {	if (val) {
2818	/* override the inherited value with our own.	/* override the inherited value with our own.
2819	* 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 2823  struct singleLine * addLineTmpl(struct s
2823	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2824
2825	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2826	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)) {
2827	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2828	if (rootspec != NULL) {	if (rootspec != NULL) {
2829	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 1723  struct singleLine *  addLine(struct sing	Line 2860  struct singleLine *  addLine(struct sing
2860	/* 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
2861	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2862	*/	*/
2863	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2864	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2865	tmpl.type = type;	tmpl.type = type;
#	Line 1733  struct singleLine *  addLine(struct sing	Line 2869  struct singleLine *  addLine(struct sing
2869	sprintf(tmpl.elements[0].item, "[%s]", val);	sprintf(tmpl.elements[0].item, "[%s]", val);
2870	tmpl.elements[0].indent = "";	tmpl.elements[0].indent = "";
2871	val = NULL;	val = NULL;
2872		} else if (type == LT_MENUENTRY) {
2873		char *lineend = "--class gnu-linux --class gnu --class os {";
2874		if (!val) {
2875		fprintf(stderr, "Line type LT_MENUENTRY requires a value\n");
2876		abort();
2877		}
2878		kw = getKeywordByType(type, cfi);
2879		if (!kw) {
2880		fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
2881		abort();
2882		}
2883		tmpl.indent = "";
2884		tmpl.type = type;
2885		tmpl.numElements = 3;
2886		tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
2887		tmpl.elements[0].item = kw->key;
2888		tmpl.elements[0].indent = alloca(2);
2889		sprintf(tmpl.elements[0].indent, "%c", kw->nextChar);
2890		tmpl.elements[1].item = (char *)val;
2891		tmpl.elements[1].indent = alloca(2);
2892		sprintf(tmpl.elements[1].indent, "%c", kw->nextChar);
2893		tmpl.elements[2].item = alloca(strlen(lineend)+1);
2894		strcpy(tmpl.elements[2].item, lineend);
2895		tmpl.elements[2].indent = "";
2896	} else {	} else {
2897	kw = getKeywordByType(type, cfi);	kw = getKeywordByType(type, cfi);
2898	if (!kw) abort();	if (!kw) {
2899		fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
2900		abort();
2901		}
2902	tmpl.type = type;	tmpl.type = type;
2903	tmpl.numElements = val ? 2 : 1;	tmpl.numElements = val ? 2 : 1;
2904	tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);	tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
#	Line 1759  struct singleLine *  addLine(struct sing	Line 2922  struct singleLine *  addLine(struct sing
2922	if (!line->next && !prev) prev = line;	if (!line->next && !prev) prev = line;
2923	}	}
2924
2925	if (prev == entry->lines)	struct singleLine *menuEntry;
2926	tmpl.indent = defaultIndent ?: "";	menuEntry = getLineByType(LT_MENUENTRY, entry->lines);
2927	else	if (tmpl.type == LT_ENTRY_END) {
2928	tmpl.indent = prev->indent;	if (menuEntry)
2929		tmpl.indent = menuEntry->indent;
2930		else
2931		tmpl.indent = defaultIndent ?: "";
2932		} else if (tmpl.type != LT_MENUENTRY) {
2933		if (menuEntry)
2934		tmpl.indent = "\t";
2935		else if (prev == entry->lines)
2936		tmpl.indent = defaultIndent ?: "";
2937		else
2938		tmpl.indent = prev->indent;
2939		}
2940
2941	return addLineTmpl(entry, &tmpl, prev, val, cfi);	return addLineTmpl(entry, &tmpl, prev, val, cfi);
2942	}	}
#	Line 1789  void removeLine(struct singleEntry * ent	Line 2963  void removeLine(struct singleEntry * ent
2963	free(line);	free(line);
2964	}	}
2965
2966		static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
2967		{
2968		struct singleLine newLine = {
2969		.indent = tmplLine->indent,
2970		.type = tmplLine->type,
2971		.next = tmplLine->next,
2972		};
2973		int firstQuotedItem = -1;
2974		int quoteLen = 0;
2975		int j;
2976		int element = 0;
2977		char *c;
2978
2979		c = malloc(strlen(tmplLine->elements[0].item) + 1);
2980		strcpy(c, tmplLine->elements[0].item);
2981		insertElement(&newLine, c, element++, cfi);
2982		free(c);
2983		c = NULL;
2984
2985		for (j = 1; j < tmplLine->numElements; j++) {
2986		if (firstQuotedItem == -1) {
2987		quoteLen += strlen(tmplLine->elements[j].item);
2988
2989		if (isquote(tmplLine->elements[j].item[0])) {
2990		firstQuotedItem = j;
2991		quoteLen += strlen(tmplLine->elements[j].indent);
2992		} else {
2993		c = malloc(quoteLen + 1);
2994		strcpy(c, tmplLine->elements[j].item);
2995		insertElement(&newLine, c, element++, cfi);
2996		free(c);
2997		quoteLen = 0;
2998		}
2999		} else {
3000		int itemlen = strlen(tmplLine->elements[j].item);
3001		quoteLen += itemlen;
3002		quoteLen += strlen(tmplLine->elements[j].indent);
3003
3004		if (isquote(tmplLine->elements[j].item[itemlen - 1])) {
3005		c = malloc(quoteLen + 1);
3006		c[0] = '\0';
3007		for (int i = firstQuotedItem; i < j+1; i++) {
3008		strcat(c, tmplLine->elements[i].item);
3009		strcat(c, tmplLine->elements[i].indent);
3010		}
3011		insertElement(&newLine, c, element++, cfi);
3012		free(c);
3013
3014		firstQuotedItem = -1;
3015		quoteLen = 0;
3016		}
3017		}
3018		}
3019		while (tmplLine->numElements)
3020		removeElement(tmplLine, 0);
3021		if (tmplLine->elements)
3022		free(tmplLine->elements);
3023
3024		tmplLine->numElements = newLine.numElements;
3025		tmplLine->elements = newLine.elements;
3026		}
3027
3028	static void insertElement(struct singleLine * line,	static void insertElement(struct singleLine * line,
3029	const char * item, int insertHere,	const char * item, int insertHere,
3030	struct configFileInfo * cfi)	struct configFileInfo * cfi)
#	Line 1895  int updateActualImage(struct grubConfig	Line 3131  int updateActualImage(struct grubConfig
3131	const char ** arg;	const char ** arg;
3132	int useKernelArgs, useRoot;	int useKernelArgs, useRoot;
3133	int firstElement;	int firstElement;
3134	int *usedElements, *usedArgs;	int *usedElements;
3135	int doreplace;	int doreplace;
3136
3137	if (!image) return 0;	if (!image) return 0;
#	Line 1930  int updateActualImage(struct grubConfig	Line 3166  int updateActualImage(struct grubConfig
3166	useRoot = (getKeywordByType(LT_ROOT, cfg->cfi)	useRoot = (getKeywordByType(LT_ROOT, cfg->cfi)
3167	&& !multibootArgs);	&& !multibootArgs);
3168
	for (k = 0, arg = newArgs; *arg; arg++, k++) ;
	usedArgs = calloc(k, sizeof(*usedArgs));
3169	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3170
3171	if (multibootArgs && !entry->multiboot)	if (multibootArgs && !entry->multiboot)
#	Line 1960  int updateActualImage(struct grubConfig	Line 3193  int updateActualImage(struct grubConfig
3193	firstElement = 2;	firstElement = 2;
3194
3195	} else {	} else {
3196	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3197	if (!line) {	if (!line) {
3198	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3199	continue;	continue;
#	Line 2008  int updateActualImage(struct grubConfig	Line 3241  int updateActualImage(struct grubConfig
3241	usedElements = calloc(line->numElements, sizeof(*usedElements));	usedElements = calloc(line->numElements, sizeof(*usedElements));
3242
3243	for (k = 0, arg = newArgs; *arg; arg++, k++) {	for (k = 0, arg = newArgs; *arg; arg++, k++) {
	if (usedArgs[k]) continue;
3244
3245	doreplace = 1;	doreplace = 1;
3246	for (i = firstElement; i < line->numElements; i++) {	for (i = firstElement; i < line->numElements; i++) {
#	Line 2023  int updateActualImage(struct grubConfig	Line 3255  int updateActualImage(struct grubConfig
3255	continue;	continue;
3256	if (!argMatch(line->elements[i].item, *arg)) {	if (!argMatch(line->elements[i].item, *arg)) {
3257	usedElements[i]=1;	usedElements[i]=1;
	usedArgs[k]=1;
3258	break;	break;
3259	}	}
3260	}	}
#	Line 2093  int updateActualImage(struct grubConfig	Line 3324  int updateActualImage(struct grubConfig
3324	}	}
3325	}	}
3326
	free(usedArgs);
3327	free(newArgs);	free(newArgs);
3328	free(oldArgs);	free(oldArgs);
3329
#	Line 2119  int updateImage(struct grubConfig * cfg,	Line 3349  int updateImage(struct grubConfig * cfg,
3349	return rc;	return rc;
3350	}	}
3351
3352		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3353		const char * image, const char * prefix, const char * initrd,
3354		const char * title) {
3355		struct singleEntry * entry;
3356		struct singleLine * line, * kernelLine, *endLine = NULL;
3357		int index = 0;
3358
3359		if (!image) return 0;
3360
3361		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3362		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3363		if (!kernelLine) continue;
3364
3365		/* if title is supplied, the entry's title must match it. */
3366		if (title) {
3367		char *linetitle;
3368
3369		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3370		if (!line)
3371		continue;
3372
3373		linetitle = extractTitle(cfg, line);
3374		if (!linetitle)
3375		continue;
3376		if (strcmp(title, linetitle)) {
3377		free(linetitle);
3378		continue;
3379		}
3380		free(linetitle);
3381		}
3382
3383		if (prefix) {
3384		int prefixLen = strlen(prefix);
3385		if (!strncmp(initrd, prefix, prefixLen))
3386		initrd += prefixLen;
3387		}
3388		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3389		if (endLine)
3390		removeLine(entry, endLine);
3391		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3392		kernelLine->indent, initrd);
3393		if (!line)
3394		return 1;
3395		if (endLine) {
3396		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3397		if (!line)
3398		return 1;
3399		}
3400
3401		break;
3402		}
3403
3404		return 0;
3405		}
3406
3407		int updateInitrd(struct grubConfig * cfg, const char * image,
3408		const char * prefix, const char * initrd, const char * title) {
3409		struct singleEntry * entry;
3410		struct singleLine * line, * kernelLine, *endLine = NULL;
3411		int index = 0;
3412
3413		if (!image) return 0;
3414
3415		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3416		kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3417		if (!kernelLine) continue;
3418
3419		/* if title is supplied, the entry's title must match it. */
3420		if (title) {
3421		char *linetitle;
3422
3423		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3424		if (!line)
3425		continue;
3426
3427		linetitle = extractTitle(cfg, line);
3428		if (!linetitle)
3429		continue;
3430		if (strcmp(title, linetitle)) {
3431		free(linetitle);
3432		continue;
3433		}
3434		free(linetitle);
3435		}
3436
3437		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3438		if (line)
3439		removeLine(entry, line);
3440		if (prefix) {
3441		int prefixLen = strlen(prefix);
3442		if (!strncmp(initrd, prefix, prefixLen))
3443		initrd += prefixLen;
3444		}
3445		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3446		if (endLine)
3447		removeLine(entry, endLine);
3448		enum lineType_e lt;
3449		switch(kernelLine->type) {
3450		case LT_KERNEL:
3451		lt = LT_INITRD;
3452		break;
3453		case LT_KERNEL_EFI:
3454		lt = LT_INITRD_EFI;
3455		break;
3456		case LT_KERNEL_16:
3457		lt = LT_INITRD_16;
3458		break;
3459		default:
3460		lt = preferredLineType(LT_INITRD, cfg->cfi);
3461		}
3462		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3463		if (!line)
3464		return 1;
3465		if (endLine) {
3466		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3467		if (!line)
3468		return 1;
3469		}
3470
3471		break;
3472		}
3473
3474		return 0;
3475		}
3476
3477	int checkDeviceBootloader(const char * device, const unsigned char * boot) {	int checkDeviceBootloader(const char * device, const unsigned char * boot) {
3478	int fd;	int fd;
3479	unsigned char bootSect[512];	unsigned char bootSect[512];
#	Line 2142  int checkDeviceBootloader(const char * d	Line 3497  int checkDeviceBootloader(const char * d
3497	if (memcmp(boot, bootSect, 3))	if (memcmp(boot, bootSect, 3))
3498	return 0;	return 0;
3499
3500	if (boot[1] == 0xeb) {	if (boot[1] == JMP_SHORT_OPCODE) {
3501	offset = boot[2] + 2;	offset = boot[2] + 2;
3502	} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {	} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {
3503	offset = (boot[3] << 8) + boot[2] + 2;	offset = (boot[3] << 8) + boot[2] + 2;
3504	} else if (boot[0] == 0xeb) {	} else if (boot[0] == JMP_SHORT_OPCODE) {
3505	offset = boot[1] + 2;	offset = boot[1] + 2;
3506		/*
3507		* it looks like grub, when copying stage1 into the mbr, patches stage1
3508		* right after the JMP location, replacing other instructions such as
3509		* JMPs for NOOPs. So, relax the check a little bit by skipping those
3510		* different bytes.
3511		*/
3512		if ((bootSect[offset + 1] == NOOP_OPCODE)
3513		&& (bootSect[offset + 2] == NOOP_OPCODE)) {
3514		offset = offset + 3;
3515		}
3516	} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {	} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {
3517	offset = (boot[2] << 8) + boot[1] + 2;	offset = (boot[2] << 8) + boot[1] + 2;
3518	} else {	} else {
#	Line 2289  int checkForLilo(struct grubConfig * con	Line 3654  int checkForLilo(struct grubConfig * con
3654	return checkDeviceBootloader(line->elements[1].item, boot);	return checkDeviceBootloader(line->elements[1].item, boot);
3655	}	}
3656
3657		int checkForGrub2(struct grubConfig * config) {
3658		if (!access("/etc/grub.d/", R_OK))
3659		return 2;
3660
3661		return 1;
3662		}
3663
3664	int checkForGrub(struct grubConfig * config) {	int checkForGrub(struct grubConfig * config) {
3665	int fd;	int fd;
3666	unsigned char bootSect[512];	unsigned char bootSect[512];
3667	char * boot;	char * boot;
3668		int onSuse = isSuseSystem();
3669
3670	if (parseSysconfigGrub(NULL, &boot))
3671	return 0;	if (onSuse) {
3672		if (parseSuseGrubConf(NULL, &boot))
3673		return 0;
3674		} else {
3675		if (parseSysconfigGrub(NULL, &boot))
3676		return 0;
3677		}
3678
3679	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3680	if (!boot)	if (!boot)
#	Line 2314  int checkForGrub(struct grubConfig * con	Line 3693  int checkForGrub(struct grubConfig * con
3693	}	}
3694	close(fd);	close(fd);
3695
3696		/* The more elaborate checks do not work on SuSE. The checks done
3697		* seem to be reasonble (at least for now), so just return success
3698		*/
3699		if (onSuse)
3700		return 2;
3701
3702	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3703	}	}
3704
#	Line 2347  int checkForExtLinux(struct grubConfig *	Line 3732  int checkForExtLinux(struct grubConfig *
3732	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3733	}	}
3734
3735		int checkForYaboot(struct grubConfig * config) {
3736		/*
3737		* This is a simplistic check that we consider good enough for own puporses
3738		*
3739		* If we were to properly check if yaboot is *installed* we'd need to:
3740		* 1) get the system boot device (LT_BOOT)
3741		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3742		*    the content on the boot device
3743		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3744		* 4) check again if binary and boot device contents match
3745		*/
3746		if (!access("/etc/yaboot.conf", R_OK))
3747		return 2;
3748
3749		return 1;
3750		}
3751
3752		int checkForElilo(struct grubConfig * config) {
3753		if (!access("/etc/elilo.conf", R_OK))
3754		return 2;
3755
3756		return 1;
3757		}
3758
3759	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3760	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3761
#	Line 2361  static char * getRootSpecifier(char * st	Line 3770  static char * getRootSpecifier(char * st
3770	static char * getInitrdVal(struct grubConfig * config,	static char * getInitrdVal(struct grubConfig * config,
3771	const char * prefix, struct singleLine *tmplLine,	const char * prefix, struct singleLine *tmplLine,
3772	const char * newKernelInitrd,	const char * newKernelInitrd,
3773	char ** extraInitrds, int extraInitrdCount)	const char ** extraInitrds, int extraInitrdCount)
3774	{	{
3775	char *initrdVal, *end;	char *initrdVal, *end;
3776	int i;	int i;
#	Line 2406  static char * getInitrdVal(struct grubCo	Line 3815  static char * getInitrdVal(struct grubCo
3815
3816	int addNewKernel(struct grubConfig * config, struct singleEntry * template,	int addNewKernel(struct grubConfig * config, struct singleEntry * template,
3817	const char * prefix,	const char * prefix,
3818	char * newKernelPath, char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3819	char * newKernelArgs, char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3820	char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3821	char * newMBKernel, char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs,
3822		const char * newDevTreePath) {
3823	struct singleEntry * new;	struct singleEntry * new;
3824	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3825	int needs;	int needs;
#	Line 2450  int addNewKernel(struct grubConfig * con	Line 3860  int addNewKernel(struct grubConfig * con
3860	needs |= NEED_MB;	needs |= NEED_MB;
3861	new->multiboot = 1;	new->multiboot = 1;
3862	}	}
3863		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3864		needs |= NEED_DEVTREE;
3865
3866	if (template) {	if (template) {
3867	for (masterLine = template->lines;	for (masterLine = template->lines;
#	Line 2463  int addNewKernel(struct grubConfig * con	Line 3875  int addNewKernel(struct grubConfig * con
3875	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3876	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3877
3878	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3879	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3880	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3881	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 2541  int addNewKernel(struct grubConfig * con	Line 3952  int addNewKernel(struct grubConfig * con
3952	/* template is multi but new is not,	/* template is multi but new is not,
3953	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3954	*/	*/
3955	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3956	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3957	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3958	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3959		config->cfi)->key);
3960	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3961	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3962		config->cfi);
3963	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3964	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3965	char *initrdVal;	char *initrdVal;
3966	/* template is multi but new is not,	/* template is multi but new is not,
3967	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3968	*/	*/
3969	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3970	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3971	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3972	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3973		config->cfi)->key);
3974	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3975	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3976	free(initrdVal);	free(initrdVal);
3977	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3978	}	}
3979
3980	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3981	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3982	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3983	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 2590  int addNewKernel(struct grubConfig * con	Line 4003  int addNewKernel(struct grubConfig * con
4003	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4004	}	}
4005
4006		} else if (tmplLine->type == LT_MENUENTRY &&
4007		(needs & NEED_TITLE)) {
4008		requote(tmplLine, config->cfi);
4009		char *nkt = malloc(strlen(newKernelTitle)+3);
4010		strcpy(nkt, "'");
4011		strcat(nkt, newKernelTitle);
4012		strcat(nkt, "'");
4013		newLine = addLineTmpl(new, tmplLine, newLine, nkt, config->cfi);
4014		free(nkt);
4015		needs &= ~NEED_TITLE;
4016	} else if (tmplLine->type == LT_TITLE &&	} else if (tmplLine->type == LT_TITLE &&
4017	(needs & NEED_TITLE)) {	(needs & NEED_TITLE)) {
4018	if (tmplLine->numElements >= 2) {	if (tmplLine->numElements >= 2) {
#	Line 2603  int addNewKernel(struct grubConfig * con	Line 4026  int addNewKernel(struct grubConfig * con
4026	tmplLine->indent, newKernelTitle);	tmplLine->indent, newKernelTitle);
4027	needs &= ~NEED_TITLE;	needs &= ~NEED_TITLE;
4028	}	}
4029		} else if (tmplLine->type == LT_ECHO) {
4030		requote(tmplLine, config->cfi);
4031		static const char *prefix = "'Loading ";
4032		if (tmplLine->numElements > 1 &&
4033		strstr(tmplLine->elements[1].item, prefix) &&
4034		masterLine->next &&
4035		iskernel(masterLine->next->type)) {
4036		char *newTitle = malloc(strlen(prefix) +
4037		strlen(newKernelTitle) + 2);
4038
4039		strcpy(newTitle, prefix);
4040		strcat(newTitle, newKernelTitle);
4041		strcat(newTitle, "'");
4042		newLine = addLine(new, config->cfi, LT_ECHO,
4043		tmplLine->indent, newTitle);
4044		free(newTitle);
4045		} else {
4046		/* pass through other lines from the template */
4047		newLine = addLineTmpl(new, tmplLine, newLine, NULL,
4048		config->cfi);
4049		}
4050		} else if (tmplLine->type == LT_DEVTREE &&
4051		tmplLine->numElements == 2 && newDevTreePath) {
4052		newLine = addLineTmpl(new, tmplLine, newLine,
4053		newDevTreePath + strlen(prefix),
4054		config->cfi);
4055		needs &= ~NEED_DEVTREE;
4056		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
4057		const char *ndtp = newDevTreePath;
4058		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
4059		ndtp += strlen(prefix);
4060		newLine = addLine(new, config->cfi, LT_DEVTREE,
4061		config->secondaryIndent,
4062		ndtp);
4063		needs &= ~NEED_DEVTREE;
4064		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
4065	} else {	} else {
4066	/* pass through other lines from the template */	/* pass through other lines from the template */
4067	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
#	Line 2614  int addNewKernel(struct grubConfig * con	Line 4072  int addNewKernel(struct grubConfig * con
4072	/* don't have a template, so start the entry with the	/* don't have a template, so start the entry with the
4073	* appropriate starting line	* appropriate starting line
4074	*/	*/
4075	switch (config->cfi->entrySeparator) {	switch (config->cfi->entryStart) {
4076	case LT_KERNEL:	case LT_KERNEL:
4077		case LT_KERNEL_EFI:
4078		case LT_KERNEL_16:
4079	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
4080	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
4081	} else {	} else {
4082	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
4083		preferredLineType(LT_KERNEL, config->cfi),
4084	config->primaryIndent,	config->primaryIndent,
4085	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4086	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 2633  int addNewKernel(struct grubConfig * con	Line 4094  int addNewKernel(struct grubConfig * con
4094	needs &= ~NEED_MB;	needs &= ~NEED_MB;
4095	break;	break;
4096
4097		case LT_MENUENTRY: {
4098		char *nkt = malloc(strlen(newKernelTitle)+3);
4099		strcpy(nkt, "'");
4100		strcat(nkt, newKernelTitle);
4101		strcat(nkt, "'");
4102		newLine = addLine(new, config->cfi, LT_MENUENTRY,
4103		config->primaryIndent, nkt);
4104		free(nkt);
4105		needs &= ~NEED_TITLE;
4106		needs |= NEED_END;
4107		break;
4108		}
4109	case LT_TITLE:	case LT_TITLE:
4110	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)
4111	char * templabel;	char * templabel;
#	Line 2664  int addNewKernel(struct grubConfig * con	Line 4137  int addNewKernel(struct grubConfig * con
4137	}	}
4138	}	}
4139
4140		struct singleLine *endLine = NULL;
4141		endLine = getLineByType(LT_ENTRY_END, new->lines);
4142		if (endLine) {
4143		removeLine(new, endLine);
4144		needs |= NEED_END;
4145		}
4146
4147	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4148	* 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,
4149	* all the lines following the entrySeparator.	* all the lines following the entryStart.
4150	*/	*/
4151	if (needs & NEED_TITLE) {	if (needs & NEED_TITLE) {
4152	newLine = addLine(new, config->cfi, LT_TITLE,	newLine = addLine(new, config->cfi, LT_TITLE,
#	Line 2683  int addNewKernel(struct grubConfig * con	Line 4163  int addNewKernel(struct grubConfig * con
4163	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
4164	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4165	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4166	config->cfi)) ?	config->cfi))
4167	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
4168		: preferredLineType(LT_KERNEL, config->cfi),
4169	config->secondaryIndent,	config->secondaryIndent,
4170	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4171	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 2700  int addNewKernel(struct grubConfig * con	Line 4181  int addNewKernel(struct grubConfig * con
4181	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4182	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4183	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4184	config->cfi)) ?	config->cfi))
4185	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
4186		: preferredLineType(LT_INITRD, config->cfi),
4187	config->secondaryIndent,	config->secondaryIndent,
4188	initrdVal);	initrdVal);
4189	free(initrdVal);	free(initrdVal);
4190	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4191	}	}
4192		if (needs & NEED_DEVTREE) {
4193		newLine = addLine(new, config->cfi, LT_DEVTREE,
4194		config->secondaryIndent,
4195		newDevTreePath);
4196		needs &= ~NEED_DEVTREE;
4197		}
4198
4199		/* NEEDS_END must be last on bootloaders that need it... */
4200		if (needs & NEED_END) {
4201		newLine = addLine(new, config->cfi, LT_ENTRY_END,
4202		config->secondaryIndent, NULL);
4203		needs &= ~NEED_END;
4204		}
4205
4206	if (needs) {	if (needs) {
4207	printf(_("grubby: needs=%d, aborting\n"), needs);	printf(_("grubby: needs=%d, aborting\n"), needs);
#	Line 2719  int addNewKernel(struct grubConfig * con	Line 4214  int addNewKernel(struct grubConfig * con
4214	return 0;	return 0;
4215	}	}
4216
	static void traceback(int signum)
	{
	void *array[40];
	size_t size;
	signal(SIGSEGV, SIG_DFL);
	memset(array, '\0', sizeof (array));
	size = backtrace(array, 40);
	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",
	(unsigned long)size);
	backtrace_symbols_fd(array, size, STDERR_FILENO);
	exit(1);
	}
4217	int main(int argc, const char ** argv) {	int main(int argc, const char ** argv) {
4218	poptContext optCon;	poptContext optCon;
4219	char * grubConfig = NULL;	const char * grubConfig = NULL;
4220	char * outputFile = NULL;	char * outputFile = NULL;
4221	int arg = 0;	int arg = 0;
4222	int flags = 0;	int flags = 0;
4223	int badImageOkay = 0;	int badImageOkay = 0;
4224		int configureGrub2 = 0;
4225	int configureLilo = 0, configureELilo = 0, configureGrub = 0;	int configureLilo = 0, configureELilo = 0, configureGrub = 0;
4226	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;
4227	int configureExtLinux = 0;	int configureExtLinux = 0;
#	Line 2752  int main(int argc, const char ** argv) {	Line 4233  int main(int argc, const char ** argv) {
4233	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4234	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4235	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4236	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4237	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4238	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4239	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 2762  int main(int argc, const char ** argv) {	Line 4243  int main(int argc, const char ** argv) {
4243	char * removeArgs = NULL;	char * removeArgs = NULL;
4244	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4245	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4246		char * envPath = NULL;
4247	const char * chptr = NULL;	const char * chptr = NULL;
4248	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4249	struct grubConfig * config;	struct grubConfig * config;
4250	struct singleEntry * template = NULL;	struct singleEntry * template = NULL;
4251	int copyDefault = 0, makeDefault = 0;	int copyDefault = 0, makeDefault = 0;
4252	int displayDefault = 0;	int displayDefault = 0;
4253		int displayDefaultIndex = 0;
4254		int displayDefaultTitle = 0;
4255		int defaultIndex = -1;
4256	struct poptOption options[] = {	struct poptOption options[] = {
4257	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4258	_("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 4270  int main(int argc, const char ** argv) {
4270	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4271	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4272	_("bootfs") },	_("bootfs") },
4273	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4274	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4275	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4276	#endif	#endif
4277	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4278	_("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 4283  int main(int argc, const char ** argv) {
4283	"the kernel referenced by the default image does not exist, "	"the kernel referenced by the default image does not exist, "
4284	"the first linux entry whose kernel does exist is used as the "	"the first linux entry whose kernel does exist is used as the "
4285	"template"), NULL },	"template"), NULL },
4286		{ "debug", 0, 0, &debug, 0,
4287		_("print debugging information for failures") },
4288	{ "default-kernel", 0, 0, &displayDefault, 0,	{ "default-kernel", 0, 0, &displayDefault, 0,
4289	_("display the path of the default kernel") },	_("display the path of the default kernel") },
4290		{ "default-index", 0, 0, &displayDefaultIndex, 0,
4291		_("display the index of the default kernel") },
4292		{ "default-title", 0, 0, &displayDefaultTitle, 0,
4293		_("display the title of the default kernel") },
4294		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4295		_("device tree file for new stanza"), _("dtb-path") },
4296		{ "devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4297		_("device tree directory for new stanza"), _("dtb-path") },
4298	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4299	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4300		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4301		_("force grub2 stanzas to use efi") },
4302		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4303		_("path for environment data"),
4304		_("path") },
4305	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4306	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4307	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
4308	_("configure grub bootloader") },	_("configure grub bootloader") },
4309		{ "grub2", 0, POPT_ARG_NONE, &configureGrub2, 0,
4310		_("configure grub2 bootloader") },
4311	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,
4312	_("display boot information for specified kernel"),	_("display boot information for specified kernel"),
4313	_("kernel-path") },	_("kernel-path") },
4314	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4315	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4316	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4317	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4318	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4319	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4320	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 2832  int main(int argc, const char ** argv) {	Line 4334  int main(int argc, const char ** argv) {
4334	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4335	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4336	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4337		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4338		_("make the given entry index the default entry"),
4339		_("entry-index") },
4340	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4341	_("configure silo bootloader") },	_("configure silo bootloader") },
4342	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 2851  int main(int argc, const char ** argv) {	Line 4356  int main(int argc, const char ** argv) {
4356
4357	useextlinuxmenu=0;	useextlinuxmenu=0;
4358
4359	signal(SIGSEGV, traceback);	int i = 0;
4360		for (int j = 1; j < argc; j++)
4361		i += strlen(argv[j]) + 1;
4362		saved_command_line = malloc(i);
4363		if (!saved_command_line) {
4364		fprintf(stderr, "grubby: %m\n");
4365		exit(1);
4366		}
4367		saved_command_line[0] = '\0';
4368		for (int j = 1; j < argc; j++) {
4369		strcat(saved_command_line, argv[j]);
4370		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4371		}
4372
4373	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4374	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
#	Line 2885  int main(int argc, const char ** argv) {	Line 4402  int main(int argc, const char ** argv) {
4402	return 1;	return 1;
4403	}	}
4404
4405	if ((configureLilo + configureGrub + configureELilo +	if ((configureLilo + configureGrub2 + configureGrub + configureELilo +
4406	configureYaboot + configureSilo + configureZipl +	configureYaboot + configureSilo + configureZipl +
4407	configureExtLinux ) > 1) {	configureExtLinux ) > 1) {
4408	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 4411  int main(int argc, const char ** argv) {
4411	fprintf(stderr,	fprintf(stderr,
4412	_("grubby: cannot specify config file with --bootloader-probe\n"));	_("grubby: cannot specify config file with --bootloader-probe\n"));
4413	return 1;	return 1;
4414		} else if (configureGrub2) {
4415		cfi = &grub2ConfigType;
4416		if (envPath)
4417		cfi->envFile = envPath;
4418	} else if (configureLilo) {	} else if (configureLilo) {
4419	cfi = &liloConfigType;	cfi = &liloConfigType;
4420	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 2912  int main(int argc, const char ** argv) {	Line 4433  int main(int argc, const char ** argv) {
4433	}	}
4434
4435	if (!cfi) {	if (!cfi) {
4436		if (grub2FindConfig(&grub2ConfigType)) {
4437		cfi = &grub2ConfigType;
4438		if (envPath)
4439		cfi->envFile = envPath;
4440		} else
4441	#ifdef __ia64__	#ifdef __ia64__
4442	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4443	#elif __powerpc__	#elif __powerpc__
4444	cfi = &yabootConfigType;	cfi = &yabootConfigType;
4445	#elif __sparc__	#elif __sparc__
4446	cfi = &siloConfigType;	cfi = &siloConfigType;
4447	#elif __s390__	#elif __s390__
4448	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4449	#elif __s390x__	#elif __s390x__
4450	cfi = &ziplConfigtype;	cfi = &ziplConfigtype;
4451	#else	#else
4452	cfi = &grubConfigType;	cfi = &grubConfigType;
4453	#endif	#endif
4454	}	}
4455
4456	if (!grubConfig)	if (!grubConfig) {
4457	grubConfig = cfi->defaultConfig;	if (cfi->findConfig)
4458		grubConfig = cfi->findConfig(cfi);
4459		if (!grubConfig)
4460		grubConfig = cfi->defaultConfig;
4461		}
4462
4463	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4464	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4465	defaultKernel)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4466		(defaultIndex >= 0))) {
4467	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4468	"specified option"));	"specified option"));
4469	return 1;	return 1;
4470	}	}
4471
4472	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4473	removeKernelPath)) {	removeKernelPath)) {
4474	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4475	"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 4479  int main(int argc, const char ** argv) {
4479	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4480	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4481	return 1;	return 1;
4482	} else if (!newKernelPath && (newKernelTitle  || newKernelInitrd ||	} else if (!newKernelPath && (copyDefault ||
4483	newKernelInitrd || copyDefault     ||	(newKernelInitrd && !updateKernelPath)||
4484	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4485	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
4486	return 1;	return 1;
#	Line 2974  int main(int argc, const char ** argv) {	Line 4505  int main(int argc, const char ** argv) {
4505	makeDefault = 1;	makeDefault = 1;
4506	defaultKernel = NULL;	defaultKernel = NULL;
4507	}	}
4508		else if (defaultKernel && (defaultIndex >= 0)) {
4509		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4510		"may not be used together\n"));
4511		return 1;
4512		}
4513
4514	if (!strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4515	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
4516	"is used\n"));	"is used\n"));
4517	return 1;	return 1;
4518	}	}
4519
4520	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4521	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4522	&& !removeMBKernel) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4523		&& (defaultIndex == -1)) {
4524	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4525	return 1;	return 1;
4526	}	}
#	Line 3010  int main(int argc, const char ** argv) {	Line 4547  int main(int argc, const char ** argv) {
4547	}	}
4548
4549	if (bootloaderProbe) {	if (bootloaderProbe) {
4550	int lrc = 0, grc = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4551	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4552
4553		const char *grub2config = grub2FindConfig(&grub2ConfigType);
4554		if (grub2config) {
4555		gconfig = readConfig(grub2config, &grub2ConfigType);
4556		if (!gconfig)
4557		gr2c = 1;
4558		else
4559		gr2c = checkForGrub2(gconfig);
4560		}
4561
4562	if (!access(grubConfigType.defaultConfig, F_OK)) {	const char *grubconfig = grubFindConfig(&grubConfigType);
4563	gconfig = readConfig(grubConfigType.defaultConfig, &grubConfigType);	if (!access(grubconfig, F_OK)) {
4564		gconfig = readConfig(grubconfig, &grubConfigType);
4565	if (!gconfig)	if (!gconfig)
4566	grc = 1;	grc = 1;
4567	else	else
#	Line 3029  int main(int argc, const char ** argv) {	Line 4576  int main(int argc, const char ** argv) {
4576	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4577	}	}
4578
4579		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4580		econfig = readConfig(eliloConfigType.defaultConfig,
4581		&eliloConfigType);
4582		if (!econfig)
4583		erc = 1;
4584		else
4585		erc = checkForElilo(econfig);
4586		}
4587
4588	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4589	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4590	if (!lconfig)	if (!lconfig)
4591	erc = 1;	extrc = 1;
4592	else	else
4593	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4594	}	}
4595
4596	if (lrc == 1 || grc == 1) return 1;
4597		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4598		yconfig = readConfig(yabootConfigType.defaultConfig,
4599		&yabootConfigType);
4600		if (!yconfig)
4601		yrc = 1;
4602		else
4603		yrc = checkForYaboot(yconfig);
4604		}
4605
4606		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4607		erc == 1)
4608		return 1;
4609
4610	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4611		if (gr2c == 2) printf("grub2\n");
4612	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4613	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4614		if (yrc == 2) printf("yaboot\n");
4615		if (erc == 2) printf("elilo\n");
4616
4617	return 0;	return 0;
4618	}	}
4619
4620		if (grubConfig == NULL) {
4621		printf("Could not find bootloader configuration file.\n");
4622		exit(1);
4623		}
4624
4625	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4626	if (!config) return 1;	if (!config) return 1;
4627
#	Line 3055  int main(int argc, const char ** argv) {	Line 4631  int main(int argc, const char ** argv) {
4631	char * rootspec;	char * rootspec;
4632
4633	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4634		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4635		cfi->defaultIsSaved)
4636		config->defaultImage = 0;
4637	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4638	if (!entry) return 0;	if (!entry) return 0;
4639	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4640
4641	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4642	if (!line) return 0;	if (!line) return 0;
4643
4644	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3067  int main(int argc, const char ** argv) {	Line 4646  int main(int argc, const char ** argv) {
4646	((rootspec != NULL) ? strlen(rootspec) : 0));	((rootspec != NULL) ? strlen(rootspec) : 0));
4647
4648	return 0;	return 0;
4649
4650		} else if (displayDefaultTitle) {
4651		struct singleLine * line;
4652		struct singleEntry * entry;
4653
4654		if (config->defaultImage == -1)
4655		return 0;
4656		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4657		cfi->defaultIsSaved)
4658		config->defaultImage = 0;
4659		entry = findEntryByIndex(config, config->defaultImage);
4660		if (!entry)
4661		return 0;
4662
4663		if (!configureGrub2) {
4664		char *title;
4665		line = getLineByType(LT_TITLE, entry->lines);
4666		if (!line)
4667		return 0;
4668		title = extractTitle(config, line);
4669		if (!title)
4670		return 0;
4671		printf("%s\n", title);
4672		free(title);
4673		} else {
4674		char * title;
4675
4676		dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
4677		line = getLineByType(LT_MENUENTRY, entry->lines);
4678		if (!line)
4679		return 0;
4680		title = grub2ExtractTitle(line);
4681		if (title)
4682		printf("%s\n", title);
4683		}
4684		return 0;
4685
4686		} else if (displayDefaultIndex) {
4687		if (config->defaultImage == -1) return 0;
4688		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4689		cfi->defaultIsSaved)
4690		config->defaultImage = 0;
4691		printf("%i\n", config->defaultImage);
4692		return 0;
4693
4694	} else if (kernelInfo)	} else if (kernelInfo)
4695	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
4696
#	Line 3078  int main(int argc, const char ** argv) {	Line 4702  int main(int argc, const char ** argv) {
4702	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4703	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4704	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4705	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4706	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4707	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4708	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4709		if (updateKernelPath && newKernelInitrd) {
4710		if (newMBKernel) {
4711		if (addMBInitrd(config, newMBKernel, updateKernelPath,
4712		bootPrefix, newKernelInitrd,
4713		newKernelTitle))
4714		return 1;
4715		} else {
4716		if (updateInitrd(config, updateKernelPath, bootPrefix,
4717		newKernelInitrd, newKernelTitle))
4718		return 1;
4719		}
4720		}
4721	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4722	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4723	extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4724	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4725
4726
4727	if (numEntries(config) == 0) {	if (numEntries(config) == 0) {
#	Line 3095  int main(int argc, const char ** argv) {	Line 4731  int main(int argc, const char ** argv) {
4731	}	}
4732
4733	if (!outputFile)	if (!outputFile)
4734	outputFile = grubConfig;	outputFile = (char *)grubConfig;
4735
4736	return writeConfig(config, outputFile, bootPrefix);	return writeConfig(config, outputFile, bootPrefix);
4737	}	}

---

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

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