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

Parent Directory | Revision Log | Patch

	revision 1693 by niro, Fri Feb 17 23:21:08 2012 UTC	revision 2991 by niro, Thu Jun 30 10:34:31 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		int defaultIsSaved;
164		int defaultIsUnquoted;
165	enum lineType_e entryStart;	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	.defaultConfig = "/boot/grub/grub.conf",	.findConfig = grubFindConfig,
217	.keywords = grubKeywords,	.keywords = grubKeywords,
218	.defaultIsIndex = 1,	.defaultIsIndex = 1,
219	.defaultSupportSaved = 1,	.defaultSupportSaved = 1,
#	Line 148  struct configFileInfo grubConfigType = {	Line 222  struct configFileInfo grubConfigType = {
222	.mbHyperFirst = 1,	.mbHyperFirst = 1,
223	.mbInitRdIsModule = 1,	.mbInitRdIsModule = 1,
224	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
225		.titlePosition = 1,
226		};
227
228		struct keywordTypes grub2Keywords[] = {
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 241  struct keywordTypes extlinuxKeywords[] =	Line 585  struct keywordTypes extlinuxKeywords[] =
585	{ "initrd",    LT_INITRD,      ' ', ',' },	{ "initrd",    LT_INITRD,      ' ', ',' },
586	{ "append",    LT_KERNELARGS,  ' ' },	{ "append",    LT_KERNELARGS,  ' ' },
587	{ "prompt",     LT_UNKNOWN,     ' ' },	{ "prompt",     LT_UNKNOWN,     ' ' },
588		{ "fdt",        LT_DEVTREE,     ' ' },
589		{ "fdtdir",     LT_DEVTREE,     ' ' },
590	{ NULL,    0, 0 },	{ NULL,    0, 0 },
591	};	};
592	int useextlinuxmenu;	int useextlinuxmenu;
#	Line 251  struct configFileInfo eliloConfigType =	Line 597  struct configFileInfo eliloConfigType =
597	.needsBootPrefix = 1,	.needsBootPrefix = 1,
598	.argsInQuotes = 1,	.argsInQuotes = 1,
599	.mbConcatArgs = 1,	.mbConcatArgs = 1,
600		.titlePosition = 1,
601	};	};
602
603	struct configFileInfo liloConfigType = {	struct configFileInfo liloConfigType = {
#	Line 259  struct configFileInfo liloConfigType = {	Line 606  struct configFileInfo liloConfigType = {
606	.entryStart = LT_KERNEL,	.entryStart = LT_KERNEL,
607	.argsInQuotes = 1,	.argsInQuotes = 1,
608	.maxTitleLength = 15,	.maxTitleLength = 15,
609		.titlePosition = 1,
610	};	};
611
612	struct configFileInfo yabootConfigType = {	struct configFileInfo yabootConfigType = {
#	Line 269  struct configFileInfo yabootConfigType =	Line 617  struct configFileInfo yabootConfigType =
617	.argsInQuotes = 1,	.argsInQuotes = 1,
618	.maxTitleLength = 15,	.maxTitleLength = 15,
619	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
620		.titlePosition = 1,
621	};	};
622
623	struct configFileInfo siloConfigType = {	struct configFileInfo siloConfigType = {
#	Line 278  struct configFileInfo siloConfigType = {	Line 627  struct configFileInfo siloConfigType = {
627	.needsBootPrefix = 1,	.needsBootPrefix = 1,
628	.argsInQuotes = 1,	.argsInQuotes = 1,
629	.maxTitleLength = 15,	.maxTitleLength = 15,
630		.titlePosition = 1,
631	};	};
632
633	struct configFileInfo ziplConfigType = {	struct configFileInfo ziplConfigType = {
#	Line 291  struct configFileInfo ziplConfigType = {	Line 641  struct configFileInfo ziplConfigType = {
641	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
642	.defaultConfig = "/boot/extlinux/extlinux.conf",	.defaultConfig = "/boot/extlinux/extlinux.conf",
643	.keywords = extlinuxKeywords,	.keywords = extlinuxKeywords,
644		.caseInsensitive = 1,
645	.entryStart = LT_TITLE,	.entryStart = LT_TITLE,
646	.needsBootPrefix = 1,	.needsBootPrefix = 1,
647	.maxTitleLength = 255,	.maxTitleLength = 255,
648	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
649		.defaultIsUnquoted = 1,
650		.titlePosition = 1,
651	};	};
652
653	struct grubConfig {	struct grubConfig {
#	Line 315  struct singleEntry * findEntryByIndex(st	Line 668  struct singleEntry * findEntryByIndex(st
668	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
669	const char * path, const char * prefix,	const char * path, const char * prefix,
670	int * index);	int * index);
671		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
672		int * index);
673	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
674	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
675	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 324  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 378  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 *getKeyByType(enum lineType_e type, struct configFileInfo * cfi) {
773		struct keywordTypes *kt = getKeywordByType(type, cfi);
774		if (kt)
775		return kt->key;
776		return "unknown";
777		}
778
779	static char * getpathbyspec(char *device) {	static char * getpathbyspec(char *device) {
780	if (!blkid)	if (!blkid)
781	blkid_get_cache(&blkid, NULL);	blkid_get_cache(&blkid, NULL);
#	Line 404  static char * getuuidbydev(char *device)	Line 792  static char * getuuidbydev(char *device)
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 444  static int isEntryStart(struct singleLin	Line 836  static int isEntryStart(struct singleLin
836	}	}
837
838	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
839	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct grubConfig *cfg, struct singleLine * line) {
840	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it */
841	char * title;	char * title = NULL;
842	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
843	title++;	char *tmp = line->elements[cfg->cfi->titlePosition].item;
844	*(title + strlen(title) - 1) = '\0';	if (cfg->cfi->titleBracketed) {
845		tmp++;
846		title = strdup(tmp);
847		*(title + strlen(title) - 1) = '\0';
848		} else {
849		title = strdup(tmp);
850		}
851		} else if (line->type == LT_MENUENTRY)
852		title = strdup(line->elements[1].item);
853		else
854		return NULL;
855	return title;	return title;
856	}	}
857
#	Line 492  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 502  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 511  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 526  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 624  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 636  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 655  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 676  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 689  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 705  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 716  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 762  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 (isEntryStart(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 778  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 796  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 814  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 838  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 847  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 891  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 905  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 924  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 936  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 953  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 981  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 1008  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 1046  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 1140  static char *findDiskForRoot()	Line 1733  static char *findDiskForRoot()
1733	buf[rc] = '\0';	buf[rc] = '\0';
1734	chptr = buf;	chptr = buf;
1735
1736		char *foundanswer = NULL;
1737
1738	while (chptr && chptr != buf+rc) {	while (chptr && chptr != buf+rc) {
1739	devname = chptr;	devname = chptr;
1740
#	Line 1167  static char *findDiskForRoot()	Line 1762  static char *findDiskForRoot()
1762	* for '/' obviously.	* for '/' obviously.
1763	*/	*/
1764	if (*(++chptr) == '/' && *(++chptr) == ' ') {	if (*(++chptr) == '/' && *(++chptr) == ' ') {
1765	/*	/* remember the last / entry in mtab */
1766	* Move back 2, which is the first space after the device name, set	foundanswer = devname;
	* it to \0 so strdup will just get the devicename.
	*/
	chptr -= 2;
	*chptr = '\0';
	return strdup(devname);
1767	}	}
1768
1769	/* Next line */	/* Next line */
#	Line 1182  static char *findDiskForRoot()	Line 1772  static char *findDiskForRoot()
1772	chptr++;	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;	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;
#	Line 1194  int suitableImage(struct singleEntry * e	Line 1868  int suitableImage(struct singleEntry * e
1868	char * rootspec;	char * rootspec;
1869	char * rootdev;	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 1225  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 1239  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	rootdev = findDiskForRoot();	rootdev = findDiskForRoot();
1946	if (!rootdev)	if (!rootdev) {
1947		notSuitablePrintf(entry, 0, "can't find root device\n");
1948	return 0;	return 0;
1949		}
1950
1951	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1952		notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1953		getuuidbydev(rootdev), getuuidbydev(dev));
1954	free(rootdev);	free(rootdev);
1955	return 0;	return 0;
1956	}	}
1957
1958	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1959		notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1960		getuuidbydev(rootdev), getuuidbydev(dev));
1961	free(rootdev);	free(rootdev);
1962	return 0;	return 0;
1963	}	}
1964
1965	free(rootdev);	free(rootdev);
1966		notSuitablePrintf(entry, 1, "\n");
1967
1968	return 1;	return 1;
1969	}	}
#	Line 1290  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 1338  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 1349  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 1377  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 1399  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 1452  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 1460  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 1479  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 1533  void setFallbackImage(struct grubConfig	Line 2315  void setFallbackImage(struct grubConfig
2315	}	}
2316	}	}
2317
2318	void displayEntry(struct singleEntry * entry, const char * prefix, int index) {	void displayEntry(struct singleEntry * entry, const char * prefix, int index) {
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 1660  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 1714  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 1723  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 1760  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 1770  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 1796  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 1826  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 1994  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 2150  int updateImage(struct grubConfig * cfg,	Line 3347  int updateImage(struct grubConfig * cfg,
3347	return rc;	return rc;
3348	}	}
3349
3350		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3351		const char * image, const char * prefix, const char * initrd,
3352		const char * title) {
3353		struct singleEntry * entry;
3354		struct singleLine * line, * kernelLine, *endLine = NULL;
3355		int index = 0;
3356
3357		if (!image) return 0;
3358
3359		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3360		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3361		if (!kernelLine) continue;
3362
3363		/* if title is supplied, the entry's title must match it. */
3364		if (title) {
3365		char *linetitle;
3366
3367		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3368		if (!line)
3369		continue;
3370
3371		linetitle = extractTitle(cfg, line);
3372		if (!linetitle)
3373		continue;
3374		if (strcmp(title, linetitle)) {
3375		free(linetitle);
3376		continue;
3377		}
3378		free(linetitle);
3379		}
3380
3381		if (prefix) {
3382		int prefixLen = strlen(prefix);
3383		if (!strncmp(initrd, prefix, prefixLen))
3384		initrd += prefixLen;
3385		}
3386		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3387		if (endLine)
3388		removeLine(entry, endLine);
3389		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3390		kernelLine->indent, initrd);
3391		if (!line)
3392		return 1;
3393		if (endLine) {
3394		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3395		if (!line)
3396		return 1;
3397		}
3398
3399		break;
3400		}
3401
3402		return 0;
3403		}
3404
3405	int updateInitrd(struct grubConfig * cfg, const char * image,	int updateInitrd(struct grubConfig * cfg, const char * image,
3406	const char * prefix, const char * initrd) {	const char * prefix, const char * initrd, const char * title) {
3407	struct singleEntry * entry;	struct singleEntry * entry;
3408	struct singleLine * line, * kernelLine;	struct singleLine * line, * kernelLine, *endLine = NULL;
3409	int index = 0;	int index = 0;
3410
3411	if (!image) return 0;	if (!image) return 0;
3412
3413	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3414	kernelLine = getLineByType(LT_KERNEL, entry->lines);	kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3415	if (!kernelLine) continue;	if (!kernelLine) continue;
3416
3417	line = getLineByType(LT_INITRD, entry->lines);	/* if title is supplied, the entry's title must match it. */
3418		if (title) {
3419		char *linetitle;
3420
3421		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3422		if (!line)
3423		continue;
3424
3425		linetitle = extractTitle(cfg, line);
3426		if (!linetitle)
3427		continue;
3428		if (strcmp(title, linetitle)) {
3429		free(linetitle);
3430		continue;
3431		}
3432		free(linetitle);
3433		}
3434
3435		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3436	if (line)	if (line)
3437	removeLine(entry, line);	removeLine(entry, line);
3438	if (prefix) {	if (prefix) {
#	Line 2170  int updateInitrd(struct grubConfig * cfg	Line 3440  int updateInitrd(struct grubConfig * cfg
3440	if (!strncmp(initrd, prefix, prefixLen))	if (!strncmp(initrd, prefix, prefixLen))
3441	initrd += prefixLen;	initrd += prefixLen;
3442	}	}
3443	line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);	endLine = getLineByType(LT_ENTRY_END, entry->lines);
3444	if (!line) return 1;	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;	break;
3470	}	}
3471
#	Line 2201  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 2348  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 2373  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 2406  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 2420  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 2465  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 2509  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 2522  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 2600  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 2649  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 2662  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 2675  int addNewKernel(struct grubConfig * con	Line 4072  int addNewKernel(struct grubConfig * con
4072	*/	*/
4073	switch (config->cfi->entryStart) {	switch (config->cfi->entryStart) {
4074	case LT_KERNEL:	case LT_KERNEL:
4075		case LT_KERNEL_EFI:
4076		case LT_KERNEL_16:
4077	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
4078	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
4079	} else {	} else {
4080	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
4081		preferredLineType(LT_KERNEL, config->cfi),
4082	config->primaryIndent,	config->primaryIndent,
4083	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4084	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 2692  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 2723  int addNewKernel(struct grubConfig * con	Line 4135  int addNewKernel(struct grubConfig * con
4135	}	}
4136	}	}
4137
4138		struct singleLine *endLine = NULL;
4139		endLine = getLineByType(LT_ENTRY_END, new->lines);
4140		if (endLine) {
4141		removeLine(new, endLine);
4142		needs |= NEED_END;
4143		}
4144
4145	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4146	* weren't present in the template, or in the case of no template,	* weren't present in the template, or in the case of no template,
4147	* all the lines following the entryStart.	* all the lines following the entryStart.
#	Line 2742  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 2759  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 2778  int addNewKernel(struct grubConfig * con	Line 4212  int addNewKernel(struct grubConfig * con
4212	return 0;	return 0;
4213	}	}
4214
	static void traceback(int signum)
	{
	void *array[40];
	size_t size;
	signal(SIGSEGV, SIG_DFL);
	memset(array, '\0', sizeof (array));
	size = backtrace(array, 40);
	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",
	(unsigned long)size);
	backtrace_symbols_fd(array, size, STDERR_FILENO);
	exit(1);
	}
