Diff of /trunk/grubby/grubby.c

Parent Directory | Revision Log | Patch

	trunk/mkinitrd-magellan/grubby/grubby.c revision 926 by niro, Wed Oct 28 13:29:38 2009 UTC	trunk/grubby/grubby.c revision 2989 by niro, Thu Jun 30 10:32:12 2016 UTC
#	Line 36	Line 36
36	#include <signal.h>	#include <signal.h>
37	#include <blkid/blkid.h>	#include <blkid/blkid.h>
38
39		#include "log.h"
40
41		#ifndef DEBUG
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	"/boot/grub/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);
443		*(tmp + current_len - 1) = '\0';
444		return ++tmp;
445		}
446
447		/* if no quotes, return second word verbatim */
448		if (!isquote(*current))
449		return current;
450
451		/* second element start with a quote, so we have to find the element
452		* whose last character is also quote (assuming it's the closing one) */
453		int resultMaxSize;
454		char * result;
455		/* need to ensure that ' does not match " as we search */
456		char quote_char = *current;
457
458		resultMaxSize = sizeOfSingleLine(line);
459		result = malloc(resultMaxSize);
460		snprintf(result, resultMaxSize, "%s", ++current);
461
462		i++;
463		for (; i < line->numElements; ++i) {
464		current = line->elements[i].item;
465		current_len = strlen(current);
466		current_indent = line->elements[i].indent;
467		current_indent_len = strlen(current_indent);
468
469		strncat(result, current_indent, current_indent_len);
470		if (current[current_len-1] != quote_char) {
471		strncat(result, current, current_len);
472		} else {
473		strncat(result, current, current_len - 1);
474		break;
475		}
476		}
477		return result;
478		}
479
480		struct configFileInfo grub2ConfigType = {
481		.findConfig = grub2FindConfig,
482		.getEnv = grub2GetEnv,
483		.setEnv = grub2SetEnv,
484		.keywords = grub2Keywords,
485		.defaultIsIndex = 1,
486		.defaultSupportSaved = 1,
487		.defaultIsVariable = 1,
488		.entryStart = LT_MENUENTRY,
489		.entryEnd = LT_ENTRY_END,
490		.titlePosition = 1,
491		.needsBootPrefix = 1,
492		.mbHyperFirst = 1,
493		.mbInitRdIsModule = 1,
494		.mbAllowExtraInitRds = 1,
495	};	};
496
497	struct keywordTypes yabootKeywords[] = {	struct keywordTypes yabootKeywords[] = {
#	Line 245  struct keywordTypes extlinuxKeywords[] =	Line 585  struct keywordTypes extlinuxKeywords[] =
585	{ "initrd",    LT_INITRD,      ' ', ',' },	{ "initrd",    LT_INITRD,      ' ', ',' },
586	{ "append",    LT_KERNELARGS,  ' ' },	{ "append",    LT_KERNELARGS,  ' ' },
587	{ "prompt",     LT_UNKNOWN,     ' ' },	{ "prompt",     LT_UNKNOWN,     ' ' },
588		{ "fdt",        LT_DEVTREE,     ' ' },
589		{ "fdtdir",     LT_DEVTREE,     ' ' },
590	{ NULL,    0, 0 },	{ NULL,    0, 0 },
591	};	};
592	int useextlinuxmenu;	int useextlinuxmenu;
593	struct configFileInfo eliloConfigType = {	struct configFileInfo eliloConfigType = {
594	"/boot/efi/EFI/redhat/elilo.conf",    /* defaultConfig */	.defaultConfig = "/boot/efi/EFI/redhat/elilo.conf",
595	eliloKeywords,    /* keywords */	.keywords = eliloKeywords,
596	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
597	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
598	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
599	1,                    /* needsBootPrefix */	.mbConcatArgs = 1,
600	1,    /* argsInQuotes */	.titlePosition = 1,
	0,    /* maxTitleLength */
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	1,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
601	};	};
602
603	struct configFileInfo liloConfigType = {	struct configFileInfo liloConfigType = {
604	"/etc/lilo.conf",    /* defaultConfig */	.defaultConfig = "/etc/lilo.conf",
605	liloKeywords,    /* keywords */	.keywords = liloKeywords,
606	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
607	0,    /* defaultSupportSaved */	.argsInQuotes = 1,
608	LT_KERNEL,    /* entrySeparator */	.maxTitleLength = 15,
609	0,    /* needsBootPrefix */	.titlePosition = 1,
	1,    /* argsInQuotes */
	15,    /* maxTitleLength */
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
610	};	};
611
612	struct configFileInfo yabootConfigType = {	struct configFileInfo yabootConfigType = {
613	"/etc/yaboot.conf",    /* defaultConfig */	.defaultConfig = "/etc/yaboot.conf",
614	yabootKeywords,    /* keywords */	.keywords = yabootKeywords,
615	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
616	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
617	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
618	1,    /* needsBootPrefix */	.maxTitleLength = 15,
619	1,    /* argsInQuotes */	.mbAllowExtraInitRds = 1,
620	15,    /* maxTitleLength */	.titlePosition = 1,
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	1,                                      /* mbAllowExtraInitRds */
621	};	};
622
623	struct configFileInfo siloConfigType = {	struct configFileInfo siloConfigType = {
624	"/etc/silo.conf",    /* defaultConfig */	.defaultConfig = "/etc/silo.conf",
625	siloKeywords,    /* keywords */	.keywords = siloKeywords,
626	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
627	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
628	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
629	1,    /* needsBootPrefix */	.maxTitleLength = 15,
630	1,    /* argsInQuotes */	.titlePosition = 1,
	15,    /* maxTitleLength */
	0,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
631	};	};
632
633	struct configFileInfo ziplConfigType = {	struct configFileInfo ziplConfigType = {
634	"/etc/zipl.conf",    /* defaultConfig */	.defaultConfig = "/etc/zipl.conf",
635	ziplKeywords,    /* keywords */	.keywords = ziplKeywords,
636	0,    /* defaultIsIndex */	.entryStart = LT_TITLE,
637	0,    /* defaultSupportSaved */	.argsInQuotes = 1,
638	LT_TITLE,    /* entrySeparator */	.titleBracketed = 1,
	0,    /* needsBootPrefix */
	1,    /* argsInQuotes */
	0,    /* maxTitleLength */
	1,                                      /* titleBracketed */
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	0,                                      /* mbAllowExtraInitRds */
639	};	};
640
641	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
642	"/boot/extlinux/extlinux.conf",         /* defaultConfig */	.defaultConfig = "/boot/extlinux/extlinux.conf",
643	extlinuxKeywords,                       /* keywords */	.keywords = extlinuxKeywords,
644	0,                                      /* defaultIsIndex */	.caseInsensitive = 1,
645	0,                                      /* defaultSupportSaved */	.entryStart = LT_TITLE,
646	LT_TITLE,                               /* entrySeparator */	.needsBootPrefix = 1,
647	1,                                      /* needsBootPrefix */	.maxTitleLength = 255,
648	0,                                      /* argsInQuotes */	.mbAllowExtraInitRds = 1,
649	255,                                    /* maxTitleLength */	.defaultIsUnquoted = 1,
650	0,                                      /* titleBracketed */	.titlePosition = 1,
	0,                                      /* mbHyperFirst */
	0,                                      /* mbInitRdIsModule */
	0,                                      /* mbConcatArgs */
	1,                                      /* mbAllowExtraInitRds */
651	};	};
652
653	struct grubConfig {	struct grubConfig {
#	Line 356  struct grubConfig {	Line 662  struct grubConfig {
662	struct configFileInfo * cfi;	struct configFileInfo * cfi;
663	};	};
664
665		blkid_cache blkid;
666
667	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index);	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index);
668	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
669	const char * path, const char * prefix,	const char * path, const char * prefix,
670	int * index);	int * index);
671		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
672		int * index);
673	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
674	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
675	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 369  static int lineWrite(FILE * out, struct	Line 679  static int lineWrite(FILE * out, struct
679	static int getNextLine(char ** bufPtr, struct singleLine * line,	static int getNextLine(char ** bufPtr, struct singleLine * line,
680	struct configFileInfo * cfi);	struct configFileInfo * cfi);
681	static char * getRootSpecifier(char * str);	static char * getRootSpecifier(char * str);
682		static void requote(struct singleLine *line, struct configFileInfo * cfi);
683	static void insertElement(struct singleLine * line,	static void insertElement(struct singleLine * line,
684	const char * item, int insertHere,	const char * item, int insertHere,
685	struct configFileInfo * cfi);	struct configFileInfo * cfi);
#	Line 423  static char * sdupprintf(const char *for	Line 734  static char * sdupprintf(const char *for
734	return buf;	return buf;
735	}	}
736
737		static enum lineType_e preferredLineType(enum lineType_e type,
738		struct configFileInfo *cfi) {
739		if (isEfi && cfi == &grub2ConfigType) {
740		switch (type) {
741		case LT_KERNEL:
742		return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
743		case LT_INITRD:
744		return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
745		default:
746		return type;
747		}
748		#if defined(__i386__) || defined(__x86_64__)
749		} else if (cfi == &grub2ConfigType) {
750		switch (type) {
751		case LT_KERNEL:
752		return LT_KERNEL_16;
753		case LT_INITRD:
754		return LT_INITRD_16;
755		default:
756		return type;
757		}
758		#endif
759		}
760		return type;
761		}
762
763	static struct keywordTypes * getKeywordByType(enum lineType_e type,	static struct keywordTypes * getKeywordByType(enum lineType_e type,
764	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
765	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
	for (kw = cfi->keywords; kw->key; kw++) {
766	if (kw->type == type)	if (kw->type == type)
767	return kw;	return kw;
768	}	}
769	return NULL;	return NULL;
770	}	}
771
772	static char * getpathbyspec(char *device) {	static char *getKeyByType(enum lineType_e type, struct configFileInfo * cfi) {
773	static blkid_cache blkid;	struct keywordTypes *kt = getKeywordByType(type, cfi);
774		if (kt)
775		return kt->key;
776		return "unknown";
777		}
778
779		static char * getpathbyspec(char *device) {
780	if (!blkid)	if (!blkid)
781	blkid_get_cache(&blkid, NULL);	blkid_get_cache(&blkid, NULL);
782
783	return blkid_get_devname(blkid, device, NULL);	return blkid_get_devname(blkid, device, NULL);
784	}	}
785
786		static char * getuuidbydev(char *device) {
787		if (!blkid)
788		blkid_get_cache(&blkid, NULL);
789
790		return blkid_get_tag_value(blkid, "UUID", device);
791		}
792
793	static enum lineType_e getTypeByKeyword(char * keyword,	static enum lineType_e getTypeByKeyword(char * keyword,
794	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
795	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
796	for (kw = cfi->keywords; kw->key; kw++) {	if (cfi->caseInsensitive) {
797	if (!strcmp(keyword, kw->key))	if (!strcasecmp(keyword, kw->key))
798	return kw->type;	return kw->type;
799		} else {
800		if (!strcmp(keyword, kw->key))
801		return kw->type;
802		}
803	}	}
804	return LT_UNKNOWN;	return LT_UNKNOWN;
805	}	}
#	Line 477  static int isBracketedTitle(struct singl	Line 829  static int isBracketedTitle(struct singl
829	return 0;	return 0;
830	}	}
831
832	static int isEntrySeparator(struct singleLine * line,	static int isEntryStart(struct singleLine * line,
833	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
834	return line->type == cfi->entrySeparator || line->type == LT_OTHER ||	return line->type == cfi->entryStart || line->type == LT_OTHER ||
835	(cfi->titleBracketed && isBracketedTitle(line));	(cfi->titleBracketed && isBracketedTitle(line));
836	}	}
837
838	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
839	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct grubConfig *cfg, struct singleLine * line) {
840	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it */
841	char * title;	char * title = NULL;
842	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
843	title++;	char *tmp = line->elements[cfg->cfi->titlePosition].item;
844	*(title + strlen(title) - 1) = '\0';	if (cfg->cfi->titleBracketed) {
845		tmp++;
846		title = strdup(tmp);
847		*(title + strlen(title) - 1) = '\0';
848		} else {
849		title = strdup(tmp);
850		}
851		} else if (line->type == LT_MENUENTRY)
852		title = strdup(line->elements[1].item);
853		else
854		return NULL;
855	return title;	return title;
856	}	}
857
#	Line 532  static void lineInit(struct singleLine *	Line 894  static void lineInit(struct singleLine *
894	}	}
895
896	struct singleLine * lineDup(struct singleLine * line) {	struct singleLine * lineDup(struct singleLine * line) {
	int i;
897	struct singleLine * newLine = malloc(sizeof(*newLine));	struct singleLine * newLine = malloc(sizeof(*newLine));
898
899	newLine->indent = strdup(line->indent);	newLine->indent = strdup(line->indent);
#	Line 542  struct singleLine * lineDup(struct singl	Line 903  struct singleLine * lineDup(struct singl
903	newLine->elements = malloc(sizeof(*newLine->elements) *	newLine->elements = malloc(sizeof(*newLine->elements) *
904	newLine->numElements);	newLine->numElements);
905
906	for (i = 0; i < newLine->numElements; i++) {	for (int i = 0; i < newLine->numElements; i++) {
907	newLine->elements[i].indent = strdup(line->elements[i].indent);	newLine->elements[i].indent = strdup(line->elements[i].indent);
908	newLine->elements[i].item = strdup(line->elements[i].item);	newLine->elements[i].item = strdup(line->elements[i].item);
909	}	}
#	Line 551  struct singleLine * lineDup(struct singl	Line 912  struct singleLine * lineDup(struct singl
912	}	}
913
914	static void lineFree(struct singleLine * line) {	static void lineFree(struct singleLine * line) {
	int i;
915	if (line->indent) free(line->indent);	if (line->indent) free(line->indent);
916
917	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
918	free(line->elements[i].item);	free(line->elements[i].item);
919	free(line->elements[i].indent);	free(line->elements[i].indent);
920	}	}
#	Line 566  static void lineFree(struct singleLine *	Line 925  static void lineFree(struct singleLine *
925
926	static int lineWrite(FILE * out, struct singleLine * line,	static int lineWrite(FILE * out, struct singleLine * line,
927	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
	int i;
928	if (fprintf(out, "%s", line->indent) == -1) return -1;	if (fprintf(out, "%s", line->indent) == -1) return -1;
929
930	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
931		/* Need to handle this, because we strip the quotes from
932		* menuentry when read it. */
933		if (line->type == LT_MENUENTRY && i == 1) {
934		if(!isquote(*line->elements[i].item)) {
935		int substring = 0;
936		/* If the line contains nested quotes, we did not strip
937		* the "interna" quotes and we must use the right quotes
938		* again when writing the updated file. */
939		for (int j = i; j < line->numElements; j++) {
940		if (strchr(line->elements[i].item, '\'') != NULL) {
941		substring = 1;
942		fprintf(out, "\"%s\"", line->elements[i].item);
943		break;
944		}
945		}
946		if (!substring)
947		fprintf(out, "\'%s\'", line->elements[i].item);
948		} else {
949		fprintf(out, "%s", line->elements[i].item);
950		}
951		fprintf(out, "%s", line->elements[i].indent);
952
953		continue;
954		}
955
956	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
957	if (fputc('"', out) == EOF) return -1;	if (fputc('"', out) == EOF) return -1;
958
#	Line 664  static int getNextLine(char ** bufPtr, s	Line 1046  static int getNextLine(char ** bufPtr, s
1046	if (*line->elements[0].item == '#') {	if (*line->elements[0].item == '#') {
1047	char * fullLine;	char * fullLine;
1048	int len;	int len;
	int i;
1049
1050	len = strlen(line->indent);	len = strlen(line->indent);
1051	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1052	len += strlen(line->elements[i].item) +	len += strlen(line->elements[i].item) +
1053	strlen(line->elements[i].indent);	strlen(line->elements[i].indent);
1054
#	Line 676  static int getNextLine(char ** bufPtr, s	Line 1057  static int getNextLine(char ** bufPtr, s
1057	free(line->indent);	free(line->indent);
1058	line->indent = fullLine;	line->indent = fullLine;
1059
1060	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1061	strcat(fullLine, line->elements[i].item);	strcat(fullLine, line->elements[i].item);
1062	strcat(fullLine, line->elements[i].indent);	strcat(fullLine, line->elements[i].indent);
1063	free(line->elements[i].item);	free(line->elements[i].item);
#	Line 695  static int getNextLine(char ** bufPtr, s	Line 1076  static int getNextLine(char ** bufPtr, s
1076	* elements up more	* elements up more
1077	*/	*/
1078	if (!isspace(kw->separatorChar)) {	if (!isspace(kw->separatorChar)) {
	int i;
1079	char indent[2] = "";	char indent[2] = "";
1080	indent[0] = kw->separatorChar;	indent[0] = kw->separatorChar;
1081	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1082	char *p;	char *p;
	int j;
1083	int numNewElements;	int numNewElements;
1084
1085	numNewElements = 0;	numNewElements = 0;
#	Line 716  static int getNextLine(char ** bufPtr, s	Line 1095  static int getNextLine(char ** bufPtr, s
1095	sizeof(*line->elements) * elementsAlloced);	sizeof(*line->elements) * elementsAlloced);
1096	}	}
1097
1098	for (j = line->numElements; j > i; j--) {	for (int j = line->numElements; j > i; j--) {
1099	line->elements[j + numNewElements] = line->elements[j];	line->elements[j + numNewElements] = line->elements[j];
1100	}	}
1101	line->numElements += numNewElements;	line->numElements += numNewElements;
#	Line 729  static int getNextLine(char ** bufPtr, s	Line 1108  static int getNextLine(char ** bufPtr, s
1108	break;	break;
1109	}	}
1110
1111	free(line->elements[i].indent);	line->elements[i + 1].indent = line->elements[i].indent;
1112	line->elements[i].indent = strdup(indent);	line->elements[i].indent = strdup(indent);
1113	*p++ = '\0';	*p++ = '\0';
1114	i++;	i++;
1115	line->elements[i].item = strdup(p);	line->elements[i].item = strdup(p);
	line->elements[i].indent = strdup("");
	p = line->elements[i].item;
