Diff of /trunk/grubby/grubby.c

Parent Directory | Revision Log | Patch

	revision 1721 by niro, Sat Feb 18 00:52:28 2012 UTC	revision 2992 by niro, Thu Jun 30 10:35:14 2016 UTC
#	Line 36	Line 36
36	#include <signal.h>	#include <signal.h>
37	#include <blkid/blkid.h>	#include <blkid/blkid.h>
38
39		#include "log.h"
40
41	#ifndef DEBUG	#ifndef DEBUG
42	#define DEBUG 0	#define DEBUG 0
43	#endif	#endif
#	Line 46	Line 48
48	#define dbgPrintf(format, args...)	#define dbgPrintf(format, args...)
49	#endif	#endif
50
51		int debug = 0; /* Currently just for template debugging */
52
53	#define _(A) (A)	#define _(A) (A)
54
55	#define MAX_EXTRA_INITRDS  16 /* code segment checked by --bootloader-probe */	#define MAX_EXTRA_INITRDS  16 /* code segment checked by --bootloader-probe */
#	Line 54	Line 58
58	#define NOOP_OPCODE 0x90	#define NOOP_OPCODE 0x90
59	#define JMP_SHORT_OPCODE 0xeb	#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 80  enum lineType_e {	Line 94  enum lineType_e {
94	LT_MENUENTRY    = 1 << 17,	LT_MENUENTRY    = 1 << 17,
95	LT_ENTRY_END    = 1 << 18,	LT_ENTRY_END    = 1 << 18,
96	LT_SET_VARIABLE = 1 << 19,	LT_SET_VARIABLE = 1 << 19,
97	LT_UNKNOWN      = 1 << 20,	LT_KERNEL_EFI   = 1 << 20,
98		LT_INITRD_EFI   = 1 << 21,
99		LT_KERNEL_16    = 1 << 22,
100		LT_INITRD_16    = 1 << 23,
101		LT_DEVTREE      = 1 << 24,
102		LT_UNKNOWN      = 1 << 25,
103	};	};
104
105	struct singleLine {	struct singleLine {
#	Line 109  struct singleEntry {	Line 128  struct singleEntry {
128	#define NEED_ARGS    (1 << 3)	#define NEED_ARGS    (1 << 3)
129	#define NEED_MB      (1 << 4)	#define NEED_MB      (1 << 4)
130	#define NEED_END     (1 << 5)	#define NEED_END     (1 << 5)
131		#define NEED_DEVTREE (1 << 6)
132
133	#define MAIN_DEFAULT    (1 << 0)	#define MAIN_DEFAULT    (1 << 0)
134	#define DEFAULT_SAVED       -2	#define DEFAULT_SAVED       -2
135		#define DEFAULT_SAVED_GRUB2 -3
136
137	struct keywordTypes {	struct keywordTypes {
138	char * key;	char * key;
#	Line 125  struct configFileInfo;	Line 146  struct configFileInfo;
146	typedef const char *(*findConfigFunc)(struct configFileInfo *);	typedef const char *(*findConfigFunc)(struct configFileInfo *);
147	typedef const int (*writeLineFunc)(struct configFileInfo *,	typedef const int (*writeLineFunc)(struct configFileInfo *,
148	struct singleLine *line);	struct singleLine *line);
149		typedef char *(*getEnvFunc)(struct configFileInfo *, char *name);
150		typedef int (*setEnvFunc)(struct configFileInfo *, char *name, char *value);
151
152	struct configFileInfo {	struct configFileInfo {
153	char * defaultConfig;	char * defaultConfig;
154	findConfigFunc findConfig;	findConfigFunc findConfig;
155	writeLineFunc writeLine;	writeLineFunc writeLine;
156		getEnvFunc getEnv;
157		setEnvFunc setEnv;
158	struct keywordTypes * keywords;	struct keywordTypes * keywords;
159		int caseInsensitive;
160	int defaultIsIndex;	int defaultIsIndex;
161	int defaultIsVariable;	int defaultIsVariable;
162	int defaultSupportSaved;	int defaultSupportSaved;
163		int defaultIsSaved;
164		int defaultIsUnquoted;
165	enum lineType_e entryStart;	enum lineType_e entryStart;
166	enum lineType_e entryEnd;	enum lineType_e entryEnd;
167	int needsBootPrefix;	int needsBootPrefix;
#	Line 145  struct configFileInfo {	Line 173  struct configFileInfo {
173	int mbInitRdIsModule;	int mbInitRdIsModule;
174	int mbConcatArgs;	int mbConcatArgs;
175	int mbAllowExtraInitRds;	int mbAllowExtraInitRds;
176		char *envFile;
177	};	};
178
179	struct keywordTypes grubKeywords[] = {	struct keywordTypes grubKeywords[] = {
#	Line 161  struct keywordTypes grubKeywords[] = {	Line 190  struct keywordTypes grubKeywords[] = {
190
191	const char *grubFindConfig(struct configFileInfo *cfi) {	const char *grubFindConfig(struct configFileInfo *cfi) {
192	static const char *configFiles[] = {	static const char *configFiles[] = {
	"/etc/grub.conf",
193	"/boot/grub/grub.conf",	"/boot/grub/grub.conf",
194	"/boot/grub/menu.lst",	"/boot/grub/menu.lst",
195		"/etc/grub.conf",
196		"/boot/grub2/grub.cfg",
197		"/boot/grub2-efi/grub.cfg",
198	NULL	NULL
199	};	};
200	static int i = -1;	static int i = -1;
#	Line 191  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[] = {	struct keywordTypes grub2Keywords[] = {
#	Line 202  struct keywordTypes grub2Keywords[] = {	Line 234  struct keywordTypes grub2Keywords[] = {
234	{ "default",    LT_DEFAULT,     ' ' },	{ "default",    LT_DEFAULT,     ' ' },
235	{ "fallback",   LT_FALLBACK,    ' ' },	{ "fallback",   LT_FALLBACK,    ' ' },
236	{ "linux",      LT_KERNEL,      ' ' },	{ "linux",      LT_KERNEL,      ' ' },
237		{ "linuxefi",   LT_KERNEL_EFI,  ' ' },
238		{ "linux16",    LT_KERNEL_16,   ' ' },
239	{ "initrd",     LT_INITRD,      ' ', ' ' },	{ "initrd",     LT_INITRD,      ' ', ' ' },
240		{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
241		{ "initrd16",   LT_INITRD_16,   ' ', ' ' },
242	{ "module",     LT_MBMODULE,    ' ' },	{ "module",     LT_MBMODULE,    ' ' },
243	{ "kernel",     LT_HYPER,       ' ' },	{ "kernel",     LT_HYPER,       ' ' },
244		{ "devicetree", LT_DEVTREE,  ' ' },
245	{ NULL, 0, 0 },	{ NULL, 0, 0 },
246	};	};
247
#	Line 216  const char *grub2FindConfig(struct confi	Line 253  const char *grub2FindConfig(struct confi
253	};	};
254	static int i = -1;	static int i = -1;
255	static const char *grub_cfg = "/boot/grub/grub.cfg";	static const char *grub_cfg = "/boot/grub/grub.cfg";
256		int rc = -1;
257
258	if (i == -1) {	if (i == -1) {
259	for (i = 0; configFiles[i] != NULL; i++) {	for (i = 0; configFiles[i] != NULL; i++) {
260	dbgPrintf("Checking \"%s\": ", configFiles[i]);	dbgPrintf("Checking \"%s\": ", configFiles[i]);
261	if (!access(configFiles[i], R_OK)) {	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");	dbgPrintf("found\n");
270	return configFiles[i];	return configFiles[i];
271	}	}
#	Line 239  const char *grub2FindConfig(struct confi	Line 284  const char *grub2FindConfig(struct confi
284	return configFiles[i];	return configFiles[i];
285	}	}
286
287		/* kind of hacky.  It'll give the first 1024 bytes, ish. */
288		static char *grub2GetEnv(struct configFileInfo *info, char *name)
289		{
290		static char buf[1025];
291		char *s = NULL;
292		char *ret = NULL;
293		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
294		int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
295
296		if (rc < 0)
297		return NULL;
298
299		FILE *f = popen(s, "r");
300		if (!f)
301		goto out;
302
303		memset(buf, '\0', sizeof (buf));
304		ret = fgets(buf, 1024, f);
305		pclose(f);
306
307		if (ret) {
308		ret += strlen(name) + 1;
309		ret[strlen(ret) - 1] = '\0';
310		}
311		dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
312		out:
313		free(s);
314		return ret;
315		}
316
317		static int sPopCount(const char *s, const char *c)
318		{
319		int ret = 0;
320		if (!s)
321		return -1;
322		for (int i = 0; s[i] != '\0'; i++)
323		for (int j = 0; c[j] != '\0'; j++)
324		if (s[i] == c[j])
325		ret++;
326		return ret;
327		}
328
329		static char *shellEscape(const char *s)
330		{
331		int l = strlen(s) + sPopCount(s, "'") * 2;
332
333		char *ret = calloc(l+1, sizeof (*ret));
334		if (!ret)
335		return NULL;
336		for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
337		if (s[i] == '\'')
338		ret[j++] = '\\';
339		ret[j] = s[i];
340		}
341		return ret;
342		}
343
344		static void unquote(char *s)
345		{
346		int l = strlen(s);
347
348		if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
349		memmove(s, s+1, l-2);
350		s[l-2] = '\0';
351		}
352		}
353
354		static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
355		{
356		char *s = NULL;
357		int rc = 0;
358		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
359
360		unquote(value);
361		value = shellEscape(value);
362		if (!value)
363		return -1;
364
365		rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
366		free(value);
367		if (rc <0)
368		return -1;
369
370		dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
371		rc = system(s);
372		free(s);
373		return rc;
374		}
375
376		/* this is a gigantic hack to avoid clobbering grub2 variables... */
377		static int is_special_grub2_variable(const char *name)
378		{
379		if (!strcmp(name,"\"${next_entry}\""))
380		return 1;
381		if (!strcmp(name,"\"${prev_saved_entry}\""))
382		return 1;
383		return 0;
384		}
385
386		int sizeOfSingleLine(struct singleLine * line) {
387		int count = 0;
388
389		for (int i = 0; i < line->numElements; i++) {
390		int indentSize = 0;
391
392		count = count + strlen(line->elements[i].item);
393
394		indentSize = strlen(line->elements[i].indent);
395		if (indentSize > 0)
396		count = count + indentSize;
397		else
398		/* be extra safe and add room for whitespaces */
399		count = count + 1;
400		}
401
402		/* room for trailing terminator */
403		count = count + 1;
404
405		return count;
406		}
407
408		static int isquote(char q)
409		{
410		if (q == '\'' || q == '\"')
411		return 1;
412		return 0;
413		}
414
415		static int iskernel(enum lineType_e type) {
416		return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
417		}
418
419		static int isinitrd(enum lineType_e type) {
420		return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
421		}
422
423		char *grub2ExtractTitle(struct singleLine * line) {
424		char * current;
425		char * current_indent;
426		int current_len;
427		int current_indent_len;
428		int i;
429
430		/* bail out if line does not start with menuentry */
431		if (strcmp(line->elements[0].item, "menuentry"))
432		return NULL;
433
434		i = 1;
435		current = line->elements[i].item;
436		current_len = strlen(current);
437
438		/* if second word is quoted, strip the quotes and return single word */
439		if (isquote(*current) && isquote(current[current_len - 1])) {
440		char *tmp;
441
442		tmp = strdup(current+1);
443		if (!tmp)
444		return NULL;
445		tmp[strlen(tmp)-1] = '\0';
446		return tmp;
447		}
448
449		/* if no quotes, return second word verbatim */
450		if (!isquote(*current))
451		return current;
452
453		/* second element start with a quote, so we have to find the element
454		* whose last character is also quote (assuming it's the closing one) */
455		int resultMaxSize;
456		char * result;
457		/* need to ensure that ' does not match " as we search */
458		char quote_char = *current;
459
460		resultMaxSize = sizeOfSingleLine(line);
461		result = malloc(resultMaxSize);
462		snprintf(result, resultMaxSize, "%s", ++current);
463
464		i++;
465		for (; i < line->numElements; ++i) {
466		current = line->elements[i].item;
467		current_len = strlen(current);
468		current_indent = line->elements[i].indent;
469		current_indent_len = strlen(current_indent);
470
471		strncat(result, current_indent, current_indent_len);
472		if (current[current_len-1] != quote_char) {
473		strncat(result, current, current_len);
474		} else {
475		strncat(result, current, current_len - 1);
476		break;
477		}
478		}
479		return result;
480		}
481
482	struct configFileInfo grub2ConfigType = {	struct configFileInfo grub2ConfigType = {
483	.findConfig = grub2FindConfig,	.findConfig = grub2FindConfig,
484		.getEnv = grub2GetEnv,
485		.setEnv = grub2SetEnv,
486	.keywords = grub2Keywords,	.keywords = grub2Keywords,
487	.defaultIsIndex = 1,	.defaultIsIndex = 1,
488	.defaultSupportSaved = 0,	.defaultSupportSaved = 1,
489	.defaultIsVariable = 1,	.defaultIsVariable = 1,
490	.entryStart = LT_MENUENTRY,	.entryStart = LT_MENUENTRY,
491	.entryEnd = LT_ENTRY_END,	.entryEnd = LT_ENTRY_END,
#	Line 345  struct keywordTypes extlinuxKeywords[] =	Line 587  struct keywordTypes extlinuxKeywords[] =
587	{ "initrd",    LT_INITRD,      ' ', ',' },	{ "initrd",    LT_INITRD,      ' ', ',' },
588	{ "append",    LT_KERNELARGS,  ' ' },	{ "append",    LT_KERNELARGS,  ' ' },
589	{ "prompt",     LT_UNKNOWN,     ' ' },	{ "prompt",     LT_UNKNOWN,     ' ' },
590		{ "fdt",        LT_DEVTREE,     ' ' },
591		{ "fdtdir",     LT_DEVTREE,     ' ' },
592	{ NULL,    0, 0 },	{ NULL,    0, 0 },
593	};	};
594	int useextlinuxmenu;	int useextlinuxmenu;
#	Line 355  struct configFileInfo eliloConfigType =	Line 599  struct configFileInfo eliloConfigType =
599	.needsBootPrefix = 1,	.needsBootPrefix = 1,
600	.argsInQuotes = 1,	.argsInQuotes = 1,
601	.mbConcatArgs = 1,	.mbConcatArgs = 1,
602		.titlePosition = 1,
603	};	};
604
605	struct configFileInfo liloConfigType = {	struct configFileInfo liloConfigType = {
#	Line 363  struct configFileInfo liloConfigType = {	Line 608  struct configFileInfo liloConfigType = {
608	.entryStart = LT_KERNEL,	.entryStart = LT_KERNEL,
609	.argsInQuotes = 1,	.argsInQuotes = 1,
610	.maxTitleLength = 15,	.maxTitleLength = 15,
611		.titlePosition = 1,
612	};	};
613
614	struct configFileInfo yabootConfigType = {	struct configFileInfo yabootConfigType = {
#	Line 373  struct configFileInfo yabootConfigType =	Line 619  struct configFileInfo yabootConfigType =
619	.argsInQuotes = 1,	.argsInQuotes = 1,
620	.maxTitleLength = 15,	.maxTitleLength = 15,
621	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
622		.titlePosition = 1,
623	};	};
624
625	struct configFileInfo siloConfigType = {	struct configFileInfo siloConfigType = {
#	Line 382  struct configFileInfo siloConfigType = {	Line 629  struct configFileInfo siloConfigType = {
629	.needsBootPrefix = 1,	.needsBootPrefix = 1,
630	.argsInQuotes = 1,	.argsInQuotes = 1,
631	.maxTitleLength = 15,	.maxTitleLength = 15,
632		.titlePosition = 1,
633	};	};
634
635	struct configFileInfo ziplConfigType = {	struct configFileInfo ziplConfigType = {
#	Line 395  struct configFileInfo ziplConfigType = {	Line 643  struct configFileInfo ziplConfigType = {
643	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
644	.defaultConfig = "/boot/extlinux/extlinux.conf",	.defaultConfig = "/boot/extlinux/extlinux.conf",
645	.keywords = extlinuxKeywords,	.keywords = extlinuxKeywords,
646		.caseInsensitive = 1,
647	.entryStart = LT_TITLE,	.entryStart = LT_TITLE,
648	.needsBootPrefix = 1,	.needsBootPrefix = 1,
649	.maxTitleLength = 255,	.maxTitleLength = 255,
650	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
651		.defaultIsUnquoted = 1,
652		.titlePosition = 1,
653	};	};
654
655	struct grubConfig {	struct grubConfig {
#	Line 419  struct singleEntry * findEntryByIndex(st	Line 670  struct singleEntry * findEntryByIndex(st
670	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
671	const char * path, const char * prefix,	const char * path, const char * prefix,
672	int * index);	int * index);
673		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
674		int * index);
675	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
676	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
677	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 483  static char * sdupprintf(const char *for	Line 736  static char * sdupprintf(const char *for
736	return buf;	return buf;
737	}	}
738
739		static enum lineType_e preferredLineType(enum lineType_e type,
740		struct configFileInfo *cfi) {
741		if (isEfi && cfi == &grub2ConfigType) {
742		switch (type) {
743		case LT_KERNEL:
744		return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
745		case LT_INITRD:
746		return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
747		default:
748		return type;
749		}
750		#if defined(__i386__) || defined(__x86_64__)
751		} else if (cfi == &grub2ConfigType) {
752		switch (type) {
753		case LT_KERNEL:
754		return LT_KERNEL_16;
755		case LT_INITRD:
756		return LT_INITRD_16;
757		default:
758		return type;
759		}
760		#endif
761		}
762		return type;
763		}
764
765	static struct keywordTypes * getKeywordByType(enum lineType_e type,	static struct keywordTypes * getKeywordByType(enum lineType_e type,
766	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
767	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
	for (kw = cfi->keywords; kw->key; kw++) {
768	if (kw->type == type)	if (kw->type == type)
769	return kw;	return kw;
770	}	}
#	Line 516  static char * getuuidbydev(char *device)	Line 794  static char * getuuidbydev(char *device)
794
795	static enum lineType_e getTypeByKeyword(char * keyword,	static enum lineType_e getTypeByKeyword(char * keyword,
796	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
797	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
798	for (kw = cfi->keywords; kw->key; kw++) {	if (cfi->caseInsensitive) {
799	if (!strcmp(keyword, kw->key))	if (!strcasecmp(keyword, kw->key))
800	return kw->type;	return kw->type;
801		} else {
802		if (!strcmp(keyword, kw->key))
803		return kw->type;
804		}
805	}	}
806	return LT_UNKNOWN;	return LT_UNKNOWN;
807	}	}
#	Line 556  static int isEntryStart(struct singleLin	Line 838  static int isEntryStart(struct singleLin
838	}	}
839
840	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
841	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct grubConfig *cfg, struct singleLine * line) {
842	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it */
843	char * title;	char * title = NULL;
844	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
845	title++;	char *tmp = line->elements[cfg->cfi->titlePosition].item;
846	*(title + strlen(title) - 1) = '\0';	if (cfg->cfi->titleBracketed) {
847		tmp++;
848		title = strdup(tmp);
849		*(title + strlen(title) - 1) = '\0';
850		} else {
851		title = strdup(tmp);
852		}
853		} else if (line->type == LT_MENUENTRY)
854		title = strdup(line->elements[1].item);
855		else
856		return NULL;
857	return title;	return title;
858	}	}
859
#	Line 604  static void lineInit(struct singleLine *	Line 896  static void lineInit(struct singleLine *
896	}	}
897
898	struct singleLine * lineDup(struct singleLine * line) {	struct singleLine * lineDup(struct singleLine * line) {
	int i;
899	struct singleLine * newLine = malloc(sizeof(*newLine));	struct singleLine * newLine = malloc(sizeof(*newLine));
900
901	newLine->indent = strdup(line->indent);	newLine->indent = strdup(line->indent);
#	Line 614  struct singleLine * lineDup(struct singl	Line 905  struct singleLine * lineDup(struct singl
905	newLine->elements = malloc(sizeof(*newLine->elements) *	newLine->elements = malloc(sizeof(*newLine->elements) *
906	newLine->numElements);	newLine->numElements);
907
908	for (i = 0; i < newLine->numElements; i++) {	for (int i = 0; i < newLine->numElements; i++) {
909	newLine->elements[i].indent = strdup(line->elements[i].indent);	newLine->elements[i].indent = strdup(line->elements[i].indent);
910	newLine->elements[i].item = strdup(line->elements[i].item);	newLine->elements[i].item = strdup(line->elements[i].item);
911	}	}
#	Line 623  struct singleLine * lineDup(struct singl	Line 914  struct singleLine * lineDup(struct singl
914	}	}
915
916	static void lineFree(struct singleLine * line) {	static void lineFree(struct singleLine * line) {
	int i;
917	if (line->indent) free(line->indent);	if (line->indent) free(line->indent);
918
919	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
920	free(line->elements[i].item);	free(line->elements[i].item);
921	free(line->elements[i].indent);	free(line->elements[i].indent);
922	}	}
#	Line 638  static void lineFree(struct singleLine *	Line 927  static void lineFree(struct singleLine *
927
928	static int lineWrite(FILE * out, struct singleLine * line,	static int lineWrite(FILE * out, struct singleLine * line,
929	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
	int i;
930	if (fprintf(out, "%s", line->indent) == -1) return -1;	if (fprintf(out, "%s", line->indent) == -1) return -1;
931
932	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
933		/* Need to handle this, because we strip the quotes from
934		* menuentry when read it. */
935		if (line->type == LT_MENUENTRY && i == 1) {
936		if(!isquote(*line->elements[i].item)) {
937		int substring = 0;
938		/* If the line contains nested quotes, we did not strip
939		* the "interna" quotes and we must use the right quotes
940		* again when writing the updated file. */
941		for (int j = i; j < line->numElements; j++) {
942		if (strchr(line->elements[i].item, '\'') != NULL) {
943		substring = 1;
944		fprintf(out, "\"%s\"", line->elements[i].item);
945		break;
946		}
947		}
948		if (!substring)
949		fprintf(out, "\'%s\'", line->elements[i].item);
950		} else {
951		fprintf(out, "%s", line->elements[i].item);
952		}
953		fprintf(out, "%s", line->elements[i].indent);
954
955		continue;
956		}
957
958	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
959	if (fputc('"', out) == EOF) return -1;	if (fputc('"', out) == EOF) return -1;
960
#	Line 736  static int getNextLine(char ** bufPtr, s	Line 1048  static int getNextLine(char ** bufPtr, s
1048	if (*line->elements[0].item == '#') {	if (*line->elements[0].item == '#') {
1049	char * fullLine;	char * fullLine;
1050	int len;	int len;
	int i;
1051
1052	len = strlen(line->indent);	len = strlen(line->indent);
1053	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1054	len += strlen(line->elements[i].item) +	len += strlen(line->elements[i].item) +
1055	strlen(line->elements[i].indent);	strlen(line->elements[i].indent);
1056
#	Line 748  static int getNextLine(char ** bufPtr, s	Line 1059  static int getNextLine(char ** bufPtr, s
1059	free(line->indent);	free(line->indent);
1060	line->indent = fullLine;	line->indent = fullLine;
1061
1062	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1063	strcat(fullLine, line->elements[i].item);	strcat(fullLine, line->elements[i].item);
1064	strcat(fullLine, line->elements[i].indent);	strcat(fullLine, line->elements[i].indent);
1065	free(line->elements[i].item);	free(line->elements[i].item);
#	Line 767  static int getNextLine(char ** bufPtr, s	Line 1078  static int getNextLine(char ** bufPtr, s
1078	* elements up more	* elements up more
1079	*/	*/
1080	if (!isspace(kw->separatorChar)) {	if (!isspace(kw->separatorChar)) {
	int i;
1081	char indent[2] = "";	char indent[2] = "";
1082	indent[0] = kw->separatorChar;	indent[0] = kw->separatorChar;
1083	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1084	char *p;	char *p;
	int j;
1085	int numNewElements;	int numNewElements;
1086
1087	numNewElements = 0;	numNewElements = 0;
#	Line 788  static int getNextLine(char ** bufPtr, s	Line 1097  static int getNextLine(char ** bufPtr, s
1097	sizeof(*line->elements) * elementsAlloced);	sizeof(*line->elements) * elementsAlloced);
1098	}	}
1099
1100	for (j = line->numElements; j > i; j--) {	for (int j = line->numElements; j > i; j--) {
1101	line->elements[j + numNewElements] = line->elements[j];	line->elements[j + numNewElements] = line->elements[j];
1102	}	}
1103	line->numElements += numNewElements;	line->numElements += numNewElements;
#	Line 801  static int getNextLine(char ** bufPtr, s	Line 1110  static int getNextLine(char ** bufPtr, s
1110	break;	break;
1111	}	}
1112
1113	free(line->elements[i].indent);	line->elements[i + 1].indent = line->elements[i].indent;
1114	line->elements[i].indent = strdup(indent);	line->elements[i].indent = strdup(indent);
1115	*p++ = '\0';	*p++ = '\0';
1116	i++;	i++;
1117	line->elements[i].item = strdup(p);	line->elements[i].item = strdup(p);
	line->elements[i].indent = strdup("");
	p = line->elements[i].item;