4215	int main(int argc, const char ** argv) {	int main(int argc, const char ** argv) {
4216	poptContext optCon;	poptContext optCon;
4217	char * grubConfig = NULL;	const char * grubConfig = NULL;
4218	char * outputFile = NULL;	char * outputFile = NULL;
4219	int arg = 0;	int arg = 0;
4220	int flags = 0;	int flags = 0;
4221	int badImageOkay = 0;	int badImageOkay = 0;
4222		int configureGrub2 = 0;
4223	int configureLilo = 0, configureELilo = 0, configureGrub = 0;	int configureLilo = 0, configureELilo = 0, configureGrub = 0;
4224	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;
4225	int configureExtLinux = 0;	int configureExtLinux = 0;
#	Line 2811  int main(int argc, const char ** argv) {	Line 4231  int main(int argc, const char ** argv) {
4231	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4232	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4233	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4234	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4235	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4236	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4237	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 2821  int main(int argc, const char ** argv) {	Line 4241  int main(int argc, const char ** argv) {
4241	char * removeArgs = NULL;	char * removeArgs = NULL;
4242	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4243	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4244		char * envPath = NULL;
4245	const char * chptr = NULL;	const char * chptr = NULL;
4246	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4247	struct grubConfig * config;	struct grubConfig * config;
4248	struct singleEntry * template = NULL;	struct singleEntry * template = NULL;
4249	int copyDefault = 0, makeDefault = 0;	int copyDefault = 0, makeDefault = 0;
4250	int displayDefault = 0;	int displayDefault = 0;
4251		int displayDefaultIndex = 0;
4252		int displayDefaultTitle = 0;
4253		int defaultIndex = -1;
4254	struct poptOption options[] = {	struct poptOption options[] = {
4255	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4256	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 2844  int main(int argc, const char ** argv) {	Line 4268  int main(int argc, const char ** argv) {
4268	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4269	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4270	_("bootfs") },	_("bootfs") },
4271	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4272	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4273	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4274	#endif	#endif
4275	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4276	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
#	Line 2857  int main(int argc, const char ** argv) {	Line 4281  int main(int argc, const char ** argv) {
4281	"the kernel referenced by the default image does not exist, "	"the kernel referenced by the default image does not exist, "
4282	"the first linux entry whose kernel does exist is used as the "	"the first linux entry whose kernel does exist is used as the "
4283	"template"), NULL },	"template"), NULL },
4284		{ "debug", 0, 0, &debug, 0,
4285		_("print debugging information for failures") },
4286	{ "default-kernel", 0, 0, &displayDefault, 0,	{ "default-kernel", 0, 0, &displayDefault, 0,
4287	_("display the path of the default kernel") },	_("display the path of the default kernel") },
4288		{ "default-index", 0, 0, &displayDefaultIndex, 0,
4289		_("display the index of the default kernel") },
4290		{ "default-title", 0, 0, &displayDefaultTitle, 0,
4291		_("display the title of the default kernel") },
4292		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4293		_("device tree file for new stanza"), _("dtb-path") },
4294		{ "devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4295		_("device tree directory for new stanza"), _("dtb-path") },
4296	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4297	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4298		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4299		_("force grub2 stanzas to use efi") },
4300		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4301		_("path for environment data"),
4302		_("path") },
4303	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4304	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4305	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
4306	_("configure grub bootloader") },	_("configure grub bootloader") },
4307		{ "grub2", 0, POPT_ARG_NONE, &configureGrub2, 0,
4308		_("configure grub2 bootloader") },
4309	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,
4310	_("display boot information for specified kernel"),	_("display boot information for specified kernel"),
4311	_("kernel-path") },	_("kernel-path") },
4312	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4313	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4314	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4315	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4316	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4317	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4318	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 2891  int main(int argc, const char ** argv) {	Line 4332  int main(int argc, const char ** argv) {
4332	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4333	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4334	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4335		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4336		_("make the given entry index the default entry"),
4337		_("entry-index") },
4338	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4339	_("configure silo bootloader") },	_("configure silo bootloader") },
4340	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 2910  int main(int argc, const char ** argv) {	Line 4354  int main(int argc, const char ** argv) {
4354
4355	useextlinuxmenu=0;	useextlinuxmenu=0;
4356
4357	signal(SIGSEGV, traceback);	int i = 0;
4358		for (int j = 1; j < argc; j++)
4359		i += strlen(argv[j]) + 1;
4360		saved_command_line = malloc(i);
4361		if (!saved_command_line) {
4362		fprintf(stderr, "grubby: %m\n");
4363		exit(1);
4364		}
4365		saved_command_line[0] = '\0';
4366		for (int j = 1; j < argc; j++) {
4367		strcat(saved_command_line, argv[j]);
4368		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4369		}
4370
4371	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4372	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
#	Line 2944  int main(int argc, const char ** argv) {	Line 4400  int main(int argc, const char ** argv) {
4400	return 1;	return 1;
4401	}	}
4402
4403	if ((configureLilo + configureGrub + configureELilo +	if ((configureLilo + configureGrub2 + configureGrub + configureELilo +
4404	configureYaboot + configureSilo + configureZipl +	configureYaboot + configureSilo + configureZipl +
4405	configureExtLinux ) > 1) {	configureExtLinux ) > 1) {
4406	fprintf(stderr, _("grubby: cannot specify multiple bootloaders\n"));	fprintf(stderr, _("grubby: cannot specify multiple bootloaders\n"));
#	Line 2953  int main(int argc, const char ** argv) {	Line 4409  int main(int argc, const char ** argv) {
4409	fprintf(stderr,	fprintf(stderr,
4410	_("grubby: cannot specify config file with --bootloader-probe\n"));	_("grubby: cannot specify config file with --bootloader-probe\n"));
4411	return 1;	return 1;
4412		} else if (configureGrub2) {
4413		cfi = &grub2ConfigType;
4414		if (envPath)
4415		cfi->envFile = envPath;
4416	} else if (configureLilo) {	} else if (configureLilo) {
4417	cfi = &liloConfigType;	cfi = &liloConfigType;
4418	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 2971  int main(int argc, const char ** argv) {	Line 4431  int main(int argc, const char ** argv) {
4431	}	}
4432
4433	if (!cfi) {	if (!cfi) {
4434		if (grub2FindConfig(&grub2ConfigType)) {
4435		cfi = &grub2ConfigType;
4436		if (envPath)
4437		cfi->envFile = envPath;
4438		} else
4439	#ifdef __ia64__	#ifdef __ia64__
4440	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4441	#elif __powerpc__	#elif __powerpc__
4442	cfi = &yabootConfigType;	cfi = &yabootConfigType;
4443	#elif __sparc__	#elif __sparc__
4444	cfi = &siloConfigType;	cfi = &siloConfigType;
4445	#elif __s390__	#elif __s390__
4446	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4447	#elif __s390x__	#elif __s390x__
4448	cfi = &ziplConfigtype;	cfi = &ziplConfigtype;
4449	#else	#else
4450	cfi = &grubConfigType;	cfi = &grubConfigType;
4451	#endif	#endif
4452	}	}
4453
4454	if (!grubConfig)	if (!grubConfig) {
4455	grubConfig = cfi->defaultConfig;	if (cfi->findConfig)
4456		grubConfig = cfi->findConfig(cfi);
4457		if (!grubConfig)
4458		grubConfig = cfi->defaultConfig;
4459		}
4460
4461	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4462	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4463	defaultKernel)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4464		(defaultIndex >= 0))) {
4465	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4466	"specified option"));	"specified option"));
4467	return 1;	return 1;
4468	}	}
4469
4470	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4471	removeKernelPath)) {	removeKernelPath)) {
4472	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4473	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 3007  int main(int argc, const char ** argv) {	Line 4477  int main(int argc, const char ** argv) {
4477	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4478	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4479	return 1;	return 1;
4480	} else if (!newKernelPath && (newKernelTitle  || copyDefault ||	} else if (!newKernelPath && (copyDefault ||
4481	(newKernelInitrd && !updateKernelPath)||	(newKernelInitrd && !updateKernelPath)||
4482	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4483	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
#	Line 3033  int main(int argc, const char ** argv) {	Line 4503  int main(int argc, const char ** argv) {
4503	makeDefault = 1;	makeDefault = 1;
4504	defaultKernel = NULL;	defaultKernel = NULL;
4505	}	}
4506		else if (defaultKernel && (defaultIndex >= 0)) {
4507		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4508		"may not be used together\n"));
4509		return 1;
4510		}
4511
4512	if (!strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4513	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
4514	"is used\n"));	"is used\n"));
4515	return 1;	return 1;
4516	}	}
4517
4518	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4519	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4520	&& !removeMBKernel) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4521		&& (defaultIndex == -1)) {
4522	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4523	return 1;	return 1;
4524	}	}
#	Line 3069  int main(int argc, const char ** argv) {	Line 4545  int main(int argc, const char ** argv) {
4545	}	}
4546
4547	if (bootloaderProbe) {	if (bootloaderProbe) {
4548	int lrc = 0, grc = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4549	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4550
4551		const char *grub2config = grub2FindConfig(&grub2ConfigType);
4552		if (grub2config) {
4553		gconfig = readConfig(grub2config, &grub2ConfigType);
4554		if (!gconfig)
4555		gr2c = 1;
4556		else
4557		gr2c = checkForGrub2(gconfig);
4558		}
4559
4560	if (!access(grubConfigType.defaultConfig, F_OK)) {	const char *grubconfig = grubFindConfig(&grubConfigType);
4561	gconfig = readConfig(grubConfigType.defaultConfig, &grubConfigType);	if (!access(grubconfig, F_OK)) {
4562		gconfig = readConfig(grubconfig, &grubConfigType);
4563	if (!gconfig)	if (!gconfig)
4564	grc = 1;	grc = 1;
4565	else	else
#	Line 3088  int main(int argc, const char ** argv) {	Line 4574  int main(int argc, const char ** argv) {
4574	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4575	}	}
4576
4577		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4578		econfig = readConfig(eliloConfigType.defaultConfig,
4579		&eliloConfigType);
4580		if (!econfig)
4581		erc = 1;
4582		else
4583		erc = checkForElilo(econfig);
4584		}
4585
4586	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4587	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4588	if (!lconfig)	if (!lconfig)
4589	erc = 1;	extrc = 1;
4590	else	else
4591	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4592	}	}
4593
4594	if (lrc == 1 || grc == 1) return 1;
4595		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4596		yconfig = readConfig(yabootConfigType.defaultConfig,
4597		&yabootConfigType);
4598		if (!yconfig)
4599		yrc = 1;
4600		else
4601		yrc = checkForYaboot(yconfig);
4602		}
4603
4604		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4605		erc == 1)
4606		return 1;
4607
4608	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4609		if (gr2c == 2) printf("grub2\n");
4610	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4611	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4612		if (yrc == 2) printf("yaboot\n");
4613		if (erc == 2) printf("elilo\n");
4614
4615	return 0;	return 0;
4616	}	}
4617
4618		if (grubConfig == NULL) {
4619		printf("Could not find bootloader configuration file.\n");
4620		exit(1);
4621		}
4622
4623	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4624	if (!config) return 1;	if (!config) return 1;
4625
#	Line 3114  int main(int argc, const char ** argv) {	Line 4629  int main(int argc, const char ** argv) {
4629	char * rootspec;	char * rootspec;
4630
4631	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4632		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4633		cfi->defaultIsSaved)
4634		config->defaultImage = 0;
4635	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4636	if (!entry) return 0;	if (!entry) return 0;
4637	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4638
4639	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4640	if (!line) return 0;	if (!line) return 0;
4641
4642	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3126  int main(int argc, const char ** argv) {	Line 4644  int main(int argc, const char ** argv) {
4644	((rootspec != NULL) ? strlen(rootspec) : 0));	((rootspec != NULL) ? strlen(rootspec) : 0));
4645
4646	return 0;	return 0;
4647
4648		} else if (displayDefaultTitle) {
4649		struct singleLine * line;
4650		struct singleEntry * entry;
4651
4652		if (config->defaultImage == -1) return 0;
4653		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4654		cfi->defaultIsSaved)
4655		config->defaultImage = 0;
4656		entry = findEntryByIndex(config, config->defaultImage);
4657		if (!entry) return 0;
4658
4659		if (!configureGrub2) {
4660		line = getLineByType(LT_TITLE, entry->lines);
4661		if (!line) return 0;
4662		printf("%s\n", line->elements[1].item);
4663
4664		} else {
4665		char * title;
4666
4667		dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
4668		line = getLineByType(LT_MENUENTRY, entry->lines);
4669		if (!line) return 0;
4670		title = grub2ExtractTitle(line);
4671		if (title)
4672		printf("%s\n", title);
4673		}
4674		return 0;
4675
4676		} else if (displayDefaultIndex) {
4677		if (config->defaultImage == -1) return 0;
4678		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4679		cfi->defaultIsSaved)
4680		config->defaultImage = 0;
4681		printf("%i\n", config->defaultImage);
4682		return 0;
4683
4684	} else if (kernelInfo)	} else if (kernelInfo)
4685	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
4686
#	Line 3137  int main(int argc, const char ** argv) {	Line 4692  int main(int argc, const char ** argv) {
4692	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4693	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4694	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4695	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4696	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4697	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4698	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4699	if (updateKernelPath && newKernelInitrd) {	if (updateKernelPath && newKernelInitrd) {
4700	if (updateInitrd(config, updateKernelPath, bootPrefix,	if (newMBKernel) {
4701	newKernelInitrd)) return 1;	if (addMBInitrd(config, newMBKernel, updateKernelPath,
4702		bootPrefix, newKernelInitrd,
4703		newKernelTitle))
4704		return 1;
4705		} else {
4706		if (updateInitrd(config, updateKernelPath, bootPrefix,
4707		newKernelInitrd, newKernelTitle))
4708		return 1;
4709		}
4710	}	}
4711	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4712	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4713	extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4714	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4715
4716
4717	if (numEntries(config) == 0) {	if (numEntries(config) == 0) {
#	Line 3158  int main(int argc, const char ** argv) {	Line 4721  int main(int argc, const char ** argv) {
4721	}	}
4722
4723	if (!outputFile)	if (!outputFile)
4724	outputFile = grubConfig;	outputFile = (char *)grubConfig;
4725
4726	return writeConfig(config, outputFile, bootPrefix);	return writeConfig(config, outputFile, bootPrefix);
4727	}	}

---

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

Legend: Removed from v.1693   changed lines   Added in v.2991