1116	}	}
1117	}	}
1118	}	}
#	Line 745  static int getNextLine(char ** bufPtr, s	Line 1122  static int getNextLine(char ** bufPtr, s
1122	return 0;	return 0;
1123	}	}
1124
1125		static int isnumber(const char *s)
1126		{
1127		int i;
1128		for (i = 0; s[i] != '\0'; i++)
1129		if (s[i] < '0' || s[i] > '9')
1130		return 0;
1131		return i;
1132		}
1133
1134	static struct grubConfig * readConfig(const char * inName,	static struct grubConfig * readConfig(const char * inName,
1135	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
1136	int in;	int in;
#	Line 756  static struct grubConfig * readConfig(co	Line 1142  static struct grubConfig * readConfig(co
1142	struct singleLine * last = NULL, * line, * defaultLine = NULL;	struct singleLine * last = NULL, * line, * defaultLine = NULL;
1143	char * end;	char * end;
1144	struct singleEntry * entry = NULL;	struct singleEntry * entry = NULL;
1145	int i, len;	int len;
1146	char * buf;	char * buf;
1147
1148	if (!strcmp(inName, "-")) {	if (inName == NULL) {
1149		printf("Could not find bootloader configuration\n");
1150		exit(1);
1151		} else if (!strcmp(inName, "-")) {
1152	in = 0;	in = 0;
1153	} else {	} else {
1154	if ((in = open(inName, O_RDONLY)) < 0) {	if ((in = open(inName, O_RDONLY)) < 0) {
#	Line 802  static struct grubConfig * readConfig(co	Line 1191  static struct grubConfig * readConfig(co
1191	cfg->secondaryIndent = strdup(line->indent);	cfg->secondaryIndent = strdup(line->indent);
1192	}	}
1193
1194	if (isEntrySeparator(line, cfi)) {	if (isEntryStart(line, cfi) || (cfg->entries && !sawEntry)) {
1195	sawEntry = 1;	sawEntry = 1;
1196	if (!entry) {	if (!entry) {
1197	cfg->entries = malloc(sizeof(*entry));	cfg->entries = malloc(sizeof(*entry));
#	Line 818  static struct grubConfig * readConfig(co	Line 1207  static struct grubConfig * readConfig(co
1207	entry->next = NULL;	entry->next = NULL;
1208	}	}
1209
1210	if (line->type == LT_DEFAULT && line->numElements == 2) {	if (line->type == LT_SET_VARIABLE) {
1211	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	dbgPrintf("found 'set' command (%d elements): ", line->numElements);
1212	defaultLine = line;	dbgPrintf("%s", line->indent);
1213		for (int i = 0; i < line->numElements; i++)
1214		dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
1215		dbgPrintf("\n");
1216		struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1217		if (kwType && line->numElements == 3 &&
1218		!strcmp(line->elements[1].item, kwType->key) &&
1219		!is_special_grub2_variable(line->elements[2].item)) {
1220		dbgPrintf("Line sets default config\n");
1221		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1222		defaultLine = line;
1223		}
1224
1225	} else if (line->type == LT_KERNEL) {	} else if (iskernel(line->type)) {
1226	/* if by some freak chance this is multiboot and the "module"	/* if by some freak chance this is multiboot and the "module"
1227	* lines came earlier in the template, make sure to use LT_HYPER	* lines came earlier in the template, make sure to use LT_HYPER
1228	* instead of LT_KERNEL now	* instead of LT_KERNEL now
1229	*/	*/
1230	if (entry->multiboot)	if (entry && entry->multiboot)
1231	line->type = LT_HYPER;	line->type = LT_HYPER;
1232
1233	} else if (line->type == LT_MBMODULE) {	} else if (line->type == LT_MBMODULE) {
#	Line 836  static struct grubConfig * readConfig(co	Line 1236  static struct grubConfig * readConfig(co
1236	* This only applies to grub, but that's the only place we	* This only applies to grub, but that's the only place we
1237	* should find LT_MBMODULE lines anyway.	* should find LT_MBMODULE lines anyway.
1238	*/	*/
1239	struct singleLine * l;	for (struct singleLine *l = entry->lines; l; l = l->next) {
	for (l = entry->lines; l; l = l->next) {
1240	if (l->type == LT_HYPER)	if (l->type == LT_HYPER)
1241	break;	break;
1242	else if (l->type == LT_KERNEL) {	else if (iskernel(l->type)) {
1243	l->type = LT_HYPER;	l->type = LT_HYPER;
1244	break;	break;
1245	}	}
#	Line 854  static struct grubConfig * readConfig(co	Line 1253  static struct grubConfig * readConfig(co
1253	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1254	if (*end) cfg->fallbackImage = -1;	if (*end) cfg->fallbackImage = -1;
1255
1256	} else if (line->type == LT_TITLE && line->numElements > 1) {	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1257	/* make the title a single argument (undoing our parsing) */	(line->type == LT_TITLE && line->numElements > 1)) {
1258		/* make the title/default a single argument (undoing our parsing) */
1259	len = 0;	len = 0;
1260	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1261	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
1262	len += strlen(line->elements[i].indent);	len += strlen(line->elements[i].indent);
1263	}	}
1264	buf = malloc(len + 1);	buf = malloc(len + 1);
1265	*buf = '\0';	*buf = '\0';
1266
1267	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1268	strcat(buf, line->elements[i].item);	strcat(buf, line->elements[i].item);
1269	free(line->elements[i].item);	free(line->elements[i].item);
1270
#	Line 878  static struct grubConfig * readConfig(co	Line 1278  static struct grubConfig * readConfig(co
1278	line->elements[line->numElements - 1].indent;	line->elements[line->numElements - 1].indent;
1279	line->elements[1].item = buf;	line->elements[1].item = buf;
1280	line->numElements = 2;	line->numElements = 2;
1281		} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
1282		/* let --remove-kernel="TITLE=what" work */
1283		len = 0;
1284		char *extras;
1285		char *title;
1286		/* initially unseen value */
1287		char quote_char = '\0';
1288
1289		for (int i = 1; i < line->numElements; i++) {
1290		len += strlen(line->elements[i].item);
1291		len += strlen(line->elements[i].indent);
1292		}
1293		buf = malloc(len + 1);
1294		*buf = '\0';
1295
1296		/* allocate mem for extra flags. */
1297		extras = malloc(len + 1);
1298		*extras = '\0';
1299
1300		/* get title. */
1301		for (int i = 0; i < line->numElements; i++) {
1302		if (!strcmp(line->elements[i].item, "menuentry"))
1303		continue;
1304		if (isquote(*line->elements[i].item) && quote_char == '\0') {
1305		/* ensure we properly pair off quotes */
1306		quote_char = *line->elements[i].item;
1307		title = line->elements[i].item + 1;
1308		} else {
1309		title = line->elements[i].item;
1310		}
1311
1312		len = strlen(title);
1313		if (title[len-1] == quote_char) {
1314		strncat(buf, title,len-1);
1315		break;
1316		} else {
1317		strcat(buf, title);
1318		strcat(buf, line->elements[i].indent);
1319		}
1320		}
1321
1322		/* get extras */
1323		int count = 0;
1324		quote_char = '\0';
1325		for (int i = 0; i < line->numElements; i++) {
1326		if (count >= 2) {
1327		strcat(extras, line->elements[i].item);
1328		strcat(extras, line->elements[i].indent);
1329		}
1330
1331		if (!strcmp(line->elements[i].item, "menuentry"))
1332		continue;
1333
1334		/* count ' or ", there should be two in menuentry line. */
1335		if (isquote(*line->elements[i].item) && quote_char == '\0') {
1336		/* ensure we properly pair off quotes */
1337		quote_char = *line->elements[i].item;
1338		count++;
1339		}
1340
1341		len = strlen(line->elements[i].item);
1342
1343		if (line->elements[i].item[len -1] == quote_char)
1344		count++;
1345
1346		/* ok, we get the final ' or ", others are extras. */
1347		}
1348		line->elements[1].indent =
1349		line->elements[line->numElements - 2].indent;
1350		line->elements[1].item = buf;
1351		line->elements[2].indent =
1352		line->elements[line->numElements - 2].indent;
1353		line->elements[2].item = extras;
1354		line->numElements = 3;
1355	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
1356	/* Strip off any " which may be present; they'll be put back	/* Strip off any " which may be present; they'll be put back
1357	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 1360  static struct grubConfig * readConfig(co
1360	if (line->numElements >= 2) {	if (line->numElements >= 2) {
1361	int last, len;	int last, len;
1362
1363	if (*line->elements[1].item == '"')	if (isquote(*line->elements[1].item))
1364	memmove(line->elements[1].item, line->elements[1].item + 1,	memmove(line->elements[1].item, line->elements[1].item + 1,
1365	strlen(line->elements[1].item + 1) + 1);	strlen(line->elements[1].item + 1) + 1);
1366
1367	last = line->numElements - 1;	last = line->numElements - 1;
1368	len = strlen(line->elements[last].item) - 1;	len = strlen(line->elements[last].item) - 1;
1369	if (line->elements[last].item[len] == '"')	if (isquote(line->elements[last].item[len]))
1370	line->elements[last].item[len] = '\0';	line->elements[last].item[len] = '\0';
1371	}	}
1372	}	}
1373
1374		if (line->type == LT_DEFAULT && line->numElements == 2) {
1375		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1376		defaultLine = line;
1377		}
1378
1379	/* If we find a generic config option which should live at the	/* If we find a generic config option which should live at the
1380	top of the file, move it there. Old versions of grubby were	top of the file, move it there. Old versions of grubby were
1381	probably responsible for putting new images in the wrong	probably responsible for putting new images in the wrong
#	Line 931  static struct grubConfig * readConfig(co	Line 1409  static struct grubConfig * readConfig(co
1409	entry->lines = line;	entry->lines = line;
1410	else	else
1411	last->next = line;	last->next = line;
1412	dbgPrintf("readConfig added %d to %p\n", line->type, entry);	dbgPrintf("readConfig added %s to %p\n", getKeyByType(line->type, cfi), entry);
1413
1414		/* we could have seen this outside of an entry... if so, we
1415		* ignore it like any other line we don't grok */
1416		if (line->type == LT_ENTRY_END && sawEntry)
1417		sawEntry = 0;
1418	} else {	} else {
1419	if (!cfg->theLines)	if (!cfg->theLines)
1420	cfg->theLines = line;	cfg->theLines = line;
1421	else	else
1422	last->next = line;	last->next = line;
1423	dbgPrintf("readConfig added %d to cfg\n", line->type);	dbgPrintf("readConfig added %s to cfg\n", getKeyByType(line->type, cfi));
1424	}	}
1425
1426	last = line;	last = line;
#	Line 945  static struct grubConfig * readConfig(co	Line 1428  static struct grubConfig * readConfig(co
1428
1429	free(incoming);	free(incoming);
1430
1431		dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");
1432	if (defaultLine) {	if (defaultLine) {
1433	if (cfi->defaultSupportSaved &&	if (defaultLine->numElements > 2 &&
1434		cfi->defaultSupportSaved &&
1435		!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1436		cfg->cfi->defaultIsSaved = 1;
1437		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1438		if (cfg->cfi->getEnv) {
1439		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1440		if (defTitle) {
1441		int index = 0;
1442		if (isnumber(defTitle)) {
1443		index = atoi(defTitle);
1444		entry = findEntryByIndex(cfg, index);
1445		} else {
1446		entry = findEntryByTitle(cfg, defTitle, &index);
1447		}
1448		if (entry)
1449		cfg->defaultImage = index;
1450		}
1451		}
1452		} else if (cfi->defaultIsVariable) {
1453		char *value = defaultLine->elements[2].item;
1454		while (*value && (*value == '"' || *value == '\'' ||
1455		*value == ' ' || *value == '\t'))
1456		value++;
1457		cfg->defaultImage = strtol(value, &end, 10);
1458		while (*end && (*end == '"' || *end == '\'' ||
1459		*end == ' ' || *end == '\t'))
1460		end++;
1461		if (*end) cfg->defaultImage = -1;
1462		} else if (cfi->defaultSupportSaved &&
1463	!strncmp(defaultLine->elements[1].item, "saved", 5)) {	!strncmp(defaultLine->elements[1].item, "saved", 5)) {
1464	cfg->defaultImage = DEFAULT_SAVED;	cfg->defaultImage = DEFAULT_SAVED;
1465	} else if (cfi->defaultIsIndex) {	} else if (cfi->defaultIsIndex) {
1466	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
1467	if (*end) cfg->defaultImage = -1;	if (*end) cfg->defaultImage = -1;
1468	} else if (defaultLine->numElements >= 2) {	} else if (defaultLine->numElements >= 2) {
1469	i = 0;	int i = 0;
1470	while ((entry = findEntryByIndex(cfg, i))) {	while ((entry = findEntryByIndex(cfg, i))) {
1471	for (line = entry->lines; line; line = line->next)	for (line = entry->lines; line; line = line->next)
1472	if (line->type == LT_TITLE) break;	if (line->type == LT_TITLE) break;
#	Line 964  static struct grubConfig * readConfig(co	Line 1477  static struct grubConfig * readConfig(co
1477	line->elements[1].item)) break;	line->elements[1].item)) break;
1478	} else if (line) {	} else if (line) {
1479	if (!strcmp(defaultLine->elements[1].item,	if (!strcmp(defaultLine->elements[1].item,
1480	extractTitle(line))) break;	extractTitle(cfg, line))) break;
1481	}	}
1482	i++;	i++;
1483	entry = NULL;	entry = NULL;
#	Line 976  static struct grubConfig * readConfig(co	Line 1489  static struct grubConfig * readConfig(co
1489	cfg->defaultImage = -1;	cfg->defaultImage = -1;
1490	}	}
1491	}	}
1492		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1493		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1494		if (defTitle) {
1495		int index = 0;
1496		if (isnumber(defTitle)) {
1497		index = atoi(defTitle);
1498		entry = findEntryByIndex(cfg, index);
1499		} else {
1500		entry = findEntryByTitle(cfg, defTitle, &index);
1501		}
1502		if (entry)
1503		cfg->defaultImage = index;
1504		}
1505	} else {	} else {
1506	cfg->defaultImage = 0;	cfg->defaultImage = 0;
1507	}	}
#	Line 993  static void writeDefault(FILE * out, cha	Line 1519  static void writeDefault(FILE * out, cha
1519
1520	if (cfg->defaultImage == DEFAULT_SAVED)	if (cfg->defaultImage == DEFAULT_SAVED)
1521	fprintf(out, "%sdefault%ssaved\n", indent, separator);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1522	else if (cfg->defaultImage > -1) {	else if (cfg->cfi->defaultIsSaved) {
1523		fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1524		if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1525		char *title;
1526		entry = findEntryByIndex(cfg, cfg->defaultImage);
1527		line = getLineByType(LT_MENUENTRY, entry->lines);
1528		if (!line)
1529		line = getLineByType(LT_TITLE, entry->lines);
1530		if (line) {
1531		title = extractTitle(cfg, line);
1532		if (title)
1533		cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1534		}
1535		}
1536		} else if (cfg->defaultImage > -1) {
1537	if (cfg->cfi->defaultIsIndex) {	if (cfg->cfi->defaultIsIndex) {
1538	fprintf(out, "%sdefault%s%d\n", indent, separator,	if (cfg->cfi->defaultIsVariable) {
1539	cfg->defaultImage);	fprintf(out, "%sset default=\"%d\"\n", indent,
1540		cfg->defaultImage);
1541		} else {
1542		fprintf(out, "%sdefault%s%d\n", indent, separator,
1543		cfg->defaultImage);
1544		}
1545	} else {	} else {
1546	int image = cfg->defaultImage;	int image = cfg->defaultImage;
1547
#	Line 1021  static void writeDefault(FILE * out, cha	Line 1566  static void writeDefault(FILE * out, cha
1566	else if (line && (line->numElements == 1) &&	else if (line && (line->numElements == 1) &&
1567	cfg->cfi->titleBracketed) {	cfg->cfi->titleBracketed) {
1568	fprintf(out, "%sdefault%s%s\n", indent, separator,	fprintf(out, "%sdefault%s%s\n", indent, separator,
1569	extractTitle(line));	extractTitle(cfg, line));
1570	}	}
1571	}	}
1572	}	}
#	Line 1048  static int writeConfig(struct grubConfig	Line 1593  static int writeConfig(struct grubConfig
1593
1594	/* most likely the symlink is relative, so change our	/* most likely the symlink is relative, so change our
1595	directory to the dir of the symlink */	directory to the dir of the symlink */
1596	rc = chdir(dirname(strdupa(outName)));	char *dir = strdupa(outName);
1597		rc = chdir(dirname(dir));
1598	do {	do {
1599	buf = alloca(len + 1);	buf = alloca(len + 1);
1600	rc = readlink(basename(outName), buf, len);	rc = readlink(basename(outName), buf, len);
#	Line 1086  static int writeConfig(struct grubConfig	Line 1632  static int writeConfig(struct grubConfig
1632	}	}
1633
1634	line = cfg->theLines;	line = cfg->theLines;
1635		struct keywordTypes *defaultKw = getKeywordByType(LT_DEFAULT, cfg->cfi);
1636	while (line) {	while (line) {
1637	if (line->type == LT_DEFAULT) {	if (line->type == LT_SET_VARIABLE && defaultKw &&
1638		line->numElements == 3 &&
1639		!strcmp(line->elements[1].item, defaultKw->key) &&
1640		!is_special_grub2_variable(line->elements[2].item)) {
1641		writeDefault(out, line->indent, line->elements[0].indent, cfg);
1642		needs &= ~MAIN_DEFAULT;
1643		} else if (line->type == LT_DEFAULT) {
1644	writeDefault(out, line->indent, line->elements[0].indent, cfg);	writeDefault(out, line->indent, line->elements[0].indent, cfg);
1645	needs &= ~MAIN_DEFAULT;	needs &= ~MAIN_DEFAULT;
1646	} else if (line->type == LT_FALLBACK) {	} else if (line->type == LT_FALLBACK) {
#	Line 1155  static int numEntries(struct grubConfig	Line 1708  static int numEntries(struct grubConfig
1708	return i;	return i;
1709	}	}
1710
1711		static char *findDiskForRoot()
1712		{
1713		int fd;
1714		char buf[65536];
1715		char *devname;
1716		char *chptr;
1717		int rc;
1718
1719		if ((fd = open(_PATH_MOUNTED, O_RDONLY)) < 0) {
1720		fprintf(stderr, "grubby: failed to open %s: %s\n",
1721		_PATH_MOUNTED, strerror(errno));
1722		return NULL;
1723		}
1724
1725		rc = read(fd, buf, sizeof(buf) - 1);
1726		if (rc <= 0) {
1727		fprintf(stderr, "grubby: failed to read %s: %s\n",
1728		_PATH_MOUNTED, strerror(errno));
1729		close(fd);
1730		return NULL;
1731		}
1732		close(fd);
1733		buf[rc] = '\0';
1734		chptr = buf;
1735
1736		char *foundanswer = NULL;
1737
1738		while (chptr && chptr != buf+rc) {
1739		devname = chptr;
1740
1741		/*
1742		* The first column of a mtab entry is the device, but if the entry is a
1743		* special device it won't start with /, so move on to the next line.
1744		*/
1745		if (*devname != '/') {
1746		chptr = strchr(chptr, '\n');
1747		if (chptr)
1748		chptr++;
1749		continue;
1750		}
1751
1752		/* Seek to the next space */
1753		chptr = strchr(chptr, ' ');
1754		if (!chptr) {
1755		fprintf(stderr, "grubby: error parsing %s: %s\n",
1756		_PATH_MOUNTED, strerror(errno));
1757		return NULL;
1758		}
1759
1760		/*
1761		* The second column of a mtab entry is the mount point, we are looking
1762		* for '/' obviously.
1763		*/
1764		if (*(++chptr) == '/' && *(++chptr) == ' ') {
1765		/* remember the last / entry in mtab */
1766		foundanswer = devname;
1767		}
1768
1769		/* Next line */
1770		chptr = strchr(chptr, '\n');
1771		if (chptr)
1772		chptr++;
1773		}
1774
1775		/* Return the last / entry found */
1776		if (foundanswer) {
1777		chptr = strchr(foundanswer, ' ');
1778		*chptr = '\0';
1779		return strdup(foundanswer);
1780		}
1781
1782		return NULL;
1783		}
1784
1785		void printEntry(struct singleEntry * entry, FILE *f) {
1786		int i;
1787		struct singleLine * line;
1788
1789		for (line = entry->lines; line; line = line->next) {
1790		log_message(f, "DBG: %s", line->indent);
1791		for (i = 0; i < line->numElements; i++) {
1792		/* Need to handle this, because we strip the quotes from
1793		* menuentry when read it. */
1794		if (line->type == LT_MENUENTRY && i == 1) {
1795		if(!isquote(*line->elements[i].item))
1796		log_message(f, "\'%s\'", line->elements[i].item);
1797		else
1798		log_message(f, "%s", line->elements[i].item);
1799		log_message(f, "%s", line->elements[i].indent);
1800
1801		continue;
1802		}
1803
1804		log_message(f, "%s%s",
1805		line->elements[i].item, line->elements[i].indent);
1806		}
1807		log_message(f, "\n");
1808		}
1809		}
1810
1811		void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1812		{
1813		static int once;
1814		va_list argp, argq;
1815
1816		va_start(argp, fmt);
1817
1818		va_copy(argq, argp);
1819		if (!once) {
1820		log_time(NULL);
1821		log_message(NULL, "command line: %s\n", saved_command_line);
1822		}
1823		log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1824		log_vmessage(NULL, fmt, argq);
1825
1826		printEntry(entry, NULL);
1827		va_end(argq);
1828
1829		if (!debug) {
1830		once = 1;
1831		va_end(argp);
1832		return;
1833		}
1834
1835		if (okay) {
1836		va_end(argp);
1837		return;
1838		}
1839
1840		if (!once)
1841		log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1842		once = 1;
1843		fprintf(stderr, "DBG: Image entry failed: ");
1844		vfprintf(stderr, fmt, argp);
1845		printEntry(entry, stderr);
1846		va_end(argp);
1847		}
1848
1849		#define beginswith(s, c) ((s) && (s)[0] == (c))
1850
1851		static int endswith(const char *s, char c)
1852		{
1853		int slen;
1854
1855		if (!s || !s[0])
1856		return 0;
1857		slen = strlen(s) - 1;
1858
1859		return s[slen] == c;
1860		}
1861
1862	int suitableImage(struct singleEntry * entry, const char * bootPrefix,	int suitableImage(struct singleEntry * entry, const char * bootPrefix,
1863	int skipRemoved, int flags) {	int skipRemoved, int flags) {
1864	struct singleLine * line;	struct singleLine * line;
1865	char * fullName;	char * fullName;
1866	int i;	int i;
	struct stat sb, sb2;
1867	char * dev;	char * dev;
1868	char * rootspec;	char * rootspec;
1869		char * rootdev;
1870
1871	if (skipRemoved && entry->skip) return 0;	if (skipRemoved && entry->skip) {
1872		notSuitablePrintf(entry, 0, "marked to skip\n");
1873		return 0;
1874		}
1875
1876	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1877	if (!line || line->numElements < 2) return 0;	if (!line) {
1878		notSuitablePrintf(entry, 0, "no line found\n");
1879		return 0;
1880		}
1881		if (line->numElements < 2) {
1882		notSuitablePrintf(entry, 0, "line has only %d elements\n",
1883		line->numElements);
1884		return 0;
1885		}
1886
1887	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	if (flags & GRUBBY_BADIMAGE_OKAY) {
1888		notSuitablePrintf(entry, 1, "\n");
1889		return 1;
1890		}
1891
1892	fullName = alloca(strlen(bootPrefix) +	fullName = alloca(strlen(bootPrefix) +
1893	strlen(line->elements[1].item) + 1);	strlen(line->elements[1].item) + 1);
1894	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
1895	sprintf(fullName, "%s%s", bootPrefix,	int rootspec_offset = rootspec ? strlen(rootspec) : 0;
1896	line->elements[1].item + (rootspec ? strlen(rootspec) : 0));	int hasslash = endswith(bootPrefix, '/') ||
1897	if (access(fullName, R_OK)) return 0;	beginswith(line->elements[1].item + rootspec_offset, '/');
1898		sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1899		line->elements[1].item + rootspec_offset);
1900		if (access(fullName, R_OK)) {
1901		notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1902		return 0;
1903		}
1904	for (i = 2; i < line->numElements; i++)	for (i = 2; i < line->numElements; i++)
1905	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1906	if (i < line->numElements) {	if (i < line->numElements) {
#	Line 1195  int suitableImage(struct singleEntry * e	Line 1918  int suitableImage(struct singleEntry * e
1918	line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);
1919
1920	/* failed to find one */	/* failed to find one */
1921	if (!line) return 0;	if (!line) {
1922		notSuitablePrintf(entry, 0, "no line found\n");
1923		return 0;
1924		}
1925
1926	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
1927	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1928	if (i < line->numElements)	if (i < line->numElements)
1929	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1930	else {	else {
1931		notSuitablePrintf(entry, 0, "no root= entry found\n");
1932	/* it failed too...  can't find root= */	/* it failed too...  can't find root= */
1933	return 0;	return 0;
1934	}	}
#	Line 1209  int suitableImage(struct singleEntry * e	Line 1936  int suitableImage(struct singleEntry * e
1936	}	}
1937
1938	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1939	if (!dev)	if (!getpathbyspec(dev)) {
1940		notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1941	return 0;	return 0;
1942		} else
1943		dev = getpathbyspec(dev);
1944
1945	i = stat(dev, &sb);	rootdev = findDiskForRoot();
1946	if (i)	if (!rootdev) {
1947		notSuitablePrintf(entry, 0, "can't find root device\n");
1948	return 0;	return 0;
1949		}
1950
1951	stat("/", &sb2);	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1952		notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1953		getuuidbydev(rootdev), getuuidbydev(dev));
1954		free(rootdev);
1955		return 0;
1956		}
1957
1958	if (sb.st_rdev != sb2.st_dev)	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1959		notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1960		getuuidbydev(rootdev), getuuidbydev(dev));
1961		free(rootdev);
1962	return 0;	return 0;
1963		}
1964
1965		free(rootdev);
1966		notSuitablePrintf(entry, 1, "\n");
1967
1968	return 1;	return 1;
1969	}	}
#	Line 1253  struct singleEntry * findEntryByPath(str	Line 1997  struct singleEntry * findEntryByPath(str
1997	}	}
1998
1999	indexVars[i + 1] = -1;	indexVars[i + 1] = -1;
2000
2001	i = 0;	i = 0;
2002	if (index) {	if (index) {
2003	while (i < *index) i++;	while (i < *index) {
2004	if (indexVars[i] == -1) return NULL;	i++;
2005		if (indexVars[i] == -1) return NULL;
2006		}
2007	}	}
2008
2009	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
2010	if (!entry) return NULL;	if (!entry) return NULL;
2011
2012	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2013	if (!line) return NULL;	if (!line) return NULL;
2014
2015	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1301  struct singleEntry * findEntryByPath(str	Line 2047  struct singleEntry * findEntryByPath(str
2047
2048	if (!strncmp(kernel, "TITLE=", 6)) {	if (!strncmp(kernel, "TITLE=", 6)) {
2049	prefix = "";	prefix = "";
2050	checkType = LT_TITLE;	checkType = LT_TITLE|LT_MENUENTRY;
2051	kernel += 6;	kernel += 6;
2052	}	}
2053
#	Line 1312  struct singleEntry * findEntryByPath(str	Line 2058  struct singleEntry * findEntryByPath(str
2058
2059	/* check all the lines matching checkType */	/* check all the lines matching checkType */
2060	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
2061	line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?	enum lineType_e ct = checkType;
2062	LT_KERNEL|LT_MBMODULE|LT_HYPER :	if (entry->multiboot && checkType == LT_KERNEL)
2063	checkType, line);	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2064	if (!line) break;  /* not found in this entry */	else if (checkType & LT_KERNEL)
2065		ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2066		line = getLineByType(ct, line);
2067		if (!line)
2068		break;  /* not found in this entry */
2069
2070	if (line && line->numElements >= 2) {	if (line && line->type != LT_MENUENTRY &&
2071		line->numElements >= 2) {
2072	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
2073	if (!strcmp(line->elements[1].item +	if (!strcmp(line->elements[1].item +
2074	((rootspec != NULL) ? strlen(rootspec) : 0),	((rootspec != NULL) ? strlen(rootspec) : 0),
2075	kernel + strlen(prefix)))	kernel + strlen(prefix)))
2076	break;	break;
2077	}	}
2078		if(line->type == LT_MENUENTRY &&
2079		!strcmp(line->elements[1].item, kernel))
2080		break;
2081	}	}
2082
2083	/* make sure this entry has a kernel identifier; this skips	/* make sure this entry has a kernel identifier; this skips
2084	* non-Linux boot entries (could find netbsd etc, though, which is	* non-Linux boot entries (could find netbsd etc, though, which is
2085	* unfortunate)	* unfortunate)
2086	*/	*/
2087	if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2088	break; /* found 'im! */	break; /* found 'im! */
2089	}	}
2090
#	Line 1340  struct singleEntry * findEntryByPath(str	Line 2094  struct singleEntry * findEntryByPath(str
2094	return entry;	return entry;
2095	}	}
2096
2097		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2098		int * index) {
2099		struct singleEntry * entry;
2100		struct singleLine * line;
2101		int i;
2102		char * newtitle;
2103
2104		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2105		if (index && i < *index)
2106		continue;
2107		line = getLineByType(LT_TITLE, entry->lines);
2108		if (!line)
2109		line = getLineByType(LT_MENUENTRY, entry->lines);
2110		if (!line)
2111		continue;
2112		newtitle = grub2ExtractTitle(line);
2113		if (!newtitle)
2114		continue;
2115		if (!strcmp(title, newtitle))
2116		break;
2117		}
2118
2119		if (!entry)
2120		return NULL;
2121
2122		if (index)
2123		*index = i;
2124		return entry;
2125		}
2126
2127	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2128	struct singleEntry * entry;	struct singleEntry * entry;
2129
#	Line 1362  struct singleEntry * findTemplate(struct	Line 2146  struct singleEntry * findTemplate(struct
2146	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2147	int index;	int index;
2148
2149	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2150		if (cfg->cfi->getEnv) {
2151		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2152		if (defTitle) {
2153		int index = 0;
2154		if (isnumber(defTitle)) {
2155		index = atoi(defTitle);
2156		entry = findEntryByIndex(cfg, index);
2157		} else {
2158		entry = findEntryByTitle(cfg, defTitle, &index);
2159		}
2160		if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2161		cfg->defaultImage = index;
2162		if (indexPtr)
2163		*indexPtr = index;
2164		return entry;
2165		}
2166		}
2167		}
2168		} else if (cfg->defaultImage > -1) {
2169	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2170	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2171	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1415  void markRemovedImage(struct grubConfig	Line 2218  void markRemovedImage(struct grubConfig
2218	const char * prefix) {	const char * prefix) {
2219	struct singleEntry * entry;	struct singleEntry * entry;
2220
2221	if (!image) return;	if (!image)
2222		return;
2223
2224		/* check and see if we're removing the default image */
2225		if (isdigit(*image)) {
2226		entry = findEntryByPath(cfg, image, prefix, NULL);
2227		if(entry)
2228		entry->skip = 1;
2229		return;
2230		}
2231
2232	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2233	entry->skip = 1;	entry->skip = 1;
#	Line 1423  void markRemovedImage(struct grubConfig	Line 2235  void markRemovedImage(struct grubConfig
2235
2236	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2237	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2238	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2239	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2240	int i, j;	int i, j;
2241
2242	if (newIsDefault) {	if (newIsDefault) {
2243	config->defaultImage = 0;	config->defaultImage = 0;
2244	return;	return;
2245		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2246		if (findEntryByIndex(config, index))
2247		config->defaultImage = index;
2248		else
2249		config->defaultImage = -1;
2250		return;
2251	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2252	i = 0;	i = 0;
2253	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1442  void setDefaultImage(struct grubConfig *	Line 2260  void setDefaultImage(struct grubConfig *
2260
2261	/* 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
2262	changes */	changes */
2263	if (config->defaultImage == DEFAULT_SAVED)	if ((config->defaultImage == DEFAULT_SAVED) ||
2264		(config->defaultImage == DEFAULT_SAVED_GRUB2))
2265	/* default is set to saved, we don't want to change it */	/* default is set to saved, we don't want to change it */
2266	return;	return;
2267
#	Line 1500  void displayEntry(struct singleEntry * e	Line 2319  void displayEntry(struct singleEntry * e
2319	struct singleLine * line;	struct singleLine * line;
2320	char * root = NULL;	char * root = NULL;
2321	int i;	int i;
2322		int j;
2323
2324		printf("index=%d\n", index);
2325
2326		line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2327		if (!line) {
2328		printf("non linux entry\n");
2329		return;
2330		}
2331
2332		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2333		printf("kernel=%s\n", line->elements[1].item);
2334		else
2335		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2336
2337		if (line->numElements >= 3) {
2338		printf("args=\"");
2339		i = 2;
2340		while (i < line->numElements) {
2341		if (!strncmp(line->elements[i].item, "root=", 5)) {
2342		root = line->elements[i].item + 5;
2343		} else {
2344		printf("%s%s", line->elements[i].item,
2345		line->elements[i].indent);
2346		}
2347
2348		i++;
2349		}
2350		printf("\"\n");
2351		} else {
2352		line = getLineByType(LT_KERNELARGS, entry->lines);
2353		if (line) {
2354		char * s;
2355
2356		printf("args=\"");
2357		i = 1;
2358		while (i < line->numElements) {
2359		if (!strncmp(line->elements[i].item, "root=", 5)) {
2360		root = line->elements[i].item + 5;
2361		} else {
2362		s = line->elements[i].item;
2363
2364		printf("%s%s", s, line->elements[i].indent);
2365		}
2366
2367		i++;
2368		}
2369
2370		s = line->elements[i - 1].indent;
2371		printf("\"\n");
2372		}
2373		}
2374
2375		if (!root) {
2376		line = getLineByType(LT_ROOT, entry->lines);
2377		if (line && line->numElements >= 2)
2378		root=line->elements[1].item;
2379		}
2380
2381		if (root) {
2382		char * s = alloca(strlen(root) + 1);
2383
2384		strcpy(s, root);
2385		if (s[strlen(s) - 1] == '"')
2386		s[strlen(s) - 1] = '\0';
2387		/* make sure the root doesn't have a trailing " */
2388		printf("root=%s\n", s);
2389		}
2390
2391		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2392
2393		if (line && line->numElements >= 2) {
2394		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2395		printf("initrd=");
2396		else
2397		printf("initrd=%s", prefix);
2398
2399		for (i = 1; i < line->numElements; i++)
2400		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2401		printf("\n");
2402		}
2403
2404		line = getLineByType(LT_TITLE, entry->lines);
2405		if (line) {
2406		printf("title=%s\n", line->elements[1].item);
2407		} else {
2408		char * title;
2409		line = getLineByType(LT_MENUENTRY, entry->lines);
2410		if (line) {
2411		title = grub2ExtractTitle(line);
2412		if (title)
2413		printf("title=%s\n", title);
2414		}
2415		}
2416
2417		for (j = 0, line = entry->lines; line; line = line->next) {
2418		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2419		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2420		printf("mbmodule%d=", j);
2421		else
2422		printf("mbmodule%d=%s", j, prefix);
2423
2424		for (i = 1; i < line->numElements; i++)
2425		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2426		printf("\n");
2427		j++;
2428		}
2429		}
2430		}
2431
2432		int isSuseSystem(void) {
2433		const char * path;
2434		const static char default_path[] = "/etc/SuSE-release";
2435
2436		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2437		path = default_path;
2438
2439		if (!access(path, R_OK))
2440		return 1;
2441		return 0;
2442		}
2443
2444		int isSuseGrubConf(const char * path) {
2445		FILE * grubConf;
2446		char * line = NULL;
2447		size_t len = 0, res = 0;
2448
2449		grubConf = fopen(path, "r");
2450		if (!grubConf) {
2451		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2452		return 0;
2453		}
2454
2455		while ((res = getline(&line, &len, grubConf)) != -1) {
2456		if (!strncmp(line, "setup", 5)) {
2457		fclose(grubConf);
2458		free(line);
2459		return 1;
2460		}
2461		}
2462
2463		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2464		path);
2465
2466		fclose(grubConf);
2467		free(line);
2468		return 0;
2469		}
2470
2471		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2472		FILE * grubConf;
2473		char * line = NULL;
2474		size_t res = 0, len = 0;
2475
2476		if (!path) return 1;
2477		if (!lbaPtr) return 1;
2478
2479		grubConf = fopen(path, "r");
2480		if (!grubConf) return 1;
2481
2482		while ((res = getline(&line, &len, grubConf)) != -1) {
2483		if (line[res - 1] == '\n')
2484		line[res - 1] = '\0';
2485		else if (len > res)
2486		line[res] = '\0';
2487		else {
2488		line = realloc(line, res + 1);
2489		line[res] = '\0';
2490		}
2491
2492		if (!strncmp(line, "setup", 5)) {
2493		if (strstr(line, "--force-lba")) {
2494		*lbaPtr = 1;
2495		} else {
2496		*lbaPtr = 0;
2497		}
2498		dbgPrintf("lba: %i\n", *lbaPtr);
2499		break;
2500		}
2501		}
2502
2503		free(line);
2504		fclose(grubConf);
2505		return 0;
2506		}
2507
2508		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2509		FILE * grubConf;
2510		char * line = NULL;
2511		size_t res = 0, len = 0;
2512		char * lastParamPtr = NULL;
2513		char * secLastParamPtr = NULL;
2514		char installDeviceNumber = '\0';
2515		char * bounds = NULL;
2516
2517		if (!path) return 1;
2518		if (!devicePtr) return 1;
2519
2520		grubConf = fopen(path, "r");
2521		if (!grubConf) return 1;
2522
2523		while ((res = getline(&line, &len, grubConf)) != -1) {
2524		if (strncmp(line, "setup", 5))
2525		continue;
2526
2527		if (line[res - 1] == '\n')
2528		line[res - 1] = '\0';
2529		else if (len > res)
2530		line[res] = '\0';
2531		else {
2532		line = realloc(line, res + 1);
2533		line[res] = '\0';
2534		}
2535
2536		lastParamPtr = bounds = line + res;
2537
2538		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2539		while (!isspace(*lastParamPtr))
2540		lastParamPtr--;
2541		lastParamPtr++;
2542
2543		secLastParamPtr = lastParamPtr - 2;
2544		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2545
2546		if (lastParamPtr + 3 > bounds) {
2547		dbgPrintf("lastParamPtr going over boundary");
2548		fclose(grubConf);
2549		free(line);
2550		return 1;
2551		}
2552		if (!strncmp(lastParamPtr, "(hd", 3))
2553		lastParamPtr += 3;
2554		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2555
2556		/*
2557		* Second last parameter will decide wether last parameter is
2558		* an IMAGE_DEVICE or INSTALL_DEVICE
2559		*/
2560		while (!isspace(*secLastParamPtr))
2561		secLastParamPtr--;
2562		secLastParamPtr++;
2563
2564		if (secLastParamPtr + 3 > bounds) {
2565		dbgPrintf("secLastParamPtr going over boundary");
2566		fclose(grubConf);
2567		free(line);
2568		return 1;
2569		}
2570		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2571		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2572		secLastParamPtr += 3;
2573		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2574		installDeviceNumber = *secLastParamPtr;
2575		} else {
2576		installDeviceNumber = *lastParamPtr;
2577		}
2578
2579		*devicePtr = malloc(6);
2580		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2581		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2582		fclose(grubConf);
2583		free(line);
2584		return 0;
2585		}
2586
2587		free(line);
2588		fclose(grubConf);
2589		return 1;
2590		}
2591
2592		int grubGetBootFromDeviceMap(const char * device,
2593		char ** bootPtr) {
2594		FILE * deviceMap;
2595		char * line = NULL;
2596		size_t res = 0, len = 0;
2597		char * devicePtr;
2598		char * bounds = NULL;
2599		const char * path;
2600		const static char default_path[] = "/boot/grub/device.map";
2601
2602		if (!device) return 1;
2603		if (!bootPtr) return 1;
2604
2605		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2606		path = default_path;
2607
2608		dbgPrintf("opening grub device.map file from: %s\n", path);
2609		deviceMap = fopen(path, "r");
2610		if (!deviceMap)
2611		return 1;
2612
2613	printf("index=%d\n", index);	while ((res = getline(&line, &len, deviceMap)) != -1) {
2614		if (!strncmp(line, "#", 1))
2615		continue;
2616
2617	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	if (line[res - 1] == '\n')
2618	if (!line) {	line[res - 1] = '\0';
2619	printf("non linux entry\n");	else if (len > res)
2620	return;	line[res] = '\0';
2621		else {
2622		line = realloc(line, res + 1);
2623		line[res] = '\0';
2624		}
2625
2626		devicePtr = line;
2627		bounds = line + res;
2628
2629		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2630		devicePtr++;
2631		dbgPrintf("device: %s\n", devicePtr);
2632
2633		if (!strncmp(devicePtr, device, strlen(device))) {
2634		devicePtr += strlen(device);
2635		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2636		devicePtr++;
2637
2638		*bootPtr = strdup(devicePtr);
2639		break;
2640		}
2641	}	}
2642
2643	printf("kernel=%s\n", line->elements[1].item);	free(line);
2644		fclose(deviceMap);
2645		return 0;
2646		}
2647
2648	if (line->numElements >= 3) {	int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2649	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);
	}