1118	}	}
1119	}	}
1120	}	}
#	Line 817  static int getNextLine(char ** bufPtr, s	Line 1124  static int getNextLine(char ** bufPtr, s
1124	return 0;	return 0;
1125	}	}
1126
1127		static int isnumber(const char *s)
1128		{
1129		int i;
1130		for (i = 0; s[i] != '\0'; i++)
1131		if (s[i] < '0' || s[i] > '9')
1132		return 0;
1133		return i;
1134		}
1135
1136	static struct grubConfig * readConfig(const char * inName,	static struct grubConfig * readConfig(const char * inName,
1137	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
1138	int in;	int in;
#	Line 828  static struct grubConfig * readConfig(co	Line 1144  static struct grubConfig * readConfig(co
1144	struct singleLine * last = NULL, * line, * defaultLine = NULL;	struct singleLine * last = NULL, * line, * defaultLine = NULL;
1145	char * end;	char * end;
1146	struct singleEntry * entry = NULL;	struct singleEntry * entry = NULL;
1147	int i, len;	int len;
1148	char * buf;	char * buf;
1149
1150	if (!strcmp(inName, "-")) {	if (inName == NULL) {
1151		printf("Could not find bootloader configuration\n");
1152		exit(1);
1153		} else if (!strcmp(inName, "-")) {
1154	in = 0;	in = 0;
1155	} else {	} else {
1156	if ((in = open(inName, O_RDONLY)) < 0) {	if ((in = open(inName, O_RDONLY)) < 0) {
#	Line 874  static struct grubConfig * readConfig(co	Line 1193  static struct grubConfig * readConfig(co
1193	cfg->secondaryIndent = strdup(line->indent);	cfg->secondaryIndent = strdup(line->indent);
1194	}	}
1195
1196	if (isEntryStart(line, cfi)) {	if (isEntryStart(line, cfi) || (cfg->entries && !sawEntry)) {
1197	sawEntry = 1;	sawEntry = 1;
1198	if (!entry) {	if (!entry) {
1199	cfg->entries = malloc(sizeof(*entry));	cfg->entries = malloc(sizeof(*entry));
#	Line 891  static struct grubConfig * readConfig(co	Line 1210  static struct grubConfig * readConfig(co
1210	}	}
1211
1212	if (line->type == LT_SET_VARIABLE) {	if (line->type == LT_SET_VARIABLE) {
	int i;
1213	dbgPrintf("found 'set' command (%d elements): ", line->numElements);	dbgPrintf("found 'set' command (%d elements): ", line->numElements);
1214	dbgPrintf("%s", line->indent);	dbgPrintf("%s", line->indent);
1215	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1216	dbgPrintf("%s\"%s\"", line->elements[i].indent, line->elements[i].item);	dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
1217	dbgPrintf("\n");	dbgPrintf("\n");
1218	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1219	if (kwType && line->numElements == 3 &&	if (kwType && line->numElements == 3 &&
1220	!strcmp(line->elements[1].item, kwType->key)) {	!strcmp(line->elements[1].item, kwType->key) &&
1221		!is_special_grub2_variable(line->elements[2].item)) {
1222	dbgPrintf("Line sets default config\n");	dbgPrintf("Line sets default config\n");
1223	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1224	defaultLine = line;	defaultLine = line;
1225	}	}
	} else if (line->type == LT_DEFAULT && line->numElements == 2) {
	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
	defaultLine = line;
1226
1227	} else if (line->type == LT_KERNEL) {	} else if (iskernel(line->type)) {
1228	/* if by some freak chance this is multiboot and the "module"	/* if by some freak chance this is multiboot and the "module"
1229	* lines came earlier in the template, make sure to use LT_HYPER	* lines came earlier in the template, make sure to use LT_HYPER
1230	* instead of LT_KERNEL now	* instead of LT_KERNEL now
1231	*/	*/
1232	if (entry->multiboot)	if (entry && entry->multiboot)
1233	line->type = LT_HYPER;	line->type = LT_HYPER;
1234
1235	} else if (line->type == LT_MBMODULE) {	} else if (line->type == LT_MBMODULE) {
#	Line 922  static struct grubConfig * readConfig(co	Line 1238  static struct grubConfig * readConfig(co
1238	* This only applies to grub, but that's the only place we	* This only applies to grub, but that's the only place we
1239	* should find LT_MBMODULE lines anyway.	* should find LT_MBMODULE lines anyway.
1240	*/	*/
1241	struct singleLine * l;	for (struct singleLine *l = entry->lines; l; l = l->next) {
	for (l = entry->lines; l; l = l->next) {
1242	if (l->type == LT_HYPER)	if (l->type == LT_HYPER)
1243	break;	break;
1244	else if (l->type == LT_KERNEL) {	else if (iskernel(l->type)) {
1245	l->type = LT_HYPER;	l->type = LT_HYPER;
1246	break;	break;
1247	}	}
#	Line 940  static struct grubConfig * readConfig(co	Line 1255  static struct grubConfig * readConfig(co
1255	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1256	if (*end) cfg->fallbackImage = -1;	if (*end) cfg->fallbackImage = -1;
1257
1258	} else if (line->type == LT_TITLE && line->numElements > 1) {	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1259	/* make the title a single argument (undoing our parsing) */	(line->type == LT_TITLE && line->numElements > 1)) {
1260		/* make the title/default a single argument (undoing our parsing) */
1261	len = 0;	len = 0;
1262	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1263	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
1264	len += strlen(line->elements[i].indent);	len += strlen(line->elements[i].indent);
1265	}	}
1266	buf = malloc(len + 1);	buf = malloc(len + 1);
1267	*buf = '\0';	*buf = '\0';
1268
1269	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1270	strcat(buf, line->elements[i].item);	strcat(buf, line->elements[i].item);
1271	free(line->elements[i].item);	free(line->elements[i].item);
1272
#	Line 964  static struct grubConfig * readConfig(co	Line 1280  static struct grubConfig * readConfig(co
1280	line->elements[line->numElements - 1].indent;	line->elements[line->numElements - 1].indent;
1281	line->elements[1].item = buf;	line->elements[1].item = buf;
1282	line->numElements = 2;	line->numElements = 2;
1283		} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
1284		/* let --remove-kernel="TITLE=what" work */
1285		len = 0;
1286		char *extras;
1287		char *title;
1288		/* initially unseen value */
1289		char quote_char = '\0';
1290
1291		for (int i = 1; i < line->numElements; i++) {
1292		len += strlen(line->elements[i].item);
1293		len += strlen(line->elements[i].indent);
1294		}
1295		buf = malloc(len + 1);
1296		*buf = '\0';
1297
1298		/* allocate mem for extra flags. */
1299		extras = malloc(len + 1);
1300		*extras = '\0';
1301
1302		/* get title. */
1303		for (int i = 0; i < line->numElements; i++) {
1304		if (!strcmp(line->elements[i].item, "menuentry"))
1305		continue;
1306		if (isquote(*line->elements[i].item) && quote_char == '\0') {
1307		/* ensure we properly pair off quotes */
1308		quote_char = *line->elements[i].item;
1309		title = line->elements[i].item + 1;
1310		} else {
1311		title = line->elements[i].item;
1312		}
1313
1314		len = strlen(title);
1315		if (title[len-1] == quote_char) {
1316		strncat(buf, title,len-1);
1317		break;
1318		} else {
1319		strcat(buf, title);
1320		strcat(buf, line->elements[i].indent);
1321		}
1322		}
1323
1324		/* get extras */
1325		int count = 0;
1326		quote_char = '\0';
1327		for (int i = 0; i < line->numElements; i++) {
1328		if (count >= 2) {
1329		strcat(extras, line->elements[i].item);
1330		strcat(extras, line->elements[i].indent);
1331		}
1332
1333		if (!strcmp(line->elements[i].item, "menuentry"))
1334		continue;
1335
1336		/* count ' or ", there should be two in menuentry line. */
1337		if (isquote(*line->elements[i].item) && quote_char == '\0') {
1338		/* ensure we properly pair off quotes */
1339		quote_char = *line->elements[i].item;
1340		count++;
1341		}
1342
1343		len = strlen(line->elements[i].item);
1344
1345		if (line->elements[i].item[len -1] == quote_char)
1346		count++;
1347
1348		/* ok, we get the final ' or ", others are extras. */
1349		}
1350		line->elements[1].indent =
1351		line->elements[line->numElements - 2].indent;
1352		line->elements[1].item = buf;
1353		line->elements[2].indent =
1354		line->elements[line->numElements - 2].indent;
1355		line->elements[2].item = extras;
1356		line->numElements = 3;
1357	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
1358	/* Strip off any " which may be present; they'll be put back	/* Strip off any " which may be present; they'll be put back
1359	on write. This is one of the few (the only?) places that grubby	on write. This is one of the few (the only?) places that grubby
#	Line 973  static struct grubConfig * readConfig(co	Line 1362  static struct grubConfig * readConfig(co
1362	if (line->numElements >= 2) {	if (line->numElements >= 2) {
1363	int last, len;	int last, len;
1364
1365	if (*line->elements[1].item == '"')	if (isquote(*line->elements[1].item))
1366	memmove(line->elements[1].item, line->elements[1].item + 1,	memmove(line->elements[1].item, line->elements[1].item + 1,
1367	strlen(line->elements[1].item + 1) + 1);	strlen(line->elements[1].item + 1) + 1);
1368
1369	last = line->numElements - 1;	last = line->numElements - 1;
1370	len = strlen(line->elements[last].item) - 1;	len = strlen(line->elements[last].item) - 1;
1371	if (line->elements[last].item[len] == '"')	if (isquote(line->elements[last].item[len]))
1372	line->elements[last].item[len] = '\0';	line->elements[last].item[len] = '\0';
1373	}	}
1374	}	}
1375
1376		if (line->type == LT_DEFAULT && line->numElements == 2) {
1377		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1378		defaultLine = line;
1379		}
1380
1381	/* If we find a generic config option which should live at the	/* If we find a generic config option which should live at the
1382	top of the file, move it there. Old versions of grubby were	top of the file, move it there. Old versions of grubby were
1383	probably responsible for putting new images in the wrong	probably responsible for putting new images in the wrong
#	Line 1038  static struct grubConfig * readConfig(co	Line 1432  static struct grubConfig * readConfig(co
1432
1433	dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");	dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");
1434	if (defaultLine) {	if (defaultLine) {
1435	if (cfi->defaultIsVariable) {	if (defaultLine->numElements > 2 &&
1436		cfi->defaultSupportSaved &&
1437		!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1438		cfg->cfi->defaultIsSaved = 1;
1439		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1440		if (cfg->cfi->getEnv) {
1441		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1442		if (defTitle) {
1443		int index = 0;
1444		if (isnumber(defTitle)) {
1445		index = atoi(defTitle);
1446		entry = findEntryByIndex(cfg, index);
1447		} else {
1448		entry = findEntryByTitle(cfg, defTitle, &index);
1449		}
1450		if (entry)
1451		cfg->defaultImage = index;
1452		}
1453		}
1454		} else if (cfi->defaultIsVariable) {
1455	char *value = defaultLine->elements[2].item;	char *value = defaultLine->elements[2].item;
1456	while (*value && (*value == '"' || *value == '\'' ||	while (*value && (*value == '"' || *value == '\'' ||
1457	*value == ' ' || *value == '\t'))	*value == ' ' || *value == '\t'))
#	Line 1055  static struct grubConfig * readConfig(co	Line 1468  static struct grubConfig * readConfig(co
1468	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
1469	if (*end) cfg->defaultImage = -1;	if (*end) cfg->defaultImage = -1;
1470	} else if (defaultLine->numElements >= 2) {	} else if (defaultLine->numElements >= 2) {
1471	i = 0;	int i = 0;
1472	while ((entry = findEntryByIndex(cfg, i))) {	while ((entry = findEntryByIndex(cfg, i))) {
1473	for (line = entry->lines; line; line = line->next)	for (line = entry->lines; line; line = line->next)
1474	if (line->type == LT_TITLE) break;	if (line->type == LT_TITLE) break;
#	Line 1066  static struct grubConfig * readConfig(co	Line 1479  static struct grubConfig * readConfig(co
1479	line->elements[1].item)) break;	line->elements[1].item)) break;
1480	} else if (line) {	} else if (line) {
1481	if (!strcmp(defaultLine->elements[1].item,	if (!strcmp(defaultLine->elements[1].item,
1482	extractTitle(line))) break;	extractTitle(cfg, line))) break;
1483	}	}
1484	i++;	i++;
1485	entry = NULL;	entry = NULL;
#	Line 1078  static struct grubConfig * readConfig(co	Line 1491  static struct grubConfig * readConfig(co
1491	cfg->defaultImage = -1;	cfg->defaultImage = -1;
1492	}	}
1493	}	}
1494		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1495		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1496		if (defTitle) {
1497		int index = 0;
1498		if (isnumber(defTitle)) {
1499		index = atoi(defTitle);
1500		entry = findEntryByIndex(cfg, index);
1501		} else {
1502		entry = findEntryByTitle(cfg, defTitle, &index);
1503		}
1504		if (entry)
1505		cfg->defaultImage = index;
1506		}
1507	} else {	} else {
1508	cfg->defaultImage = 0;	cfg->defaultImage = 0;
1509	}	}
#	Line 1095  static void writeDefault(FILE * out, cha	Line 1521  static void writeDefault(FILE * out, cha
1521
1522	if (cfg->defaultImage == DEFAULT_SAVED)	if (cfg->defaultImage == DEFAULT_SAVED)
1523	fprintf(out, "%sdefault%ssaved\n", indent, separator);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1524	else if (cfg->defaultImage > -1) {	else if (cfg->cfi->defaultIsSaved) {
1525		fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1526		if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1527		char *title;
1528		entry = findEntryByIndex(cfg, cfg->defaultImage);
1529		line = getLineByType(LT_MENUENTRY, entry->lines);
1530		if (!line)
1531		line = getLineByType(LT_TITLE, entry->lines);
1532		if (line) {
1533		title = extractTitle(cfg, line);
1534		if (title)
1535		cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1536		}
1537		}
1538		} else if (cfg->defaultImage > -1) {
1539	if (cfg->cfi->defaultIsIndex) {	if (cfg->cfi->defaultIsIndex) {
1540	if (cfg->cfi->defaultIsVariable) {	if (cfg->cfi->defaultIsVariable) {
1541	fprintf(out, "%sset default=\"%d\"\n", indent,	fprintf(out, "%sset default=\"%d\"\n", indent,
#	Line 1128  static void writeDefault(FILE * out, cha	Line 1568  static void writeDefault(FILE * out, cha
1568	else if (line && (line->numElements == 1) &&	else if (line && (line->numElements == 1) &&
1569	cfg->cfi->titleBracketed) {	cfg->cfi->titleBracketed) {
1570	fprintf(out, "%sdefault%s%s\n", indent, separator,	fprintf(out, "%sdefault%s%s\n", indent, separator,
1571	extractTitle(line));	extractTitle(cfg, line));
1572	}	}
1573	}	}
1574	}	}
#	Line 1155  static int writeConfig(struct grubConfig	Line 1595  static int writeConfig(struct grubConfig
1595
1596	/* most likely the symlink is relative, so change our	/* most likely the symlink is relative, so change our
1597	directory to the dir of the symlink */	directory to the dir of the symlink */
1598	rc = chdir(dirname(strdupa(outName)));	char *dir = strdupa(outName);
1599		rc = chdir(dirname(dir));
1600	do {	do {
1601	buf = alloca(len + 1);	buf = alloca(len + 1);
1602	rc = readlink(basename(outName), buf, len);	rc = readlink(basename(outName), buf, len);
#	Line 1197  static int writeConfig(struct grubConfig	Line 1638  static int writeConfig(struct grubConfig
1638	while (line) {	while (line) {
1639	if (line->type == LT_SET_VARIABLE && defaultKw &&	if (line->type == LT_SET_VARIABLE && defaultKw &&
1640	line->numElements == 3 &&	line->numElements == 3 &&
1641	!strcmp(line->elements[1].item, defaultKw->key)) {	!strcmp(line->elements[1].item, defaultKw->key) &&
1642		!is_special_grub2_variable(line->elements[2].item)) {
1643	writeDefault(out, line->indent, line->elements[0].indent, cfg);	writeDefault(out, line->indent, line->elements[0].indent, cfg);
1644	needs &= ~MAIN_DEFAULT;	needs &= ~MAIN_DEFAULT;
1645	} else if (line->type == LT_DEFAULT) {	} else if (line->type == LT_DEFAULT) {
#	Line 1293  static char *findDiskForRoot()	Line 1735  static char *findDiskForRoot()
1735	buf[rc] = '\0';	buf[rc] = '\0';
1736	chptr = buf;	chptr = buf;
1737
1738		char *foundanswer = NULL;
1739
1740	while (chptr && chptr != buf+rc) {	while (chptr && chptr != buf+rc) {
1741	devname = chptr;	devname = chptr;
1742
#	Line 1320  static char *findDiskForRoot()	Line 1764  static char *findDiskForRoot()
1764	* for '/' obviously.	* for '/' obviously.
1765	*/	*/
1766	if (*(++chptr) == '/' && *(++chptr) == ' ') {	if (*(++chptr) == '/' && *(++chptr) == ' ') {
1767	/*	/* remember the last / entry in mtab */
1768	* 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);
1769	}	}
1770
1771	/* Next line */	/* Next line */
#	Line 1335  static char *findDiskForRoot()	Line 1774  static char *findDiskForRoot()
1774	chptr++;	chptr++;
1775	}	}
1776
1777		/* Return the last / entry found */
1778		if (foundanswer) {
1779		chptr = strchr(foundanswer, ' ');
1780		*chptr = '\0';
1781		return strdup(foundanswer);
1782		}
1783
1784	return NULL;	return NULL;
1785	}	}
1786
1787		void printEntry(struct singleEntry * entry, FILE *f) {
1788		int i;
1789		struct singleLine * line;
1790
1791		for (line = entry->lines; line; line = line->next) {
1792		log_message(f, "DBG: %s", line->indent);
1793		for (i = 0; i < line->numElements; i++) {
1794		/* Need to handle this, because we strip the quotes from
1795		* menuentry when read it. */
1796		if (line->type == LT_MENUENTRY && i == 1) {
1797		if(!isquote(*line->elements[i].item))
1798		log_message(f, "\'%s\'", line->elements[i].item);
1799		else
1800		log_message(f, "%s", line->elements[i].item);
1801		log_message(f, "%s", line->elements[i].indent);
1802
1803		continue;
1804		}
1805
1806		log_message(f, "%s%s",
1807		line->elements[i].item, line->elements[i].indent);
1808		}
1809		log_message(f, "\n");
1810		}
1811		}
1812
1813		void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1814		{
1815		static int once;
1816		va_list argp, argq;
1817
1818		va_start(argp, fmt);
1819
1820		va_copy(argq, argp);
1821		if (!once) {
1822		log_time(NULL);
1823		log_message(NULL, "command line: %s\n", saved_command_line);
1824		}
1825		log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1826		log_vmessage(NULL, fmt, argq);
1827
1828		printEntry(entry, NULL);
1829		va_end(argq);
1830
1831		if (!debug) {
1832		once = 1;
1833		va_end(argp);
1834		return;
1835		}
1836
1837		if (okay) {
1838		va_end(argp);
1839		return;
1840		}
1841
1842		if (!once)
1843		log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1844		once = 1;
1845		fprintf(stderr, "DBG: Image entry failed: ");
1846		vfprintf(stderr, fmt, argp);
1847		printEntry(entry, stderr);
1848		va_end(argp);
1849		}
1850
1851		#define beginswith(s, c) ((s) && (s)[0] == (c))
1852
1853		static int endswith(const char *s, char c)
1854		{
1855		int slen;
1856
1857		if (!s || !s[0])
1858		return 0;
1859		slen = strlen(s) - 1;
1860
1861		return s[slen] == c;
1862		}
1863
1864	int suitableImage(struct singleEntry * entry, const char * bootPrefix,	int suitableImage(struct singleEntry * entry, const char * bootPrefix,
1865	int skipRemoved, int flags) {	int skipRemoved, int flags) {
1866	struct singleLine * line;	struct singleLine * line;
#	Line 1347  int suitableImage(struct singleEntry * e	Line 1870  int suitableImage(struct singleEntry * e
1870	char * rootspec;	char * rootspec;
1871	char * rootdev;	char * rootdev;
1872
1873	if (skipRemoved && entry->skip) return 0;	if (skipRemoved && entry->skip) {
1874		notSuitablePrintf(entry, 0, "marked to skip\n");
1875		return 0;
1876		}
1877
1878	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1879	if (!line || line->numElements < 2) return 0;	if (!line) {
1880		notSuitablePrintf(entry, 0, "no line found\n");
1881		return 0;
1882		}
1883		if (line->numElements < 2) {
1884		notSuitablePrintf(entry, 0, "line has only %d elements\n",
1885		line->numElements);
1886		return 0;
1887		}
1888
1889	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	if (flags & GRUBBY_BADIMAGE_OKAY) {
1890		notSuitablePrintf(entry, 1, "\n");
1891		return 1;
1892		}
1893
1894	fullName = alloca(strlen(bootPrefix) +	fullName = alloca(strlen(bootPrefix) +
1895	strlen(line->elements[1].item) + 1);	strlen(line->elements[1].item) + 1);
1896	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
1897	sprintf(fullName, "%s%s", bootPrefix,	int rootspec_offset = rootspec ? strlen(rootspec) : 0;
1898	line->elements[1].item + (rootspec ? strlen(rootspec) : 0));	int hasslash = endswith(bootPrefix, '/') ||
1899	if (access(fullName, R_OK)) return 0;	beginswith(line->elements[1].item + rootspec_offset, '/');
1900		sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1901		line->elements[1].item + rootspec_offset);
1902		if (access(fullName, R_OK)) {
1903		notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1904		return 0;
1905		}
1906	for (i = 2; i < line->numElements; i++)	for (i = 2; i < line->numElements; i++)
1907	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1908	if (i < line->numElements) {	if (i < line->numElements) {
#	Line 1378  int suitableImage(struct singleEntry * e	Line 1920  int suitableImage(struct singleEntry * e
1920	line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);
1921
1922	/* failed to find one */	/* failed to find one */
1923	if (!line) return 0;	if (!line) {
1924		notSuitablePrintf(entry, 0, "no line found\n");
1925		return 0;
1926		}
1927
1928	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
1929	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1930	if (i < line->numElements)	if (i < line->numElements)
1931	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1932	else {	else {
1933		notSuitablePrintf(entry, 0, "no root= entry found\n");
1934	/* it failed too...  can't find root= */	/* it failed too...  can't find root= */
1935	return 0;	return 0;
1936	}	}
#	Line 1392  int suitableImage(struct singleEntry * e	Line 1938  int suitableImage(struct singleEntry * e
1938	}	}
1939
1940	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1941	if (!dev)	if (!getpathbyspec(dev)) {
1942		notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1943	return 0;	return 0;
1944		} else
1945		dev = getpathbyspec(dev);
1946
1947	rootdev = findDiskForRoot();	rootdev = findDiskForRoot();
1948	if (!rootdev)	if (!rootdev) {
1949		notSuitablePrintf(entry, 0, "can't find root device\n");
1950	return 0;	return 0;
1951		}
1952
1953	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1954		notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1955		getuuidbydev(rootdev), getuuidbydev(dev));
1956	free(rootdev);	free(rootdev);
1957	return 0;	return 0;
1958	}	}
1959
1960	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1961		notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1962		getuuidbydev(rootdev), getuuidbydev(dev));
1963	free(rootdev);	free(rootdev);
1964	return 0;	return 0;
1965	}	}
1966
1967	free(rootdev);	free(rootdev);
1968		notSuitablePrintf(entry, 1, "\n");
1969
1970	return 1;	return 1;
1971	}	}
#	Line 1443  struct singleEntry * findEntryByPath(str	Line 1999  struct singleEntry * findEntryByPath(str
1999	}	}
2000
2001	indexVars[i + 1] = -1;	indexVars[i + 1] = -1;
2002
2003	i = 0;	i = 0;
2004	if (index) {	if (index) {
2005	while (i < *index) i++;	while (i < *index) {
2006	if (indexVars[i] == -1) return NULL;	i++;
2007		if (indexVars[i] == -1) return NULL;
2008		}
2009	}	}
2010
2011	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
2012	if (!entry) return NULL;	if (!entry) return NULL;
2013
2014	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2015	if (!line) return NULL;	if (!line) return NULL;
2016
2017	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1491  struct singleEntry * findEntryByPath(str	Line 2049  struct singleEntry * findEntryByPath(str
2049
2050	if (!strncmp(kernel, "TITLE=", 6)) {	if (!strncmp(kernel, "TITLE=", 6)) {
2051	prefix = "";	prefix = "";
2052	checkType = LT_TITLE;	checkType = LT_TITLE|LT_MENUENTRY;
2053	kernel += 6;	kernel += 6;
2054	}	}
2055
#	Line 1502  struct singleEntry * findEntryByPath(str	Line 2060  struct singleEntry * findEntryByPath(str
2060
2061	/* check all the lines matching checkType */	/* check all the lines matching checkType */
2062	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
2063	line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?	enum lineType_e ct = checkType;
2064	LT_KERNEL|LT_MBMODULE|LT_HYPER :	if (entry->multiboot && checkType == LT_KERNEL)
2065	checkType, line);	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2066	if (!line) break;  /* not found in this entry */	else if (checkType & LT_KERNEL)
2067		ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2068		line = getLineByType(ct, line);
2069		if (!line)
2070		break;  /* not found in this entry */
2071
2072	if (line && line->numElements >= 2) {	if (line && line->type != LT_MENUENTRY &&
2073		line->numElements >= 2) {
2074	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
2075	if (!strcmp(line->elements[1].item +	if (!strcmp(line->elements[1].item +
2076	((rootspec != NULL) ? strlen(rootspec) : 0),	((rootspec != NULL) ? strlen(rootspec) : 0),
2077	kernel + strlen(prefix)))	kernel + strlen(prefix)))
2078	break;	break;
2079	}	}
2080		if(line->type == LT_MENUENTRY &&
2081		!strcmp(line->elements[1].item, kernel))
2082		break;
2083	}	}
2084
2085	/* make sure this entry has a kernel identifier; this skips	/* make sure this entry has a kernel identifier; this skips
2086	* non-Linux boot entries (could find netbsd etc, though, which is	* non-Linux boot entries (could find netbsd etc, though, which is
2087	* unfortunate)	* unfortunate)
2088	*/	*/
2089	if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2090	break; /* found 'im! */	break; /* found 'im! */
2091	}	}
2092
#	Line 1530  struct singleEntry * findEntryByPath(str	Line 2096  struct singleEntry * findEntryByPath(str
2096	return entry;	return entry;
2097	}	}
2098
2099		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2100		int * index) {
2101		struct singleEntry * entry;
2102		struct singleLine * line;
2103		int i;
2104		char * newtitle;
2105
2106		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2107		if (index && i < *index)
2108		continue;
2109		line = getLineByType(LT_TITLE, entry->lines);
2110		if (!line)
2111		line = getLineByType(LT_MENUENTRY, entry->lines);
2112		if (!line)
2113		continue;
2114		newtitle = grub2ExtractTitle(line);
2115		if (!newtitle)
2116		continue;
2117		if (!strcmp(title, newtitle))
2118		break;
2119		}
2120
2121		if (!entry)
2122		return NULL;
2123
2124		if (index)
2125		*index = i;
2126		return entry;
2127		}
2128
2129	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2130	struct singleEntry * entry;	struct singleEntry * entry;
2131
#	Line 1552  struct singleEntry * findTemplate(struct	Line 2148  struct singleEntry * findTemplate(struct
2148	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2149	int index;	int index;
2150
2151	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2152		if (cfg->cfi->getEnv) {
2153		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2154		if (defTitle) {
2155		int index = 0;
2156		if (isnumber(defTitle)) {
2157		index = atoi(defTitle);
2158		entry = findEntryByIndex(cfg, index);
2159		} else {
2160		entry = findEntryByTitle(cfg, defTitle, &index);
2161		}
2162		if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2163		cfg->defaultImage = index;
2164		if (indexPtr)
2165		*indexPtr = index;
2166		return entry;
2167		}
2168		}
2169		}
2170		} else if (cfg->defaultImage > -1) {
2171	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2172	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2173	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1605  void markRemovedImage(struct grubConfig	Line 2220  void markRemovedImage(struct grubConfig
2220	const char * prefix) {	const char * prefix) {
2221	struct singleEntry * entry;	struct singleEntry * entry;
2222
2223	if (!image) return;	if (!image)
2224		return;
2225
2226		/* check and see if we're removing the default image */
2227		if (isdigit(*image)) {
2228		entry = findEntryByPath(cfg, image, prefix, NULL);
2229		if(entry)
2230		entry->skip = 1;
2231		return;
2232		}
2233
2234	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2235	entry->skip = 1;	entry->skip = 1;
#	Line 1613  void markRemovedImage(struct grubConfig	Line 2237  void markRemovedImage(struct grubConfig
2237
2238	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2239	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2240	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2241	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2242	int i, j;	int i, j;
2243
2244	if (newIsDefault) {	if (newIsDefault) {
2245	config->defaultImage = 0;	config->defaultImage = 0;
2246	return;	return;
2247		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2248		if (findEntryByIndex(config, index))
2249		config->defaultImage = index;
2250		else
2251		config->defaultImage = -1;
2252		return;
2253	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2254	i = 0;	i = 0;
2255	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1632  void setDefaultImage(struct grubConfig *	Line 2262  void setDefaultImage(struct grubConfig *
2262
2263	/* defaultImage now points to what we'd like to use, but before any order	/* defaultImage now points to what we'd like to use, but before any order
2264	changes */	changes */
2265	if (config->defaultImage == DEFAULT_SAVED)	if ((config->defaultImage == DEFAULT_SAVED) ||
2266		(config->defaultImage == DEFAULT_SAVED_GRUB2))
2267	/* default is set to saved, we don't want to change it */	/* default is set to saved, we don't want to change it */
2268	return;	return;
2269
#	Line 1690  void displayEntry(struct singleEntry * e	Line 2321  void displayEntry(struct singleEntry * e
2321	struct singleLine * line;	struct singleLine * line;
2322	char * root = NULL;	char * root = NULL;
2323	int i;	int i;
2324		int j;
2325
2326	printf("index=%d\n", index);	printf("index=%d\n", index);
2327
2328	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2329	if (!line) {	if (!line) {
2330	printf("non linux entry\n");	printf("non linux entry\n");
2331	return;	return;
2332	}	}
2333
2334	printf("kernel=%s\n", line->elements[1].item);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2335		printf("kernel=%s\n", line->elements[1].item);
2336		else
2337		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2338
2339	if (line->numElements >= 3) {	if (line->numElements >= 3) {
2340	printf("args=\"");	printf("args=\"");
#	Line 1755  void displayEntry(struct singleEntry * e	Line 2390  void displayEntry(struct singleEntry * e
2390	printf("root=%s\n", s);	printf("root=%s\n", s);
2391	}	}
2392
2393	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2394
2395	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
2396	printf("initrd=%s", prefix);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2397		printf("initrd=");
2398		else
2399		printf("initrd=%s", prefix);
2400
2401	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
2402	printf("%s%s", line->elements[i].item, line->elements[i].indent);	printf("%s%s", line->elements[i].item, line->elements[i].indent);
2403	printf("\n");	printf("\n");
2404	}	}
2405
2406		line = getLineByType(LT_TITLE, entry->lines);
2407		if (line) {
2408		printf("title=%s\n", line->elements[1].item);
2409		} else {
2410		char * title;
2411		line = getLineByType(LT_MENUENTRY, entry->lines);
2412		if (line) {
2413		title = grub2ExtractTitle(line);
2414		if (title)
2415		printf("title=%s\n", title);
2416		}
2417		}
2418
2419		for (j = 0, line = entry->lines; line; line = line->next) {
2420		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2421		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2422		printf("mbmodule%d=", j);
2423		else
2424		printf("mbmodule%d=%s", j, prefix);
2425
2426		for (i = 1; i < line->numElements; i++)
2427		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2428		printf("\n");
2429		j++;
2430		}
2431		}
2432		}
2433
2434		int isSuseSystem(void) {
2435		const char * path;
2436		const static char default_path[] = "/etc/SuSE-release";
2437
2438		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2439		path = default_path;
2440
2441		if (!access(path, R_OK))
2442		return 1;
2443		return 0;
2444		}
2445
2446		int isSuseGrubConf(const char * path) {
2447		FILE * grubConf;
2448		char * line = NULL;
2449		size_t len = 0, res = 0;
2450
2451		grubConf = fopen(path, "r");
2452		if (!grubConf) {
2453		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2454		return 0;
2455		}
2456
2457		while ((res = getline(&line, &len, grubConf)) != -1) {
2458		if (!strncmp(line, "setup", 5)) {
2459		fclose(grubConf);
2460		free(line);
2461		return 1;
2462		}
2463		}
2464
2465		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2466		path);
2467
2468		fclose(grubConf);
2469		free(line);
2470		return 0;
2471		}
2472
2473		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2474		FILE * grubConf;
2475		char * line = NULL;
2476		size_t res = 0, len = 0;
2477
2478		if (!path) return 1;
2479		if (!lbaPtr) return 1;
2480
2481		grubConf = fopen(path, "r");
2482		if (!grubConf) return 1;
2483
2484		while ((res = getline(&line, &len, grubConf)) != -1) {
2485		if (line[res - 1] == '\n')
2486		line[res - 1] = '\0';
2487		else if (len > res)
2488		line[res] = '\0';
2489		else {
2490		line = realloc(line, res + 1);
2491		line[res] = '\0';
2492		}
2493
2494		if (!strncmp(line, "setup", 5)) {
2495		if (strstr(line, "--force-lba")) {
2496		*lbaPtr = 1;
2497		} else {
2498		*lbaPtr = 0;
2499		}
2500		dbgPrintf("lba: %i\n", *lbaPtr);
2501		break;
2502		}
2503		}
2504
2505		free(line);
2506		fclose(grubConf);
2507		return 0;
2508		}
2509
2510		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2511		FILE * grubConf;
2512		char * line = NULL;
2513		size_t res = 0, len = 0;
2514		char * lastParamPtr = NULL;
2515		char * secLastParamPtr = NULL;
2516		char installDeviceNumber = '\0';
2517		char * bounds = NULL;
2518
2519		if (!path) return 1;
2520		if (!devicePtr) return 1;
2521
2522		grubConf = fopen(path, "r");
2523		if (!grubConf) return 1;
2524
2525		while ((res = getline(&line, &len, grubConf)) != -1) {
2526		if (strncmp(line, "setup", 5))
2527		continue;
2528
2529		if (line[res - 1] == '\n')
2530		line[res - 1] = '\0';
2531		else if (len > res)
2532		line[res] = '\0';
2533		else {
2534		line = realloc(line, res + 1);
2535		line[res] = '\0';
2536		}
2537
2538		lastParamPtr = bounds = line + res;
2539
2540		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2541		while (!isspace(*lastParamPtr))
2542		lastParamPtr--;
2543		lastParamPtr++;
2544
2545		secLastParamPtr = lastParamPtr - 2;
2546		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2547
2548		if (lastParamPtr + 3 > bounds) {
2549		dbgPrintf("lastParamPtr going over boundary");
2550		fclose(grubConf);
2551		free(line);
2552		return 1;
2553		}
2554		if (!strncmp(lastParamPtr, "(hd", 3))
2555		lastParamPtr += 3;
2556		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2557
2558		/*
2559		* Second last parameter will decide wether last parameter is
2560		* an IMAGE_DEVICE or INSTALL_DEVICE
2561		*/
2562		while (!isspace(*secLastParamPtr))
2563		secLastParamPtr--;
2564		secLastParamPtr++;
2565
2566		if (secLastParamPtr + 3 > bounds) {
2567		dbgPrintf("secLastParamPtr going over boundary");
2568		fclose(grubConf);
2569		free(line);
2570		return 1;
2571		}
2572		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2573		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2574		secLastParamPtr += 3;
2575		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2576		installDeviceNumber = *secLastParamPtr;
2577		} else {
2578		installDeviceNumber = *lastParamPtr;
2579		}
2580
2581		*devicePtr = malloc(6);
2582		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2583		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2584		fclose(grubConf);
2585		free(line);
2586		return 0;
2587		}
2588
2589		free(line);
2590		fclose(grubConf);
2591		return 1;
2592		}
2593
2594		int grubGetBootFromDeviceMap(const char * device,
2595		char ** bootPtr) {
2596		FILE * deviceMap;
2597		char * line = NULL;
2598		size_t res = 0, len = 0;
2599		char * devicePtr;
2600		char * bounds = NULL;
2601		const char * path;
2602		const static char default_path[] = "/boot/grub/device.map";
2603
2604		if (!device) return 1;
2605		if (!bootPtr) return 1;
2606
2607		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2608		path = default_path;
2609
2610		dbgPrintf("opening grub device.map file from: %s\n", path);
2611		deviceMap = fopen(path, "r");
2612		if (!deviceMap)
2613		return 1;
2614
2615		while ((res = getline(&line, &len, deviceMap)) != -1) {
2616		if (!strncmp(line, "#", 1))
2617		continue;
2618
2619		if (line[res - 1] == '\n')
2620		line[res - 1] = '\0';
2621		else if (len > res)
2622		line[res] = '\0';
2623		else {
2624		line = realloc(line, res + 1);
2625		line[res] = '\0';
2626		}
2627
2628		devicePtr = line;
2629		bounds = line + res;
2630
2631		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2632		devicePtr++;
2633		dbgPrintf("device: %s\n", devicePtr);
2634
2635		if (!strncmp(devicePtr, device, strlen(device))) {
2636		devicePtr += strlen(device);
2637		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2638		devicePtr++;
2639
2640		*bootPtr = strdup(devicePtr);
2641		break;
2642		}
2643		}
2644
2645		free(line);
2646		fclose(deviceMap);
2647		return 0;
2648		}
2649
2650		int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2651		char * grubDevice;
2652
2653		if (suseGrubConfGetInstallDevice(path, &grubDevice))
2654		dbgPrintf("error looking for grub installation device\n");
2655		else
2656		dbgPrintf("grubby installation device: %s\n", grubDevice);
2657
2658		if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2659		dbgPrintf("error looking for grub boot device\n");
2660		else
2661		dbgPrintf("grubby boot device: %s\n", *bootPtr);
2662
2663		free(grubDevice);
2664		return 0;
2665		}
2666
2667		int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2668		/*
2669		* This SuSE grub configuration file at this location is not your average
2670		* grub configuration file, but instead the grub commands used to setup
2671		* grub on that system.
2672		*/
2673		const char * path;
2674		const static char default_path[] = "/etc/grub.conf";
2675
2676		if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2677		path = default_path;
2678
2679		if (!isSuseGrubConf(path)) return 1;
2680
2681		if (lbaPtr) {
2682		*lbaPtr = 0;
2683		if (suseGrubConfGetLba(path, lbaPtr))
2684		return 1;
2685		}
2686
2687		if (bootPtr) {
2688		*bootPtr = NULL;
2689		suseGrubConfGetBoot(path, bootPtr);
2690		}
2691
2692		return 0;
2693	}	}
2694
2695	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
#	Line 1813  int parseSysconfigGrub(int * lbaPtr, cha	Line 2740  int parseSysconfigGrub(int * lbaPtr, cha
2740	}	}
2741
2742	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2743	char * boot;	char * boot = NULL;
2744	int lba;	int lba;
2745
2746	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2747	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2748	if (boot) printf("boot=%s\n", boot);	free(boot);
2749		return;
2750		}
2751		} else {
2752		if (parseSysconfigGrub(&lba, &boot)) {
2753		free(boot);
2754		return;
2755		}
2756		}
2757
2758		if (lba) printf("lba\n");
2759		if (boot) {
2760		printf("boot=%s\n", boot);
2761		free(boot);
2762	}	}
2763	}	}
2764
#	Line 1867  struct singleLine * addLineTmpl(struct s	Line 2807  struct singleLine * addLineTmpl(struct s
2807	{	{
2808	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2809
2810		if (isEfi && cfi == &grub2ConfigType) {
2811		enum lineType_e old = newLine->type;
2812		newLine->type = preferredLineType(newLine->type, cfi);
2813		if (old != newLine->type)
2814		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2815		}
2816
2817	if (val) {	if (val) {
2818	/* override the inherited value with our own.	/* override the inherited value with our own.
2819	* This is a little weak because it only applies to elements[1]	* This is a little weak because it only applies to elements[1]
#	Line 1876  struct singleLine * addLineTmpl(struct s	Line 2823  struct singleLine * addLineTmpl(struct s
2823	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2824
2825	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2826	if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD)) {	if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI|LT_KERNEL_16|LT_INITRD_16)) {
2827	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2828	if (rootspec != NULL) {	if (rootspec != NULL) {
2829	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 1913  struct singleLine *  addLine(struct sing	Line 2860  struct singleLine *  addLine(struct sing
2860	/* NB: This function shouldn't allocate items on the heap, rather on the	/* NB: This function shouldn't allocate items on the heap, rather on the
2861	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2862	*/	*/
2863	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2864	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2865	tmpl.type = type;	tmpl.type = type;
#	Line 2017  void removeLine(struct singleEntry * ent	Line 2963  void removeLine(struct singleEntry * ent
2963	free(line);	free(line);
2964	}	}
2965
	static int isquote(char q)
	{
	if (q == '\'' || q == '\"')
	return 1;
	return 0;
	}
2966	static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)	static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
2967	{	{
2968	struct singleLine newLine = {	struct singleLine newLine = {
#	Line 2254  int updateActualImage(struct grubConfig	Line 3193  int updateActualImage(struct grubConfig
3193	firstElement = 2;	firstElement = 2;
3194
3195	} else {	} else {
3196	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3197	if (!line) {	if (!line) {
3198	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3199	continue;	continue;
#	Line 2410  int updateImage(struct grubConfig * cfg,	Line 3349  int updateImage(struct grubConfig * cfg,
3349	return rc;	return rc;
3350	}	}
3351
3352		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3353		const char * image, const char * prefix, const char * initrd,
3354		const char * title) {
3355		struct singleEntry * entry;
3356		struct singleLine * line, * kernelLine, *endLine = NULL;
3357		int index = 0;
3358
3359		if (!image) return 0;
3360
3361		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3362		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3363		if (!kernelLine) continue;
3364
3365		/* if title is supplied, the entry's title must match it. */
3366		if (title) {
3367		char *linetitle;
3368
3369		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3370		if (!line)
3371		continue;
3372
3373		linetitle = extractTitle(cfg, line);
3374		if (!linetitle)
3375		continue;
3376		if (strcmp(title, linetitle)) {
3377		free(linetitle);
3378		continue;
3379		}
3380		free(linetitle);
3381		}
3382
3383		if (prefix) {
3384		int prefixLen = strlen(prefix);
3385		if (!strncmp(initrd, prefix, prefixLen))
3386		initrd += prefixLen;
3387		}
3388		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3389		if (endLine)
3390		removeLine(entry, endLine);
3391		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3392		kernelLine->indent, initrd);
3393		if (!line)
3394		return 1;
3395		if (endLine) {
3396		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3397		if (!line)
3398		return 1;
3399		}
3400
3401		break;
3402		}
3403
3404		return 0;
3405		}
3406
3407	int updateInitrd(struct grubConfig * cfg, const char * image,	int updateInitrd(struct grubConfig * cfg, const char * image,
3408	const char * prefix, const char * initrd) {	const char * prefix, const char * initrd, const char * title) {
3409	struct singleEntry * entry;	struct singleEntry * entry;
3410	struct singleLine * line, * kernelLine, *endLine = NULL;	struct singleLine * line, * kernelLine, *endLine = NULL;
3411	int index = 0;	int index = 0;
#	Line 2419  int updateInitrd(struct grubConfig * cfg	Line 3413  int updateInitrd(struct grubConfig * cfg
3413	if (!image) return 0;	if (!image) return 0;
3414
3415	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3416	kernelLine = getLineByType(LT_KERNEL, entry->lines);	kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3417	if (!kernelLine) continue;	if (!kernelLine) continue;
3418
3419	line = getLineByType(LT_INITRD, entry->lines);	/* if title is supplied, the entry's title must match it. */
3420		if (title) {
3421		char *linetitle;
3422
3423		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3424		if (!line)
3425		continue;
3426
3427		linetitle = extractTitle(cfg, line);
3428		if (!linetitle)
3429		continue;
3430		if (strcmp(title, linetitle)) {
3431		free(linetitle);
3432		continue;
3433		}
3434		free(linetitle);
3435		}
3436
3437		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3438	if (line)	if (line)
3439	removeLine(entry, line);	removeLine(entry, line);
3440	if (prefix) {	if (prefix) {
#	Line 2433  int updateInitrd(struct grubConfig * cfg	Line 3445  int updateInitrd(struct grubConfig * cfg
3445	endLine = getLineByType(LT_ENTRY_END, entry->lines);	endLine = getLineByType(LT_ENTRY_END, entry->lines);
3446	if (endLine)	if (endLine)
3447	removeLine(entry, endLine);	removeLine(entry, endLine);
3448	line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);	enum lineType_e lt;
3449		switch(kernelLine->type) {
3450		case LT_KERNEL:
3451		lt = LT_INITRD;
3452		break;
3453		case LT_KERNEL_EFI:
3454		lt = LT_INITRD_EFI;
3455		break;
3456		case LT_KERNEL_16:
3457		lt = LT_INITRD_16;
3458		break;
3459		default:
3460		lt = preferredLineType(LT_INITRD, cfg->cfi);
3461		}
3462		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3463	if (!line)	if (!line)
3464	return 1;	return 1;
3465	if (endLine) {	if (endLine) {
#	Line 2639  int checkForGrub(struct grubConfig * con	Line 3665  int checkForGrub(struct grubConfig * con
3665	int fd;	int fd;
3666	unsigned char bootSect[512];	unsigned char bootSect[512];
3667	char * boot;	char * boot;
3668		int onSuse = isSuseSystem();
3669
3670	if (parseSysconfigGrub(NULL, &boot))
3671	return 0;	if (onSuse) {
3672		if (parseSuseGrubConf(NULL, &boot))
3673		return 0;
3674		} else {
3675		if (parseSysconfigGrub(NULL, &boot))
3676		return 0;
3677		}
3678
3679	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3680	if (!boot)	if (!boot)
#	Line 2660  int checkForGrub(struct grubConfig * con	Line 3693  int checkForGrub(struct grubConfig * con
3693	}	}
3694	close(fd);	close(fd);
3695
3696		/* The more elaborate checks do not work on SuSE. The checks done
3697		* seem to be reasonble (at least for now), so just return success
3698		*/
3699		if (onSuse)
3700		return 2;
3701
3702	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3703	}	}
3704
#	Line 2693  int checkForExtLinux(struct grubConfig *	Line 3732  int checkForExtLinux(struct grubConfig *
3732	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3733	}	}
3734
3735		int checkForYaboot(struct grubConfig * config) {
3736		/*
3737		* This is a simplistic check that we consider good enough for own puporses
3738		*
3739		* If we were to properly check if yaboot is *installed* we'd need to:
3740		* 1) get the system boot device (LT_BOOT)
3741		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3742		*    the content on the boot device
3743		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3744		* 4) check again if binary and boot device contents match
3745		*/
3746		if (!access("/etc/yaboot.conf", R_OK))
3747		return 2;
3748
3749		return 1;
3750		}
3751
3752		int checkForElilo(struct grubConfig * config) {
3753		if (!access("/etc/elilo.conf", R_OK))
3754		return 2;
3755
3756		return 1;
3757		}
3758
3759	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3760	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3761
#	Line 2707  static char * getRootSpecifier(char * st	Line 3770  static char * getRootSpecifier(char * st
3770	static char * getInitrdVal(struct grubConfig * config,	static char * getInitrdVal(struct grubConfig * config,
3771	const char * prefix, struct singleLine *tmplLine,	const char * prefix, struct singleLine *tmplLine,
3772	const char * newKernelInitrd,	const char * newKernelInitrd,
3773	char ** extraInitrds, int extraInitrdCount)	const char ** extraInitrds, int extraInitrdCount)
3774	{	{
3775	char *initrdVal, *end;	char *initrdVal, *end;
3776	int i;	int i;
#	Line 2752  static char * getInitrdVal(struct grubCo	Line 3815  static char * getInitrdVal(struct grubCo
3815
3816	int addNewKernel(struct grubConfig * config, struct singleEntry * template,	int addNewKernel(struct grubConfig * config, struct singleEntry * template,
3817	const char * prefix,	const char * prefix,
3818	char * newKernelPath, char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3819	char * newKernelArgs, char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3820	char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3821	char * newMBKernel, char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs,
3822		const char * newDevTreePath) {
3823	struct singleEntry * new;	struct singleEntry * new;
3824	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3825	int needs;	int needs;
#	Line 2796  int addNewKernel(struct grubConfig * con	Line 3860  int addNewKernel(struct grubConfig * con
3860	needs |= NEED_MB;	needs |= NEED_MB;
3861	new->multiboot = 1;	new->multiboot = 1;
3862	}	}
3863		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3864		needs |= NEED_DEVTREE;
3865
3866	if (template) {	if (template) {
3867	for (masterLine = template->lines;	for (masterLine = template->lines;
#	Line 2809  int addNewKernel(struct grubConfig * con	Line 3875  int addNewKernel(struct grubConfig * con
3875	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3876	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3877
3878	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3879	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3880	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3881	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 2887  int addNewKernel(struct grubConfig * con	Line 3952  int addNewKernel(struct grubConfig * con
3952	/* template is multi but new is not,	/* template is multi but new is not,
3953	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3954	*/	*/
3955	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3956	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3957	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3958	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3959		config->cfi)->key);
3960	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3961	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3962		config->cfi);
3963	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3964	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3965	char *initrdVal;	char *initrdVal;
3966	/* template is multi but new is not,	/* template is multi but new is not,
3967	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3968	*/	*/
3969	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3970	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3971	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3972	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3973		config->cfi)->key);
3974	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3975	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3976	free(initrdVal);	free(initrdVal);
3977	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3978	}	}
3979
3980	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3981	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3982	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3983	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 2961  int addNewKernel(struct grubConfig * con	Line 4028  int addNewKernel(struct grubConfig * con
4028	}	}
4029	} else if (tmplLine->type == LT_ECHO) {	} else if (tmplLine->type == LT_ECHO) {
4030	requote(tmplLine, config->cfi);	requote(tmplLine, config->cfi);
4031		static const char *prefix = "'Loading ";
4032	if (tmplLine->numElements > 1 &&	if (tmplLine->numElements > 1 &&
4033	strstr(tmplLine->elements[1].item, "'Loading Linux ")) {	strstr(tmplLine->elements[1].item, prefix) &&
4034	char *prefix = "'Loading ";	masterLine->next &&
4035		iskernel(masterLine->next->type)) {
4036	char *newTitle = malloc(strlen(prefix) +	char *newTitle = malloc(strlen(prefix) +
4037	strlen(newKernelTitle) + 2);	strlen(newKernelTitle) + 2);
4038
#	Line 2978  int addNewKernel(struct grubConfig * con	Line 4047  int addNewKernel(struct grubConfig * con
4047	newLine = addLineTmpl(new, tmplLine, newLine, NULL,	newLine = addLineTmpl(new, tmplLine, newLine, NULL,
4048	config->cfi);	config->cfi);
4049	}	}
4050		} else if (tmplLine->type == LT_DEVTREE &&
4051		tmplLine->numElements == 2 && newDevTreePath) {
4052		newLine = addLineTmpl(new, tmplLine, newLine,
4053		newDevTreePath + strlen(prefix),
4054		config->cfi);
4055		needs &= ~NEED_DEVTREE;
4056		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
4057		const char *ndtp = newDevTreePath;
4058		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
4059		ndtp += strlen(prefix);
4060		newLine = addLine(new, config->cfi, LT_DEVTREE,
4061		config->secondaryIndent,
4062		ndtp);
4063		needs &= ~NEED_DEVTREE;
4064		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
4065	} else {	} else {
4066	/* pass through other lines from the template */	/* pass through other lines from the template */
4067	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
#	Line 2990  int addNewKernel(struct grubConfig * con	Line 4074  int addNewKernel(struct grubConfig * con
4074	*/	*/
4075	switch (config->cfi->entryStart) {	switch (config->cfi->entryStart) {
4076	case LT_KERNEL:	case LT_KERNEL:
4077		case LT_KERNEL_EFI:
4078		case LT_KERNEL_16:
4079	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
4080	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
4081	} else {	} else {
4082	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
4083		preferredLineType(LT_KERNEL, config->cfi),
4084	config->primaryIndent,	config->primaryIndent,
4085	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4086	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3050  int addNewKernel(struct grubConfig * con	Line 4137  int addNewKernel(struct grubConfig * con
4137	}	}
4138	}	}
4139
4140		struct singleLine *endLine = NULL;
4141		endLine = getLineByType(LT_ENTRY_END, new->lines);
4142		if (endLine) {
4143		removeLine(new, endLine);
4144		needs |= NEED_END;
4145		}
4146
4147	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4148	* weren't present in the template, or in the case of no template,	* weren't present in the template, or in the case of no template,
4149	* all the lines following the entryStart.	* all the lines following the entryStart.
#	Line 3069  int addNewKernel(struct grubConfig * con	Line 4163  int addNewKernel(struct grubConfig * con
4163	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
4164	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4165	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4166	config->cfi)) ?	config->cfi))
4167	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
4168		: preferredLineType(LT_KERNEL, config->cfi),
4169	config->secondaryIndent,	config->secondaryIndent,
4170	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4171	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3086  int addNewKernel(struct grubConfig * con	Line 4181  int addNewKernel(struct grubConfig * con
4181	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4182	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4183	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4184	config->cfi)) ?	config->cfi))
4185	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
4186		: preferredLineType(LT_INITRD, config->cfi),
4187	config->secondaryIndent,	config->secondaryIndent,
4188	initrdVal);	initrdVal);
4189	free(initrdVal);	free(initrdVal);
4190	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4191	}	}
4192		if (needs & NEED_DEVTREE) {
4193		newLine = addLine(new, config->cfi, LT_DEVTREE,
4194		config->secondaryIndent,
4195		newDevTreePath);
4196		needs &= ~NEED_DEVTREE;
4197		}
4198
4199		/* NEEDS_END must be last on bootloaders that need it... */
4200	if (needs & NEED_END) {	if (needs & NEED_END) {
4201	newLine = addLine(new, config->cfi, LT_ENTRY_END,	newLine = addLine(new, config->cfi, LT_ENTRY_END,
4202	config->secondaryIndent, NULL);	config->secondaryIndent, NULL);
#	Line 3110  int addNewKernel(struct grubConfig * con	Line 4214  int addNewKernel(struct grubConfig * con
4214	return 0;	return 0;
4215	}	}
4216
	static void traceback(int signum)
	{
	void *array[40];
	size_t size;
	signal(SIGSEGV, SIG_DFL);
	memset(array, '\0', sizeof (array));
	size = backtrace(array, 40);
	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",
	(unsigned long)size);
	backtrace_symbols_fd(array, size, STDERR_FILENO);
	exit(1);
	}