2650
2651	i++;	if (suseGrubConfGetInstallDevice(path, &grubDevice))
2652	}	dbgPrintf("error looking for grub installation device\n");
2653	printf("\"\n");	else
2654	} else {	dbgPrintf("grubby installation device: %s\n", grubDevice);
	line = getLineByType(LT_KERNELARGS, entry->lines);
	if (line) {
	char * s;
2655
2656	printf("args=\"");	if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2657	i = 1;	dbgPrintf("error looking for grub boot device\n");
2658	while (i < line->numElements) {	else
2659	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;
2660
2661	printf("%s%s", s, line->elements[i].indent);	free(grubDevice);
2662	}	return 0;
2663		}
2664
2665	i++;	int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2666	}	/*
2667		* This SuSE grub configuration file at this location is not your average
2668		* grub configuration file, but instead the grub commands used to setup
2669		* grub on that system.
2670		*/
2671		const char * path;
2672		const static char default_path[] = "/etc/grub.conf";
2673
2674	s = line->elements[i - 1].indent;	if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2675	printf("\"\n");	path = default_path;
	}
	}
2676
2677	if (!root) {	if (!isSuseGrubConf(path)) return 1;
	line = getLineByType(LT_ROOT, entry->lines);
	if (line && line->numElements >= 2)
	root=line->elements[1].item;
	}
2678
2679	if (root) {	if (lbaPtr) {
2680	char * s = alloca(strlen(root) + 1);	*lbaPtr = 0;
2681		if (suseGrubConfGetLba(path, lbaPtr))
2682	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);
2683	}	}
2684
2685	line = getLineByType(LT_INITRD, entry->lines);	if (bootPtr) {
2686		*bootPtr = NULL;
2687	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");
2688	}	}
2689
2690		return 0;
2691	}	}
2692
2693	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
#	Line 1623  int parseSysconfigGrub(int * lbaPtr, cha	Line 2738  int parseSysconfigGrub(int * lbaPtr, cha
2738	}	}
2739
2740	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2741	char * boot;	char * boot = NULL;
2742	int lba;	int lba;
2743
2744	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2745	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2746	if (boot) printf("boot=%s\n", boot);	free(boot);
2747		return;
2748		}
2749		} else {
2750		if (parseSysconfigGrub(&lba, &boot)) {
2751		free(boot);
2752		return;
2753		}
2754		}
2755
2756		if (lba) printf("lba\n");
2757		if (boot) {
2758		printf("boot=%s\n", boot);
2759		free(boot);
2760	}	}
2761	}	}
2762
#	Line 1677  struct singleLine * addLineTmpl(struct s	Line 2805  struct singleLine * addLineTmpl(struct s
2805	{	{
2806	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2807
2808		if (isEfi && cfi == &grub2ConfigType) {
2809		enum lineType_e old = newLine->type;
2810		newLine->type = preferredLineType(newLine->type, cfi);
2811		if (old != newLine->type)
2812		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2813		}
2814
2815	if (val) {	if (val) {
2816	/* override the inherited value with our own.	/* override the inherited value with our own.
2817	* This is a little weak because it only applies to elements[1]	* This is a little weak because it only applies to elements[1]
#	Line 1686  struct singleLine * addLineTmpl(struct s	Line 2821  struct singleLine * addLineTmpl(struct s
2821	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2822
2823	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2824	if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD)) {	if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI|LT_KERNEL_16|LT_INITRD_16)) {
2825	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2826	if (rootspec != NULL) {	if (rootspec != NULL) {
2827	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 1723  struct singleLine *  addLine(struct sing	Line 2858  struct singleLine *  addLine(struct sing
2858	/* NB: This function shouldn't allocate items on the heap, rather on the	/* NB: This function shouldn't allocate items on the heap, rather on the
2859	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2860	*/	*/
2861	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2862	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2863	tmpl.type = type;	tmpl.type = type;
#	Line 1733  struct singleLine *  addLine(struct sing	Line 2867  struct singleLine *  addLine(struct sing
2867	sprintf(tmpl.elements[0].item, "[%s]", val);	sprintf(tmpl.elements[0].item, "[%s]", val);
2868	tmpl.elements[0].indent = "";	tmpl.elements[0].indent = "";
2869	val = NULL;	val = NULL;
2870		} else if (type == LT_MENUENTRY) {
2871		char *lineend = "--class gnu-linux --class gnu --class os {";
2872		if (!val) {
2873		fprintf(stderr, "Line type LT_MENUENTRY requires a value\n");
2874		abort();
2875		}
2876		kw = getKeywordByType(type, cfi);
2877		if (!kw) {
2878		fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
2879		abort();
2880		}
2881		tmpl.indent = "";
2882		tmpl.type = type;
2883		tmpl.numElements = 3;
2884		tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
2885		tmpl.elements[0].item = kw->key;
2886		tmpl.elements[0].indent = alloca(2);
2887		sprintf(tmpl.elements[0].indent, "%c", kw->nextChar);
2888		tmpl.elements[1].item = (char *)val;
2889		tmpl.elements[1].indent = alloca(2);
2890		sprintf(tmpl.elements[1].indent, "%c", kw->nextChar);
2891		tmpl.elements[2].item = alloca(strlen(lineend)+1);
2892		strcpy(tmpl.elements[2].item, lineend);
2893		tmpl.elements[2].indent = "";
2894	} else {	} else {
2895	kw = getKeywordByType(type, cfi);	kw = getKeywordByType(type, cfi);
2896	if (!kw) abort();	if (!kw) {
2897		fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
2898		abort();
2899		}
2900	tmpl.type = type;	tmpl.type = type;
2901	tmpl.numElements = val ? 2 : 1;	tmpl.numElements = val ? 2 : 1;
2902	tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);	tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
#	Line 1759  struct singleLine *  addLine(struct sing	Line 2920  struct singleLine *  addLine(struct sing
2920	if (!line->next && !prev) prev = line;	if (!line->next && !prev) prev = line;
2921	}	}
2922
2923	if (prev == entry->lines)	struct singleLine *menuEntry;
2924	tmpl.indent = defaultIndent ?: "";	menuEntry = getLineByType(LT_MENUENTRY, entry->lines);
2925	else	if (tmpl.type == LT_ENTRY_END) {
2926	tmpl.indent = prev->indent;	if (menuEntry)
2927		tmpl.indent = menuEntry->indent;
2928		else
2929		tmpl.indent = defaultIndent ?: "";
2930		} else if (tmpl.type != LT_MENUENTRY) {
2931		if (menuEntry)
2932		tmpl.indent = "\t";
2933		else if (prev == entry->lines)
2934		tmpl.indent = defaultIndent ?: "";
2935		else
2936		tmpl.indent = prev->indent;
2937		}
2938
2939	return addLineTmpl(entry, &tmpl, prev, val, cfi);	return addLineTmpl(entry, &tmpl, prev, val, cfi);
2940	}	}
#	Line 1789  void removeLine(struct singleEntry * ent	Line 2961  void removeLine(struct singleEntry * ent
2961	free(line);	free(line);
2962	}	}
2963
2964		static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
2965		{
2966		struct singleLine newLine = {
2967		.indent = tmplLine->indent,
2968		.type = tmplLine->type,
2969		.next = tmplLine->next,
2970		};
2971		int firstQuotedItem = -1;
2972		int quoteLen = 0;
2973		int j;
2974		int element = 0;
2975		char *c;
2976
2977		c = malloc(strlen(tmplLine->elements[0].item) + 1);
2978		strcpy(c, tmplLine->elements[0].item);
2979		insertElement(&newLine, c, element++, cfi);
2980		free(c);
2981		c = NULL;
2982
2983		for (j = 1; j < tmplLine->numElements; j++) {
2984		if (firstQuotedItem == -1) {
2985		quoteLen += strlen(tmplLine->elements[j].item);
2986
2987		if (isquote(tmplLine->elements[j].item[0])) {
2988		firstQuotedItem = j;
2989		quoteLen += strlen(tmplLine->elements[j].indent);
2990		} else {
2991		c = malloc(quoteLen + 1);
2992		strcpy(c, tmplLine->elements[j].item);
2993		insertElement(&newLine, c, element++, cfi);
2994		free(c);
2995		quoteLen = 0;
2996		}
2997		} else {
2998		int itemlen = strlen(tmplLine->elements[j].item);
2999		quoteLen += itemlen;
3000		quoteLen += strlen(tmplLine->elements[j].indent);
3001
3002		if (isquote(tmplLine->elements[j].item[itemlen - 1])) {
3003		c = malloc(quoteLen + 1);
3004		c[0] = '\0';
3005		for (int i = firstQuotedItem; i < j+1; i++) {
3006		strcat(c, tmplLine->elements[i].item);
3007		strcat(c, tmplLine->elements[i].indent);
3008		}
3009		insertElement(&newLine, c, element++, cfi);
3010		free(c);
3011
3012		firstQuotedItem = -1;
3013		quoteLen = 0;
3014		}
3015		}
3016		}
3017		while (tmplLine->numElements)
3018		removeElement(tmplLine, 0);
3019		if (tmplLine->elements)
3020		free(tmplLine->elements);
3021
3022		tmplLine->numElements = newLine.numElements;
3023		tmplLine->elements = newLine.elements;
3024		}
3025
3026	static void insertElement(struct singleLine * line,	static void insertElement(struct singleLine * line,
3027	const char * item, int insertHere,	const char * item, int insertHere,
3028	struct configFileInfo * cfi)	struct configFileInfo * cfi)
#	Line 1895  int updateActualImage(struct grubConfig	Line 3129  int updateActualImage(struct grubConfig
3129	const char ** arg;	const char ** arg;
3130	int useKernelArgs, useRoot;	int useKernelArgs, useRoot;
3131	int firstElement;	int firstElement;
3132	int *usedElements, *usedArgs;	int *usedElements;
3133	int doreplace;	int doreplace;
3134
3135	if (!image) return 0;	if (!image) return 0;
#	Line 1930  int updateActualImage(struct grubConfig	Line 3164  int updateActualImage(struct grubConfig
3164	useRoot = (getKeywordByType(LT_ROOT, cfg->cfi)	useRoot = (getKeywordByType(LT_ROOT, cfg->cfi)
3165	&& !multibootArgs);	&& !multibootArgs);
3166
	for (k = 0, arg = newArgs; *arg; arg++, k++) ;
	usedArgs = calloc(k, sizeof(*usedArgs));