4217	int main(int argc, const char ** argv) {	int main(int argc, const char ** argv) {
4218	poptContext optCon;	poptContext optCon;
4219	const char * grubConfig = NULL;	const char * grubConfig = NULL;
#	Line 3144  int main(int argc, const char ** argv) {	Line 4233  int main(int argc, const char ** argv) {
4233	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4234	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4235	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4236	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4237	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4238	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4239	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 3154  int main(int argc, const char ** argv) {	Line 4243  int main(int argc, const char ** argv) {
4243	char * removeArgs = NULL;	char * removeArgs = NULL;
4244	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4245	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4246		char * envPath = NULL;
4247	const char * chptr = NULL;	const char * chptr = NULL;
4248	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4249	struct grubConfig * config;	struct grubConfig * config;
#	Line 3162  int main(int argc, const char ** argv) {	Line 4252  int main(int argc, const char ** argv) {
4252	int displayDefault = 0;	int displayDefault = 0;
4253	int displayDefaultIndex = 0;	int displayDefaultIndex = 0;
4254	int displayDefaultTitle = 0;	int displayDefaultTitle = 0;
4255		int defaultIndex = -1;
4256	struct poptOption options[] = {	struct poptOption options[] = {
4257	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4258	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 3179  int main(int argc, const char ** argv) {	Line 4270  int main(int argc, const char ** argv) {
4270	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4271	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4272	_("bootfs") },	_("bootfs") },
4273	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4274	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4275	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4276	#endif	#endif
4277	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4278	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
#	Line 3192  int main(int argc, const char ** argv) {	Line 4283  int main(int argc, const char ** argv) {
4283	"the kernel referenced by the default image does not exist, "	"the kernel referenced by the default image does not exist, "
4284	"the first linux entry whose kernel does exist is used as the "	"the first linux entry whose kernel does exist is used as the "
4285	"template"), NULL },	"template"), NULL },
4286		{ "debug", 0, 0, &debug, 0,
4287		_("print debugging information for failures") },
4288	{ "default-kernel", 0, 0, &displayDefault, 0,	{ "default-kernel", 0, 0, &displayDefault, 0,
4289	_("display the path of the default kernel") },	_("display the path of the default kernel") },
4290	{ "default-index", 0, 0, &displayDefaultIndex, 0,	{ "default-index", 0, 0, &displayDefaultIndex, 0,
4291	_("display the index of the default kernel") },	_("display the index of the default kernel") },
4292	{ "default-title", 0, 0, &displayDefaultTitle, 0,	{ "default-title", 0, 0, &displayDefaultTitle, 0,
4293	_("display the title of the default kernel") },	_("display the title of the default kernel") },
4294		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4295		_("device tree file for new stanza"), _("dtb-path") },
4296		{ "devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4297		_("device tree directory for new stanza"), _("dtb-path") },
4298	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4299	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4300		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4301		_("force grub2 stanzas to use efi") },
4302		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4303		_("path for environment data"),
4304		_("path") },
4305	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4306	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4307	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
#	Line 3212  int main(int argc, const char ** argv) {	Line 4314  int main(int argc, const char ** argv) {
4314	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4315	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4316	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4317	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4318	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4319	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4320	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 3232  int main(int argc, const char ** argv) {	Line 4334  int main(int argc, const char ** argv) {
4334	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4335	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4336	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4337		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4338		_("make the given entry index the default entry"),
4339		_("entry-index") },
4340	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4341	_("configure silo bootloader") },	_("configure silo bootloader") },
4342	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 3251  int main(int argc, const char ** argv) {	Line 4356  int main(int argc, const char ** argv) {
4356
4357	useextlinuxmenu=0;	useextlinuxmenu=0;
4358
4359	signal(SIGSEGV, traceback);	int i = 0;
4360		for (int j = 1; j < argc; j++)
4361		i += strlen(argv[j]) + 1;
4362		saved_command_line = malloc(i);
4363		if (!saved_command_line) {
4364		fprintf(stderr, "grubby: %m\n");
4365		exit(1);
4366		}
4367		saved_command_line[0] = '\0';
4368		for (int j = 1; j < argc; j++) {
4369		strcat(saved_command_line, argv[j]);
4370		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4371		}
4372
4373	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4374	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
#	Line 3296  int main(int argc, const char ** argv) {	Line 4413  int main(int argc, const char ** argv) {
4413	return 1;	return 1;
4414	} else if (configureGrub2) {	} else if (configureGrub2) {
4415	cfi = &grub2ConfigType;	cfi = &grub2ConfigType;
4416		if (envPath)
4417		cfi->envFile = envPath;
4418	} else if (configureLilo) {	} else if (configureLilo) {
4419	cfi = &liloConfigType;	cfi = &liloConfigType;
4420	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 3314  int main(int argc, const char ** argv) {	Line 4433  int main(int argc, const char ** argv) {
4433	}	}
4434
4435	if (!cfi) {	if (!cfi) {
4436		if (grub2FindConfig(&grub2ConfigType)) {
4437		cfi = &grub2ConfigType;
4438		if (envPath)
4439		cfi->envFile = envPath;
4440		} else
4441	#ifdef __ia64__	#ifdef __ia64__
4442	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4443	#elif __powerpc__	#elif __powerpc__
4444	cfi = &yabootConfigType;	cfi = &yabootConfigType;
4445	#elif __sparc__	#elif __sparc__
4446	cfi = &siloConfigType;	cfi = &siloConfigType;
4447	#elif __s390__	#elif __s390__
4448	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4449	#elif __s390x__	#elif __s390x__
4450	cfi = &ziplConfigtype;	cfi = &ziplConfigtype;
4451	#else	#else
	if (grub2FindConfig(&grub2ConfigType))
	cfi = &grub2ConfigType;
	else
4452	cfi = &grubConfigType;	cfi = &grubConfigType;
4453	#endif	#endif
4454	}	}
#	Line 3339  int main(int argc, const char ** argv) {	Line 4460  int main(int argc, const char ** argv) {
4460	grubConfig = cfi->defaultConfig;	grubConfig = cfi->defaultConfig;
4461	}	}
4462
4463	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4464	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4465	defaultKernel || displayDefaultIndex || displayDefaultTitle)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4466		(defaultIndex >= 0))) {
4467	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4468	"specified option"));	"specified option"));
4469	return 1;	return 1;
4470	}	}
4471
4472	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4473	removeKernelPath)) {	removeKernelPath)) {
4474	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4475	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 3357  int main(int argc, const char ** argv) {	Line 4479  int main(int argc, const char ** argv) {
4479	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4480	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4481	return 1;	return 1;
4482	} else if (!newKernelPath && (newKernelTitle  || copyDefault ||	} else if (!newKernelPath && (copyDefault ||
4483	(newKernelInitrd && !updateKernelPath)||	(newKernelInitrd && !updateKernelPath)||
4484	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4485	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
#	Line 3383  int main(int argc, const char ** argv) {	Line 4505  int main(int argc, const char ** argv) {
4505	makeDefault = 1;	makeDefault = 1;
4506	defaultKernel = NULL;	defaultKernel = NULL;
4507	}	}
4508		else if (defaultKernel && (defaultIndex >= 0)) {
4509		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4510		"may not be used together\n"));
4511		return 1;
4512		}
4513
4514	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4515	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
#	Line 3391  int main(int argc, const char ** argv) {	Line 4518  int main(int argc, const char ** argv) {
4518	}	}
4519
4520	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4521	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4522	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4523		&& (defaultIndex == -1)) {
4524	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4525	return 1;	return 1;
4526	}	}
#	Line 3419  int main(int argc, const char ** argv) {	Line 4547  int main(int argc, const char ** argv) {
4547	}	}
4548
4549	if (bootloaderProbe) {	if (bootloaderProbe) {
4550	int lrc = 0, grc = 0, gr2c = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4551	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4552
4553	const char *grub2config = grub2FindConfig(&grub2ConfigType);	const char *grub2config = grub2FindConfig(&grub2ConfigType);
4554	if (grub2config) {	if (grub2config) {
#	Line 3448  int main(int argc, const char ** argv) {	Line 4576  int main(int argc, const char ** argv) {
4576	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4577	}	}
4578
4579		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4580		econfig = readConfig(eliloConfigType.defaultConfig,
4581		&eliloConfigType);
4582		if (!econfig)
4583		erc = 1;
4584		else
4585		erc = checkForElilo(econfig);
4586		}
4587
4588	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4589	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4590	if (!lconfig)	if (!lconfig)
4591	erc = 1;	extrc = 1;
4592	else	else
4593	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4594	}	}
4595
4596	if (lrc == 1 || grc == 1 || gr2c == 1) return 1;
4597		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4598		yconfig = readConfig(yabootConfigType.defaultConfig,
4599		&yabootConfigType);
4600		if (!yconfig)
4601		yrc = 1;
4602		else
4603		yrc = checkForYaboot(yconfig);
4604		}
4605
4606		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4607		erc == 1)
4608		return 1;
4609
4610	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4611	if (gr2c == 2) printf("grub2\n");	if (gr2c == 2) printf("grub2\n");
4612	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4613	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4614		if (yrc == 2) printf("yaboot\n");
4615		if (erc == 2) printf("elilo\n");
4616
4617	return 0;	return 0;
4618	}	}
4619
4620		if (grubConfig == NULL) {
4621		printf("Could not find bootloader configuration file.\n");
4622		exit(1);
4623		}
4624
4625	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4626	if (!config) return 1;	if (!config) return 1;
4627
#	Line 3475  int main(int argc, const char ** argv) {	Line 4631  int main(int argc, const char ** argv) {
4631	char * rootspec;	char * rootspec;
4632
4633	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4634		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4635		cfi->defaultIsSaved)
4636		config->defaultImage = 0;
4637	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4638	if (!entry) return 0;	if (!entry) return 0;
4639	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4640
4641	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4642	if (!line) return 0;	if (!line) return 0;
4643
4644	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3492  int main(int argc, const char ** argv) {	Line 4651  int main(int argc, const char ** argv) {
4651	struct singleLine * line;	struct singleLine * line;
4652	struct singleEntry * entry;	struct singleEntry * entry;
4653
4654	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1)
4655		return 0;
4656		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4657		cfi->defaultIsSaved)
4658		config->defaultImage = 0;
4659	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4660	if (!entry) return 0;	if (!entry)
4661		return 0;
4662
4663	if (!configureGrub2) {	if (!configureGrub2) {
4664	line = getLineByType(LT_TITLE, entry->lines);	char *title;
4665	if (!line) return 0;	line = getLineByType(LT_TITLE, entry->lines);
4666	printf("%s\n", line->elements[1].item);	if (!line)
4667		return 0;
4668		title = extractTitle(config, line);
4669		if (!title)
4670		return 0;
4671		printf("%s\n", title);
4672		free(title);
4673	} else {	} else {
4674	int i;	char * title;
	size_t len;
	char * start;
	char * tmp;
	dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
	line = getLineByType(LT_MENUENTRY, entry->lines);
	if (!line) return 0;
	for (i = 0; i < line->numElements; i++) {
	if (!strcmp(line->elements[i].item, "menuentry"))
	continue;
4675
4676	if (*line->elements[i].item == '\'')	dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
4677	start = line->elements[i].item + 1;	line = getLineByType(LT_MENUENTRY, entry->lines);
4678	else	if (!line)
4679	start = line->elements[i].item;	return 0;
4680		title = grub2ExtractTitle(line);
4681	len = strlen(start);	if (title)
4682	if (*(start + len - 1) == '\'') {	printf("%s\n", title);
	tmp = strdup(start);
	*(tmp + len - 1) = '\0';
	printf("%s", tmp);
	free(tmp);
	break;
	} else {
	printf("%s ", start);
	}
	}
	printf("\n");
4683	}	}
4684	return 0;	return 0;
4685
4686	} else if (displayDefaultIndex) {	} else if (displayDefaultIndex) {
4687	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4688		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4689		cfi->defaultIsSaved)
4690		config->defaultImage = 0;
4691	printf("%i\n", config->defaultImage);	printf("%i\n", config->defaultImage);
4692		return 0;
4693
4694	} else if (kernelInfo)	} else if (kernelInfo)
4695	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
#	Line 3551  int main(int argc, const char ** argv) {	Line 4702  int main(int argc, const char ** argv) {
4702	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4703	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4704	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4705	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4706	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4707	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4708	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4709	if (updateKernelPath && newKernelInitrd) {	if (updateKernelPath && newKernelInitrd) {
4710	if (updateInitrd(config, updateKernelPath, bootPrefix,	if (newMBKernel) {
4711	newKernelInitrd)) return 1;	if (addMBInitrd(config, newMBKernel, updateKernelPath,
4712		bootPrefix, newKernelInitrd,
4713		newKernelTitle))
4714		return 1;
4715		} else {
4716		if (updateInitrd(config, updateKernelPath, bootPrefix,
4717		newKernelInitrd, newKernelTitle))
4718		return 1;
4719		}
4720	}	}
4721	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4722	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4723	extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4724	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4725
4726
4727	if (numEntries(config) == 0) {	if (numEntries(config) == 0) {

---

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

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