3167	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3168
3169	if (multibootArgs && !entry->multiboot)	if (multibootArgs && !entry->multiboot)
#	Line 1960  int updateActualImage(struct grubConfig	Line 3191  int updateActualImage(struct grubConfig
3191	firstElement = 2;	firstElement = 2;
3192
3193	} else {	} else {
3194	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3195	if (!line) {	if (!line) {
3196	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3197	continue;	continue;
#	Line 2008  int updateActualImage(struct grubConfig	Line 3239  int updateActualImage(struct grubConfig
3239	usedElements = calloc(line->numElements, sizeof(*usedElements));	usedElements = calloc(line->numElements, sizeof(*usedElements));
3240
3241	for (k = 0, arg = newArgs; *arg; arg++, k++) {	for (k = 0, arg = newArgs; *arg; arg++, k++) {
	if (usedArgs[k]) continue;
3242
3243	doreplace = 1;	doreplace = 1;
3244	for (i = firstElement; i < line->numElements; i++) {	for (i = firstElement; i < line->numElements; i++) {
#	Line 2023  int updateActualImage(struct grubConfig	Line 3253  int updateActualImage(struct grubConfig
3253	continue;	continue;
3254	if (!argMatch(line->elements[i].item, *arg)) {	if (!argMatch(line->elements[i].item, *arg)) {
3255	usedElements[i]=1;	usedElements[i]=1;
	usedArgs[k]=1;
3256	break;	break;
3257	}	}
3258	}	}
#	Line 2093  int updateActualImage(struct grubConfig	Line 3322  int updateActualImage(struct grubConfig
3322	}	}
3323	}	}
3324
	free(usedArgs);
3325	free(newArgs);	free(newArgs);
3326	free(oldArgs);	free(oldArgs);
3327
#	Line 2119  int updateImage(struct grubConfig * cfg,	Line 3347  int updateImage(struct grubConfig * cfg,
3347	return rc;	return rc;
3348	}	}
3349
3350		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3351		const char * image, const char * prefix, const char * initrd,
3352		const char * title) {
3353		struct singleEntry * entry;
3354		struct singleLine * line, * kernelLine, *endLine = NULL;
3355		int index = 0;
3356
3357		if (!image) return 0;
3358
3359		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3360		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3361		if (!kernelLine) continue;
3362
3363		/* if title is supplied, the entry's title must match it. */
3364		if (title) {
3365		char *linetitle;
3366
3367		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3368		if (!line)
3369		continue;
3370
3371		linetitle = extractTitle(cfg, line);
3372		if (!linetitle)
3373		continue;
3374		if (strcmp(title, linetitle)) {
3375		free(linetitle);
3376		continue;
3377		}
3378		free(linetitle);
3379		}
3380
3381		if (prefix) {
3382		int prefixLen = strlen(prefix);
3383		if (!strncmp(initrd, prefix, prefixLen))
3384		initrd += prefixLen;
3385		}
3386		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3387		if (endLine)
3388		removeLine(entry, endLine);
3389		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3390		kernelLine->indent, initrd);
3391		if (!line)
3392		return 1;
3393		if (endLine) {
3394		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3395		if (!line)
3396		return 1;
3397		}
3398
3399		break;
3400		}
3401
3402		return 0;
3403		}
3404
3405		int updateInitrd(struct grubConfig * cfg, const char * image,
3406		const char * prefix, const char * initrd, const char * title) {
3407		struct singleEntry * entry;
3408		struct singleLine * line, * kernelLine, *endLine = NULL;
3409		int index = 0;
3410
3411		if (!image) return 0;
3412
3413		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3414		kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3415		if (!kernelLine) continue;
3416
3417		/* if title is supplied, the entry's title must match it. */
3418		if (title) {
3419		char *linetitle;
3420
3421		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3422		if (!line)
3423		continue;
3424
3425		linetitle = extractTitle(cfg, line);
3426		if (!linetitle)
3427		continue;
3428		if (strcmp(title, linetitle)) {
3429		free(linetitle);
3430		continue;
3431		}
3432		free(linetitle);
3433		}
3434
3435		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3436		if (line)
3437		removeLine(entry, line);
3438		if (prefix) {
3439		int prefixLen = strlen(prefix);
3440		if (!strncmp(initrd, prefix, prefixLen))
3441		initrd += prefixLen;
3442		}
3443		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3444		if (endLine)
3445		removeLine(entry, endLine);
3446		enum lineType_e lt;
3447		switch(kernelLine->type) {
3448		case LT_KERNEL:
3449		lt = LT_INITRD;
3450		break;
3451		case LT_KERNEL_EFI:
3452		lt = LT_INITRD_EFI;
3453		break;
3454		case LT_KERNEL_16:
3455		lt = LT_INITRD_16;
3456		break;
3457		default:
3458		lt = preferredLineType(LT_INITRD, cfg->cfi);
3459		}
3460		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3461		if (!line)
3462		return 1;
3463		if (endLine) {
3464		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3465		if (!line)
3466		return 1;
3467		}
3468
3469		break;
3470		}
3471
3472		return 0;
3473		}
3474
3475	int checkDeviceBootloader(const char * device, const unsigned char * boot) {	int checkDeviceBootloader(const char * device, const unsigned char * boot) {
3476	int fd;	int fd;
3477	unsigned char bootSect[512];	unsigned char bootSect[512];
#	Line 2142  int checkDeviceBootloader(const char * d	Line 3495  int checkDeviceBootloader(const char * d
3495	if (memcmp(boot, bootSect, 3))	if (memcmp(boot, bootSect, 3))
3496	return 0;	return 0;
3497
3498	if (boot[1] == 0xeb) {	if (boot[1] == JMP_SHORT_OPCODE) {
3499	offset = boot[2] + 2;	offset = boot[2] + 2;
3500	} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {	} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {
3501	offset = (boot[3] << 8) + boot[2] + 2;	offset = (boot[3] << 8) + boot[2] + 2;
3502	} else if (boot[0] == 0xeb) {	} else if (boot[0] == JMP_SHORT_OPCODE) {
3503	offset = boot[1] + 2;	offset = boot[1] + 2;
3504		/*
3505		* it looks like grub, when copying stage1 into the mbr, patches stage1
3506		* right after the JMP location, replacing other instructions such as
3507		* JMPs for NOOPs. So, relax the check a little bit by skipping those
3508		* different bytes.
3509		*/
3510		if ((bootSect[offset + 1] == NOOP_OPCODE)
3511		&& (bootSect[offset + 2] == NOOP_OPCODE)) {
3512		offset = offset + 3;
3513		}
3514	} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {	} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {
3515	offset = (boot[2] << 8) + boot[1] + 2;	offset = (boot[2] << 8) + boot[1] + 2;
3516	} else {	} else {
#	Line 2289  int checkForLilo(struct grubConfig * con	Line 3652  int checkForLilo(struct grubConfig * con
3652	return checkDeviceBootloader(line->elements[1].item, boot);	return checkDeviceBootloader(line->elements[1].item, boot);
3653	}	}
3654
3655		int checkForGrub2(struct grubConfig * config) {
3656		if (!access("/etc/grub.d/", R_OK))
3657		return 2;
3658
3659		return 1;
3660		}
3661
3662	int checkForGrub(struct grubConfig * config) {	int checkForGrub(struct grubConfig * config) {
3663	int fd;	int fd;
3664	unsigned char bootSect[512];	unsigned char bootSect[512];
3665	char * boot;	char * boot;
3666		int onSuse = isSuseSystem();
3667
3668	if (parseSysconfigGrub(NULL, &boot))
3669	return 0;	if (onSuse) {
3670		if (parseSuseGrubConf(NULL, &boot))
3671		return 0;
3672		} else {
3673		if (parseSysconfigGrub(NULL, &boot))
3674		return 0;
3675		}
3676
3677	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3678	if (!boot)	if (!boot)
#	Line 2314  int checkForGrub(struct grubConfig * con	Line 3691  int checkForGrub(struct grubConfig * con
3691	}	}
3692	close(fd);	close(fd);
3693
3694		/* The more elaborate checks do not work on SuSE. The checks done
3695		* seem to be reasonble (at least for now), so just return success
3696		*/
3697		if (onSuse)
3698		return 2;
3699
3700	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3701	}	}
3702
#	Line 2347  int checkForExtLinux(struct grubConfig *	Line 3730  int checkForExtLinux(struct grubConfig *
3730	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3731	}	}
3732
3733		int checkForYaboot(struct grubConfig * config) {
3734		/*
3735		* This is a simplistic check that we consider good enough for own puporses
3736		*
3737		* If we were to properly check if yaboot is *installed* we'd need to:
3738		* 1) get the system boot device (LT_BOOT)
3739		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3740		*    the content on the boot device
3741		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3742		* 4) check again if binary and boot device contents match
3743		*/
3744		if (!access("/etc/yaboot.conf", R_OK))
3745		return 2;
3746
3747		return 1;
3748		}
3749
3750		int checkForElilo(struct grubConfig * config) {
3751		if (!access("/etc/elilo.conf", R_OK))
3752		return 2;
3753
3754		return 1;
3755		}
3756
3757	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3758	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3759
#	Line 2361  static char * getRootSpecifier(char * st	Line 3768  static char * getRootSpecifier(char * st
3768	static char * getInitrdVal(struct grubConfig * config,	static char * getInitrdVal(struct grubConfig * config,
3769	const char * prefix, struct singleLine *tmplLine,	const char * prefix, struct singleLine *tmplLine,
3770	const char * newKernelInitrd,	const char * newKernelInitrd,
3771	char ** extraInitrds, int extraInitrdCount)	const char ** extraInitrds, int extraInitrdCount)
3772	{	{
3773	char *initrdVal, *end;	char *initrdVal, *end;
3774	int i;	int i;
#	Line 2406  static char * getInitrdVal(struct grubCo	Line 3813  static char * getInitrdVal(struct grubCo
3813
3814	int addNewKernel(struct grubConfig * config, struct singleEntry * template,	int addNewKernel(struct grubConfig * config, struct singleEntry * template,
3815	const char * prefix,	const char * prefix,
3816	char * newKernelPath, char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3817	char * newKernelArgs, char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3818	char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3819	char * newMBKernel, char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs,
3820		const char * newDevTreePath) {
3821	struct singleEntry * new;	struct singleEntry * new;
3822	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3823	int needs;	int needs;
#	Line 2450  int addNewKernel(struct grubConfig * con	Line 3858  int addNewKernel(struct grubConfig * con
3858	needs |= NEED_MB;	needs |= NEED_MB;
3859	new->multiboot = 1;	new->multiboot = 1;
3860	}	}
3861		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3862		needs |= NEED_DEVTREE;
3863
3864	if (template) {	if (template) {
3865	for (masterLine = template->lines;	for (masterLine = template->lines;
#	Line 2463  int addNewKernel(struct grubConfig * con	Line 3873  int addNewKernel(struct grubConfig * con
3873	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3874	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3875
3876	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3877	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3878	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3879	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 2541  int addNewKernel(struct grubConfig * con	Line 3950  int addNewKernel(struct grubConfig * con
3950	/* template is multi but new is not,	/* template is multi but new is not,
3951	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3952	*/	*/
3953	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3954	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3955	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3956	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3957		config->cfi)->key);
3958	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3959	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3960		config->cfi);
3961	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3962	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3963	char *initrdVal;	char *initrdVal;
3964	/* template is multi but new is not,	/* template is multi but new is not,
3965	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3966	*/	*/
3967	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3968	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3969	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3970	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3971		config->cfi)->key);
3972	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3973	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3974	free(initrdVal);	free(initrdVal);
3975	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3976	}	}
3977
3978	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3979	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3980	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3981	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 2590  int addNewKernel(struct grubConfig * con	Line 4001  int addNewKernel(struct grubConfig * con
4001	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4002	}	}
4003
4004		} else if (tmplLine->type == LT_MENUENTRY &&
4005		(needs & NEED_TITLE)) {
4006		requote(tmplLine, config->cfi);
4007		char *nkt = malloc(strlen(newKernelTitle)+3);
4008		strcpy(nkt, "'");
4009		strcat(nkt, newKernelTitle);
4010		strcat(nkt, "'");
4011		newLine = addLineTmpl(new, tmplLine, newLine, nkt, config->cfi);
4012		free(nkt);
4013		needs &= ~NEED_TITLE;
4014	} else if (tmplLine->type == LT_TITLE &&	} else if (tmplLine->type == LT_TITLE &&
4015	(needs & NEED_TITLE)) {	(needs & NEED_TITLE)) {
4016	if (tmplLine->numElements >= 2) {	if (tmplLine->numElements >= 2) {
#	Line 2603  int addNewKernel(struct grubConfig * con	Line 4024  int addNewKernel(struct grubConfig * con
4024	tmplLine->indent, newKernelTitle);	tmplLine->indent, newKernelTitle);
4025	needs &= ~NEED_TITLE;	needs &= ~NEED_TITLE;
4026	}	}
4027		} else if (tmplLine->type == LT_ECHO) {
4028		requote(tmplLine, config->cfi);
4029		static const char *prefix = "'Loading ";
4030		if (tmplLine->numElements > 1 &&
4031		strstr(tmplLine->elements[1].item, prefix) &&
4032		masterLine->next &&
4033		iskernel(masterLine->next->type)) {
4034		char *newTitle = malloc(strlen(prefix) +
4035		strlen(newKernelTitle) + 2);
4036
4037		strcpy(newTitle, prefix);
4038		strcat(newTitle, newKernelTitle);
4039		strcat(newTitle, "'");
4040		newLine = addLine(new, config->cfi, LT_ECHO,
4041		tmplLine->indent, newTitle);
4042		free(newTitle);
4043		} else {
4044		/* pass through other lines from the template */
4045		newLine = addLineTmpl(new, tmplLine, newLine, NULL,
4046		config->cfi);
4047		}
4048		} else if (tmplLine->type == LT_DEVTREE &&
4049		tmplLine->numElements == 2 && newDevTreePath) {
4050		newLine = addLineTmpl(new, tmplLine, newLine,
4051		newDevTreePath + strlen(prefix),
4052		config->cfi);
4053		needs &= ~NEED_DEVTREE;
4054		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
4055		const char *ndtp = newDevTreePath;
4056		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
4057		ndtp += strlen(prefix);
4058		newLine = addLine(new, config->cfi, LT_DEVTREE,
4059		config->secondaryIndent,
4060		ndtp);
4061		needs &= ~NEED_DEVTREE;
4062		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
4063	} else {	} else {
4064	/* pass through other lines from the template */	/* pass through other lines from the template */
4065	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
#	Line 2614  int addNewKernel(struct grubConfig * con	Line 4070  int addNewKernel(struct grubConfig * con
4070	/* don't have a template, so start the entry with the	/* don't have a template, so start the entry with the
4071	* appropriate starting line	* appropriate starting line
4072	*/	*/
4073	switch (config->cfi->entrySeparator) {	switch (config->cfi->entryStart) {
4074	case LT_KERNEL:	case LT_KERNEL:
4075		case LT_KERNEL_EFI:
4076		case LT_KERNEL_16:
4077	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
4078	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
4079	} else {	} else {
4080	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
4081		preferredLineType(LT_KERNEL, config->cfi),
4082	config->primaryIndent,	config->primaryIndent,
4083	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4084	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 2633  int addNewKernel(struct grubConfig * con	Line 4092  int addNewKernel(struct grubConfig * con
4092	needs &= ~NEED_MB;	needs &= ~NEED_MB;
4093	break;	break;
4094
4095		case LT_MENUENTRY: {
4096		char *nkt = malloc(strlen(newKernelTitle)+3);
4097		strcpy(nkt, "'");
4098		strcat(nkt, newKernelTitle);
4099		strcat(nkt, "'");
4100		newLine = addLine(new, config->cfi, LT_MENUENTRY,
4101		config->primaryIndent, nkt);
4102		free(nkt);
4103		needs &= ~NEED_TITLE;
4104		needs |= NEED_END;
4105		break;
4106		}
4107	case LT_TITLE:	case LT_TITLE:
4108	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)
4109	char * templabel;	char * templabel;
#	Line 2664  int addNewKernel(struct grubConfig * con	Line 4135  int addNewKernel(struct grubConfig * con
4135	}	}
4136	}	}
4137
4138		struct singleLine *endLine = NULL;
4139		endLine = getLineByType(LT_ENTRY_END, new->lines);
4140		if (endLine) {
4141		removeLine(new, endLine);
4142		needs |= NEED_END;
4143		}
4144
4145	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4146	* weren't present in the template, or in the case of no template,	* weren't present in the template, or in the case of no template,
4147	* all the lines following the entrySeparator.	* all the lines following the entryStart.
4148	*/	*/
4149	if (needs & NEED_TITLE) {	if (needs & NEED_TITLE) {
4150	newLine = addLine(new, config->cfi, LT_TITLE,	newLine = addLine(new, config->cfi, LT_TITLE,
#	Line 2683  int addNewKernel(struct grubConfig * con	Line 4161  int addNewKernel(struct grubConfig * con
4161	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
4162	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4163	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4164	config->cfi)) ?	config->cfi))
4165	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
4166		: preferredLineType(LT_KERNEL, config->cfi),
4167	config->secondaryIndent,	config->secondaryIndent,
4168	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4169	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 2700  int addNewKernel(struct grubConfig * con	Line 4179  int addNewKernel(struct grubConfig * con
4179	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4180	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4181	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4182	config->cfi)) ?	config->cfi))
4183	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
4184		: preferredLineType(LT_INITRD, config->cfi),
4185	config->secondaryIndent,	config->secondaryIndent,
4186	initrdVal);	initrdVal);
4187	free(initrdVal);	free(initrdVal);
4188	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4189	}	}
4190		if (needs & NEED_DEVTREE) {
4191		newLine = addLine(new, config->cfi, LT_DEVTREE,
4192		config->secondaryIndent,
4193		newDevTreePath);
4194		needs &= ~NEED_DEVTREE;
4195		}
4196
4197		/* NEEDS_END must be last on bootloaders that need it... */
4198		if (needs & NEED_END) {
4199		newLine = addLine(new, config->cfi, LT_ENTRY_END,
4200		config->secondaryIndent, NULL);
4201		needs &= ~NEED_END;
4202		}
4203
4204	if (needs) {	if (needs) {
4205	printf(_("grubby: needs=%d, aborting\n"), needs);	printf(_("grubby: needs=%d, aborting\n"), needs);
#	Line 2728  static void traceback(int signum)	Line 4221  static void traceback(int signum)
4221	memset(array, '\0', sizeof (array));	memset(array, '\0', sizeof (array));
4222	size = backtrace(array, 40);	size = backtrace(array, 40);
4223
4224	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",	fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4225	(unsigned long)size);	(unsigned long)size);
4226	backtrace_symbols_fd(array, size, STDERR_FILENO);	backtrace_symbols_fd(array, size, STDERR_FILENO);
4227	exit(1);	exit(1);
#	Line 2736  static void traceback(int signum)	Line 4229  static void traceback(int signum)
4229
4230	int main(int argc, const char ** argv) {	int main(int argc, const char ** argv) {
4231	poptContext optCon;	poptContext optCon;
4232	char * grubConfig = NULL;	const char * grubConfig = NULL;
4233	char * outputFile = NULL;	char * outputFile = NULL;
4234	int arg = 0;	int arg = 0;
4235	int flags = 0;	int flags = 0;
4236	int badImageOkay = 0;	int badImageOkay = 0;
4237		int configureGrub2 = 0;
4238	int configureLilo = 0, configureELilo = 0, configureGrub = 0;	int configureLilo = 0, configureELilo = 0, configureGrub = 0;
4239	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;
4240	int configureExtLinux = 0;	int configureExtLinux = 0;
#	Line 2752  int main(int argc, const char ** argv) {	Line 4246  int main(int argc, const char ** argv) {
4246	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4247	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4248	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4249	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4250	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4251	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4252	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 2762  int main(int argc, const char ** argv) {	Line 4256  int main(int argc, const char ** argv) {
4256	char * removeArgs = NULL;	char * removeArgs = NULL;
4257	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4258	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4259		char * envPath = NULL;
4260	const char * chptr = NULL;	const char * chptr = NULL;
4261	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4262	struct grubConfig * config;	struct grubConfig * config;
4263	struct singleEntry * template = NULL;	struct singleEntry * template = NULL;
4264	int copyDefault = 0, makeDefault = 0;	int copyDefault = 0, makeDefault = 0;
4265	int displayDefault = 0;	int displayDefault = 0;
4266		int displayDefaultIndex = 0;
4267		int displayDefaultTitle = 0;
4268		int defaultIndex = -1;
4269	struct poptOption options[] = {	struct poptOption options[] = {
4270	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4271	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 2785  int main(int argc, const char ** argv) {	Line 4283  int main(int argc, const char ** argv) {
4283	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4284	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4285	_("bootfs") },	_("bootfs") },
4286	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4287	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4288	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4289	#endif	#endif
4290	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4291	_("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 4296  int main(int argc, const char ** argv) {
4296	"the kernel referenced by the default image does not exist, "	"the kernel referenced by the default image does not exist, "
4297	"the first linux entry whose kernel does exist is used as the "	"the first linux entry whose kernel does exist is used as the "
4298	"template"), NULL },	"template"), NULL },
4299		{ "debug", 0, 0, &debug, 0,
4300		_("print debugging information for failures") },
4301	{ "default-kernel", 0, 0, &displayDefault, 0,	{ "default-kernel", 0, 0, &displayDefault, 0,
4302	_("display the path of the default kernel") },	_("display the path of the default kernel") },
4303		{ "default-index", 0, 0, &displayDefaultIndex, 0,
4304		_("display the index of the default kernel") },
4305		{ "default-title", 0, 0, &displayDefaultTitle, 0,
4306		_("display the title of the default kernel") },
4307		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4308		_("device tree file for new stanza"), _("dtb-path") },
4309		{ "devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4310		_("device tree directory for new stanza"), _("dtb-path") },
4311	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4312	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4313		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4314		_("force grub2 stanzas to use efi") },
4315		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4316		_("path for environment data"),
4317		_("path") },
4318	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4319	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4320	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
4321	_("configure grub bootloader") },	_("configure grub bootloader") },
4322		{ "grub2", 0, POPT_ARG_NONE, &configureGrub2, 0,
4323		_("configure grub2 bootloader") },
4324	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,
4325	_("display boot information for specified kernel"),	_("display boot information for specified kernel"),
4326	_("kernel-path") },	_("kernel-path") },
4327	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4328	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4329	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4330	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4331	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4332	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4333	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 2832  int main(int argc, const char ** argv) {	Line 4347  int main(int argc, const char ** argv) {
4347	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4348	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4349	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4350		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4351		_("make the given entry index the default entry"),
4352		_("entry-index") },
4353	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4354	_("configure silo bootloader") },	_("configure silo bootloader") },
4355	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 2853  int main(int argc, const char ** argv) {	Line 4371  int main(int argc, const char ** argv) {
4371
4372	signal(SIGSEGV, traceback);	signal(SIGSEGV, traceback);
4373
4374		int i = 0;
4375		for (int j = 1; j < argc; j++)
4376		i += strlen(argv[j]) + 1;
4377		saved_command_line = malloc(i);
4378		if (!saved_command_line) {
4379		fprintf(stderr, "grubby: %m\n");
4380		exit(1);
4381		}
4382		saved_command_line[0] = '\0';
4383		for (int j = 1; j < argc; j++) {
4384		strcat(saved_command_line, argv[j]);
4385		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4386		}
4387
4388	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4389	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4390
#	Line 2885  int main(int argc, const char ** argv) {	Line 4417  int main(int argc, const char ** argv) {
4417	return 1;	return 1;
4418	}	}
4419
4420	if ((configureLilo + configureGrub + configureELilo +	if ((configureLilo + configureGrub2 + configureGrub + configureELilo +
4421	configureYaboot + configureSilo + configureZipl +	configureYaboot + configureSilo + configureZipl +
4422	configureExtLinux ) > 1) {	configureExtLinux ) > 1) {
4423	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 4426  int main(int argc, const char ** argv) {
4426	fprintf(stderr,	fprintf(stderr,
4427	_("grubby: cannot specify config file with --bootloader-probe\n"));	_("grubby: cannot specify config file with --bootloader-probe\n"));
4428	return 1;	return 1;
4429		} else if (configureGrub2) {
4430		cfi = &grub2ConfigType;
4431		if (envPath)
4432		cfi->envFile = envPath;
4433	} else if (configureLilo) {	} else if (configureLilo) {
4434	cfi = &liloConfigType;	cfi = &liloConfigType;
4435	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 2912  int main(int argc, const char ** argv) {	Line 4448  int main(int argc, const char ** argv) {
4448	}	}
4449
4450	if (!cfi) {	if (!cfi) {
4451		if (grub2FindConfig(&grub2ConfigType)) {
4452		cfi = &grub2ConfigType;
4453		if (envPath)
4454		cfi->envFile = envPath;
4455		} else
4456	#ifdef __ia64__	#ifdef __ia64__
4457	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4458	#elif __powerpc__	#elif __powerpc__
4459	cfi = &yabootConfigType;	cfi = &yabootConfigType;
4460	#elif __sparc__	#elif __sparc__
4461	cfi = &siloConfigType;	cfi = &siloConfigType;
4462	#elif __s390__	#elif __s390__
4463	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4464	#elif __s390x__	#elif __s390x__
4465	cfi = &ziplConfigtype;	cfi = &ziplConfigtype;
4466	#else	#else
4467	cfi = &grubConfigType;	cfi = &grubConfigType;
4468	#endif	#endif
4469	}	}
4470
4471	if (!grubConfig)	if (!grubConfig) {
4472	grubConfig = cfi->defaultConfig;	if (cfi->findConfig)
4473		grubConfig = cfi->findConfig(cfi);
4474		if (!grubConfig)
4475		grubConfig = cfi->defaultConfig;
4476		}
4477
4478	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4479	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4480	defaultKernel)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4481		(defaultIndex >= 0))) {
4482	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4483	"specified option"));	"specified option"));
4484	return 1;	return 1;
4485	}	}
4486
4487	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4488	removeKernelPath)) {	removeKernelPath)) {
4489	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4490	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 2948  int main(int argc, const char ** argv) {	Line 4494  int main(int argc, const char ** argv) {
4494	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4495	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4496	return 1;	return 1;
4497	} else if (!newKernelPath && (newKernelTitle  || newKernelInitrd ||	} else if (!newKernelPath && (copyDefault ||
4498	newKernelInitrd || copyDefault     ||	(newKernelInitrd && !updateKernelPath)||
4499	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4500	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
4501	return 1;	return 1;
#	Line 2974  int main(int argc, const char ** argv) {	Line 4520  int main(int argc, const char ** argv) {
4520	makeDefault = 1;	makeDefault = 1;
4521	defaultKernel = NULL;	defaultKernel = NULL;
4522	}	}
4523		else if (defaultKernel && (defaultIndex >= 0)) {
4524		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4525		"may not be used together\n"));
4526		return 1;
4527		}
4528
4529	if (!strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4530	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
4531	"is used\n"));	"is used\n"));
4532	return 1;	return 1;
4533	}	}
4534
4535	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4536	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4537	&& !removeMBKernel) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4538		&& (defaultIndex == -1)) {
4539	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4540	return 1;	return 1;
4541	}	}
#	Line 3010  int main(int argc, const char ** argv) {	Line 4562  int main(int argc, const char ** argv) {
4562	}	}
4563
4564	if (bootloaderProbe) {	if (bootloaderProbe) {
4565	int lrc = 0, grc = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4566	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4567
4568		const char *grub2config = grub2FindConfig(&grub2ConfigType);
4569		if (grub2config) {
4570		gconfig = readConfig(grub2config, &grub2ConfigType);
4571		if (!gconfig)
4572		gr2c = 1;
4573		else
4574		gr2c = checkForGrub2(gconfig);
4575		}
4576
4577	if (!access(grubConfigType.defaultConfig, F_OK)) {	const char *grubconfig = grubFindConfig(&grubConfigType);
4578	gconfig = readConfig(grubConfigType.defaultConfig, &grubConfigType);	if (!access(grubconfig, F_OK)) {
4579		gconfig = readConfig(grubconfig, &grubConfigType);
4580	if (!gconfig)	if (!gconfig)
4581	grc = 1;	grc = 1;
4582	else	else
#	Line 3029  int main(int argc, const char ** argv) {	Line 4591  int main(int argc, const char ** argv) {
4591	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4592	}	}
4593
4594		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4595		econfig = readConfig(eliloConfigType.defaultConfig,
4596		&eliloConfigType);
4597		if (!econfig)
4598		erc = 1;
4599		else
4600		erc = checkForElilo(econfig);
4601		}
4602
4603	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4604	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4605	if (!lconfig)	if (!lconfig)
4606	erc = 1;	extrc = 1;
4607	else	else
4608	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4609	}	}
4610
4611	if (lrc == 1 || grc == 1) return 1;
4612		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4613		yconfig = readConfig(yabootConfigType.defaultConfig,
4614		&yabootConfigType);
4615		if (!yconfig)
4616		yrc = 1;
4617		else
4618		yrc = checkForYaboot(yconfig);
4619		}
4620
4621		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4622		erc == 1)
4623		return 1;
4624
4625	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4626		if (gr2c == 2) printf("grub2\n");
4627	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4628	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4629		if (yrc == 2) printf("yaboot\n");
4630		if (erc == 2) printf("elilo\n");
4631
4632	return 0;	return 0;
4633	}	}
4634
4635		if (grubConfig == NULL) {
4636		printf("Could not find bootloader configuration file.\n");
4637		exit(1);
4638		}
4639
4640	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4641	if (!config) return 1;	if (!config) return 1;
4642
#	Line 3055  int main(int argc, const char ** argv) {	Line 4646  int main(int argc, const char ** argv) {
4646	char * rootspec;	char * rootspec;
4647
4648	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4649		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4650		cfi->defaultIsSaved)
4651		config->defaultImage = 0;
4652	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4653	if (!entry) return 0;	if (!entry) return 0;
4654	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4655
4656	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4657	if (!line) return 0;	if (!line) return 0;
4658
4659	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3067  int main(int argc, const char ** argv) {	Line 4661  int main(int argc, const char ** argv) {
4661	((rootspec != NULL) ? strlen(rootspec) : 0));	((rootspec != NULL) ? strlen(rootspec) : 0));
4662
4663	return 0;	return 0;
4664
4665		} else if (displayDefaultTitle) {
4666		struct singleLine * line;
4667		struct singleEntry * entry;
4668
4669		if (config->defaultImage == -1) return 0;
4670		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4671		cfi->defaultIsSaved)
4672		config->defaultImage = 0;
4673		entry = findEntryByIndex(config, config->defaultImage);
4674		if (!entry) return 0;
4675
4676		if (!configureGrub2) {
4677		line = getLineByType(LT_TITLE, entry->lines);
4678		if (!line) return 0;
4679		printf("%s\n", line->elements[1].item);
4680
4681		} else {
4682		char * title;
4683
4684		dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
4685		line = getLineByType(LT_MENUENTRY, entry->lines);
4686		if (!line) return 0;
4687		title = grub2ExtractTitle(line);
4688		if (title)
4689		printf("%s\n", title);
4690		}
4691		return 0;
4692
4693		} else if (displayDefaultIndex) {
4694		if (config->defaultImage == -1) return 0;
4695		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4696		cfi->defaultIsSaved)
4697		config->defaultImage = 0;
4698		printf("%i\n", config->defaultImage);
4699		return 0;
4700
4701	} else if (kernelInfo)	} else if (kernelInfo)
4702	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
4703
#	Line 3078  int main(int argc, const char ** argv) {	Line 4709  int main(int argc, const char ** argv) {
4709	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4710	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4711	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4712	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4713	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4714	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4715	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4716		if (updateKernelPath && newKernelInitrd) {
4717		if (newMBKernel) {
4718		if (addMBInitrd(config, newMBKernel, updateKernelPath,
4719		bootPrefix, newKernelInitrd,
4720		newKernelTitle))
4721		return 1;
4722		} else {
4723		if (updateInitrd(config, updateKernelPath, bootPrefix,
4724		newKernelInitrd, newKernelTitle))
4725		return 1;
4726		}
4727		}
4728	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4729	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4730	extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4731	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4732
4733
4734	if (numEntries(config) == 0) {	if (numEntries(config) == 0) {
#	Line 3095  int main(int argc, const char ** argv) {	Line 4738  int main(int argc, const char ** argv) {
4738	}	}
4739
4740	if (!outputFile)	if (!outputFile)
4741	outputFile = grubConfig;	outputFile = (char *)grubConfig;
4742
4743	return writeConfig(config, outputFile, bootPrefix);	return writeConfig(config, outputFile, bootPrefix);
4744	}	}

---

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

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