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

Parent Directory | Revision Log | Patch

	revision 1751 by niro, Sat Feb 18 01:10:10 2012 UTC	revision 2971 by niro, Thu Jun 30 10:06:57 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 56  int debug = 0; /* Currently just for tem	Line 58  int debug = 0; /* Currently just for tem
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 82  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 111  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
#	Line 128  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 148  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 164  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 205  struct keywordTypes grub2Keywords[] = {	Line 233  struct keywordTypes grub2Keywords[] = {
233	{ "default",    LT_DEFAULT,     ' ' },	{ "default",    LT_DEFAULT,     ' ' },
234	{ "fallback",   LT_FALLBACK,    ' ' },	{ "fallback",   LT_FALLBACK,    ' ' },
235	{ "linux",      LT_KERNEL,      ' ' },	{ "linux",      LT_KERNEL,      ' ' },
236		{ "linuxefi",   LT_KERNEL_EFI,  ' ' },
237		{ "linux16",    LT_KERNEL_16,   ' ' },
238	{ "initrd",     LT_INITRD,      ' ', ' ' },	{ "initrd",     LT_INITRD,      ' ', ' ' },
239		{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
240		{ "initrd16",   LT_INITRD_16,   ' ', ' ' },
241	{ "module",     LT_MBMODULE,    ' ' },	{ "module",     LT_MBMODULE,    ' ' },
242	{ "kernel",     LT_HYPER,       ' ' },	{ "kernel",     LT_HYPER,       ' ' },
243		{ "devicetree", LT_DEVTREE,  ' ' },
244	{ NULL, 0, 0 },	{ NULL, 0, 0 },
245	};	};
246
#	Line 219  const char *grub2FindConfig(struct confi	Line 252  const char *grub2FindConfig(struct confi
252	};	};
253	static int i = -1;	static int i = -1;
254	static const char *grub_cfg = "/boot/grub/grub.cfg";	static const char *grub_cfg = "/boot/grub/grub.cfg";
255		int rc = -1;
256
257	if (i == -1) {	if (i == -1) {
258	for (i = 0; configFiles[i] != NULL; i++) {	for (i = 0; configFiles[i] != NULL; i++) {
259	dbgPrintf("Checking \"%s\": ", configFiles[i]);	dbgPrintf("Checking \"%s\": ", configFiles[i]);
260	if (!access(configFiles[i], R_OK)) {	if ((rc = access(configFiles[i], R_OK))) {
261		if (errno == EACCES) {
262		printf("Unable to access bootloader configuration file "
263		"\"%s\": %m\n", configFiles[i]);
264		exit(1);
265		}
266		continue;
267		} else {
268	dbgPrintf("found\n");	dbgPrintf("found\n");
269	return configFiles[i];	return configFiles[i];
270	}	}
#	Line 242  const char *grub2FindConfig(struct confi	Line 283  const char *grub2FindConfig(struct confi
283	return configFiles[i];	return configFiles[i];
284	}	}
285
286		/* kind of hacky.  It'll give the first 1024 bytes, ish. */
287		static char *grub2GetEnv(struct configFileInfo *info, char *name)
288		{
289		static char buf[1025];
290		char *s = NULL;
291		char *ret = NULL;
292		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
293		int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
294
295		if (rc < 0)
296		return NULL;
297
298		FILE *f = popen(s, "r");
299		if (!f)
300		goto out;
301
302		memset(buf, '\0', sizeof (buf));
303		ret = fgets(buf, 1024, f);
304		pclose(f);
305
306		if (ret) {
307		ret += strlen(name) + 1;
308		ret[strlen(ret) - 1] = '\0';
309		}
310		dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
311		out:
312		free(s);
313		return ret;
314		}
315
316		static int sPopCount(const char *s, const char *c)
317		{
318		int ret = 0;
319		if (!s)
320		return -1;
321		for (int i = 0; s[i] != '\0'; i++)
322		for (int j = 0; c[j] != '\0'; j++)
323		if (s[i] == c[j])
324		ret++;
325		return ret;
326		}
327
328		static char *shellEscape(const char *s)
329		{
330		int l = strlen(s) + sPopCount(s, "'") * 2;
331
332		char *ret = calloc(l+1, sizeof (*ret));
333		if (!ret)
334		return NULL;
335		for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
336		if (s[i] == '\'')
337		ret[j++] = '\\';
338		ret[j] = s[i];
339		}
340		return ret;
341		}
342
343		static void unquote(char *s)
344		{
345		int l = strlen(s);
346
347		if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
348		memmove(s, s+1, l-2);
349		s[l-2] = '\0';
350		}
351		}
352
353		static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
354		{
355		char *s = NULL;
356		int rc = 0;
357		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
358
359		unquote(value);
360		value = shellEscape(value);
361		if (!value)
362		return -1;
363
364		rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
365		free(value);
366		if (rc <0)
367		return -1;
368
369		dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
370		rc = system(s);
371		free(s);
372		return rc;
373		}
374
375		/* this is a gigantic hack to avoid clobbering grub2 variables... */
376		static int is_special_grub2_variable(const char *name)
377		{
378		if (!strcmp(name,"\"${next_entry}\""))
379		return 1;
380		if (!strcmp(name,"\"${prev_saved_entry}\""))
381		return 1;
382		return 0;
383		}
384
385	int sizeOfSingleLine(struct singleLine * line) {	int sizeOfSingleLine(struct singleLine * line) {
	int i;
386	int count = 0;	int count = 0;
387
388	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
389	int indentSize = 0;	int indentSize = 0;
390
391	count = count + strlen(line->elements[i].item);	count = count + strlen(line->elements[i].item);
#	Line 265  int sizeOfSingleLine(struct singleLine *	Line 404  int sizeOfSingleLine(struct singleLine *
404	return count;	return count;
405	}	}
406
407		static int isquote(char q)
408		{
409		if (q == '\'' || q == '\"')
410		return 1;
411		return 0;
412		}
413
414		static int iskernel(enum lineType_e type) {
415		return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
416		}
417
418		static int isinitrd(enum lineType_e type) {
419		return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
420		}
421
422	char *grub2ExtractTitle(struct singleLine * line) {	char *grub2ExtractTitle(struct singleLine * line) {
423	char * current;	char * current;
424	char * current_indent;	char * current_indent;
#	Line 281  char *grub2ExtractTitle(struct singleLin	Line 435  char *grub2ExtractTitle(struct singleLin
435	current_len = strlen(current);	current_len = strlen(current);
436
437	/* if second word is quoted, strip the quotes and return single word */	/* if second word is quoted, strip the quotes and return single word */
438	if ((*current == '\'') && (*(current + current_len - 1) == '\'')) {	if (isquote(*current) && isquote(current[current_len - 1])) {
439	char *tmp;	char *tmp;
440
441	tmp = strdup(current);	tmp = strdup(current);
442	*(tmp + current_len - 1) = '\0';	*(tmp + current_len - 1) = '\0';
443	return ++tmp;	return ++tmp;
444	}	}
445
446	/* if no quotes, return second word verbatim */	/* if no quotes, return second word verbatim */
447	if (*current != '\'') {	if (!isquote(*current))
448	return current;	return current;
	}
449
450	/* second element start with a quote, so we have to find the element	/* second element start with a quote, so we have to find the element
451	* whose last character is also quote (assuming it's the closing one) */	* whose last character is also quote (assuming it's the closing one) */
452	if (*current == '\'') {	int resultMaxSize;
453	int resultMaxSize;	char * result;
454	char * result;
455		resultMaxSize = sizeOfSingleLine(line);
456	resultMaxSize = sizeOfSingleLine(line);	result = malloc(resultMaxSize);
457	result = malloc(resultMaxSize);	snprintf(result, resultMaxSize, "%s", ++current);
458	snprintf(result, resultMaxSize, "%s", ++current);
459		i++;
460	i++;	for (; i < line->numElements; ++i) {
	for (; i < line->numElements; ++i) {
461	current = line->elements[i].item;	current = line->elements[i].item;
462	current_len = strlen(current);	current_len = strlen(current);
463	current_indent = line->elements[i].indent;	current_indent = line->elements[i].indent;
464	current_indent_len = strlen(current_indent);	current_indent_len = strlen(current_indent);
465
466	strncat(result, current_indent, current_indent_len);	strncat(result, current_indent, current_indent_len);
467	if (*(current + current_len - 1) != '\'') {	if (!isquote(current[current_len-1])) {
468	strncat(result, current, current_len);	strncat(result, current, current_len);
469	} else {	} else {
470	strncat(result, current, current_len - 1);	strncat(result, current, current_len - 1);
471	break;	break;
472	}	}
	}
	return result;
473	}	}
474		return result;
	return NULL;
475	}	}
476
477	struct configFileInfo grub2ConfigType = {	struct configFileInfo grub2ConfigType = {
478	.findConfig = grub2FindConfig,	.findConfig = grub2FindConfig,
479		.getEnv = grub2GetEnv,
480		.setEnv = grub2SetEnv,
481	.keywords = grub2Keywords,	.keywords = grub2Keywords,
482	.defaultIsIndex = 1,	.defaultIsIndex = 1,
483	.defaultSupportSaved = 1,	.defaultSupportSaved = 1,
#	Line 431  struct keywordTypes extlinuxKeywords[] =	Line 582  struct keywordTypes extlinuxKeywords[] =
582	{ "initrd",    LT_INITRD,      ' ', ',' },	{ "initrd",    LT_INITRD,      ' ', ',' },
583	{ "append",    LT_KERNELARGS,  ' ' },	{ "append",    LT_KERNELARGS,  ' ' },
584	{ "prompt",     LT_UNKNOWN,     ' ' },	{ "prompt",     LT_UNKNOWN,     ' ' },
585		{ "fdt",        LT_DEVTREE,     ' ' },
586	{ NULL,    0, 0 },	{ NULL,    0, 0 },
587	};	};
588	int useextlinuxmenu;	int useextlinuxmenu;
#	Line 481  struct configFileInfo ziplConfigType = {	Line 633  struct configFileInfo ziplConfigType = {
633	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
634	.defaultConfig = "/boot/extlinux/extlinux.conf",	.defaultConfig = "/boot/extlinux/extlinux.conf",
635	.keywords = extlinuxKeywords,	.keywords = extlinuxKeywords,
636		.caseInsensitive = 1,
637	.entryStart = LT_TITLE,	.entryStart = LT_TITLE,
638	.needsBootPrefix = 1,	.needsBootPrefix = 1,
639	.maxTitleLength = 255,	.maxTitleLength = 255,
640	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
641		.defaultIsUnquoted = 1,
642	};	};
643
644	struct grubConfig {	struct grubConfig {
#	Line 505  struct singleEntry * findEntryByIndex(st	Line 659  struct singleEntry * findEntryByIndex(st
659	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
660	const char * path, const char * prefix,	const char * path, const char * prefix,
661	int * index);	int * index);
662		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
663		int * index);
664	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
665	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
666	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 569  static char * sdupprintf(const char *for	Line 725  static char * sdupprintf(const char *for
725	return buf;	return buf;
726	}	}
727
728		static enum lineType_e preferredLineType(enum lineType_e type,
729		struct configFileInfo *cfi) {
730		if (isEfi && cfi == &grub2ConfigType) {
731		switch (type) {
732		case LT_KERNEL:
733		return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
734		case LT_INITRD:
735		return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
736		default:
737		return type;
738		}
739		#if defined(__i386__) || defined(__x86_64__)
740		} else if (cfi == &grub2ConfigType) {
741		switch (type) {
742		case LT_KERNEL:
743		return LT_KERNEL_16;
744		case LT_INITRD:
745		return LT_INITRD_16;
746		default:
747		return type;
748		}
749		#endif
750		}
751		return type;
752		}
753
754	static struct keywordTypes * getKeywordByType(enum lineType_e type,	static struct keywordTypes * getKeywordByType(enum lineType_e type,
755	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
756	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
	for (kw = cfi->keywords; kw->key; kw++) {
757	if (kw->type == type)	if (kw->type == type)
758	return kw;	return kw;
759	}	}
#	Line 602  static char * getuuidbydev(char *device)	Line 783  static char * getuuidbydev(char *device)
783
784	static enum lineType_e getTypeByKeyword(char * keyword,	static enum lineType_e getTypeByKeyword(char * keyword,
785	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
786	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
787	for (kw = cfi->keywords; kw->key; kw++) {	if (cfi->caseInsensitive) {
788	if (!strcmp(keyword, kw->key))	if (!strcasecmp(keyword, kw->key))
789	return kw->type;	return kw->type;
790		} else {
791		if (!strcmp(keyword, kw->key))
792		return kw->type;
793		}
794	}	}
795	return LT_UNKNOWN;	return LT_UNKNOWN;
796	}	}
#	Line 644  static int isEntryStart(struct singleLin	Line 829  static int isEntryStart(struct singleLin
829	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
830	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct singleLine * line) {
831	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it (leaks a byte) */
832	char * title;	char * title = NULL;
833	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
834	title++;	title = strdup(line->elements[0].item);
835	*(title + strlen(title) - 1) = '\0';	title++;
836		*(title + strlen(title) - 1) = '\0';
837		} else if (line->type == LT_MENUENTRY)
838		title = strdup(line->elements[1].item);
839		else
840		return NULL;
841	return title;	return title;
842	}	}
843
#	Line 690  static void lineInit(struct singleLine *	Line 880  static void lineInit(struct singleLine *
880	}	}
881
882	struct singleLine * lineDup(struct singleLine * line) {	struct singleLine * lineDup(struct singleLine * line) {
	int i;
883	struct singleLine * newLine = malloc(sizeof(*newLine));	struct singleLine * newLine = malloc(sizeof(*newLine));
884
885	newLine->indent = strdup(line->indent);	newLine->indent = strdup(line->indent);
#	Line 700  struct singleLine * lineDup(struct singl	Line 889  struct singleLine * lineDup(struct singl
889	newLine->elements = malloc(sizeof(*newLine->elements) *	newLine->elements = malloc(sizeof(*newLine->elements) *
890	newLine->numElements);	newLine->numElements);
891
892	for (i = 0; i < newLine->numElements; i++) {	for (int i = 0; i < newLine->numElements; i++) {
893	newLine->elements[i].indent = strdup(line->elements[i].indent);	newLine->elements[i].indent = strdup(line->elements[i].indent);
894	newLine->elements[i].item = strdup(line->elements[i].item);	newLine->elements[i].item = strdup(line->elements[i].item);
895	}	}
#	Line 709  struct singleLine * lineDup(struct singl	Line 898  struct singleLine * lineDup(struct singl
898	}	}
899
900	static void lineFree(struct singleLine * line) {	static void lineFree(struct singleLine * line) {
	int i;
901	if (line->indent) free(line->indent);	if (line->indent) free(line->indent);
902
903	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
904	free(line->elements[i].item);	free(line->elements[i].item);
905	free(line->elements[i].indent);	free(line->elements[i].indent);
906	}	}
#	Line 724  static void lineFree(struct singleLine *	Line 911  static void lineFree(struct singleLine *
911
912	static int lineWrite(FILE * out, struct singleLine * line,	static int lineWrite(FILE * out, struct singleLine * line,
913	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
	int i;
914	if (fprintf(out, "%s", line->indent) == -1) return -1;	if (fprintf(out, "%s", line->indent) == -1) return -1;
915
916	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
917		/* Need to handle this, because we strip the quotes from
918		* menuentry when read it. */
919		if (line->type == LT_MENUENTRY && i == 1) {
920		if(!isquote(*line->elements[i].item))
921		fprintf(out, "\'%s\'", line->elements[i].item);
922		else
923		fprintf(out, "%s", line->elements[i].item);
924		fprintf(out, "%s", line->elements[i].indent);
925
926		continue;
927		}
928
929	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
930	if (fputc('"', out) == EOF) return -1;	if (fputc('"', out) == EOF) return -1;
931
#	Line 822  static int getNextLine(char ** bufPtr, s	Line 1019  static int getNextLine(char ** bufPtr, s
1019	if (*line->elements[0].item == '#') {	if (*line->elements[0].item == '#') {
1020	char * fullLine;	char * fullLine;
1021	int len;	int len;
	int i;
1022
1023	len = strlen(line->indent);	len = strlen(line->indent);
1024	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1025	len += strlen(line->elements[i].item) +	len += strlen(line->elements[i].item) +
1026	strlen(line->elements[i].indent);	strlen(line->elements[i].indent);
1027
#	Line 834  static int getNextLine(char ** bufPtr, s	Line 1030  static int getNextLine(char ** bufPtr, s
1030	free(line->indent);	free(line->indent);
1031	line->indent = fullLine;	line->indent = fullLine;
1032
1033	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1034	strcat(fullLine, line->elements[i].item);	strcat(fullLine, line->elements[i].item);
1035	strcat(fullLine, line->elements[i].indent);	strcat(fullLine, line->elements[i].indent);
1036	free(line->elements[i].item);	free(line->elements[i].item);
#	Line 853  static int getNextLine(char ** bufPtr, s	Line 1049  static int getNextLine(char ** bufPtr, s
1049	* elements up more	* elements up more
1050	*/	*/
1051	if (!isspace(kw->separatorChar)) {	if (!isspace(kw->separatorChar)) {
	int i;
1052	char indent[2] = "";	char indent[2] = "";
1053	indent[0] = kw->separatorChar;	indent[0] = kw->separatorChar;
1054	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1055	char *p;	char *p;
	int j;
1056	int numNewElements;	int numNewElements;
1057
1058	numNewElements = 0;	numNewElements = 0;
#	Line 874  static int getNextLine(char ** bufPtr, s	Line 1068  static int getNextLine(char ** bufPtr, s
1068	sizeof(*line->elements) * elementsAlloced);	sizeof(*line->elements) * elementsAlloced);
1069	}	}
1070
1071	for (j = line->numElements; j > i; j--) {	for (int j = line->numElements; j > i; j--) {
1072	line->elements[j + numNewElements] = line->elements[j];	line->elements[j + numNewElements] = line->elements[j];
1073	}	}
1074	line->numElements += numNewElements;	line->numElements += numNewElements;
#	Line 887  static int getNextLine(char ** bufPtr, s	Line 1081  static int getNextLine(char ** bufPtr, s
1081	break;	break;
1082	}	}
1083
1084	free(line->elements[i].indent);	line->elements[i + 1].indent = line->elements[i].indent;
1085	line->elements[i].indent = strdup(indent);	line->elements[i].indent = strdup(indent);
1086	*p++ = '\0';	*p++ = '\0';
1087	i++;	i++;
1088	line->elements[i].item = strdup(p);	line->elements[i].item = strdup(p);
	line->elements[i].indent = strdup("");
	p = line->elements[i].item;
1089	}	}
1090	}	}
1091	}	}
#	Line 903  static int getNextLine(char ** bufPtr, s	Line 1095  static int getNextLine(char ** bufPtr, s
1095	return 0;	return 0;
1096	}	}
1097
1098		static int isnumber(const char *s)
1099		{
1100		int i;
1101		for (i = 0; s[i] != '\0'; i++)
1102		if (s[i] < '0' || s[i] > '9')
1103		return 0;
1104		return i;
1105		}
1106
1107	static struct grubConfig * readConfig(const char * inName,	static struct grubConfig * readConfig(const char * inName,
1108	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
1109	int in;	int in;
#	Line 914  static struct grubConfig * readConfig(co	Line 1115  static struct grubConfig * readConfig(co
1115	struct singleLine * last = NULL, * line, * defaultLine = NULL;	struct singleLine * last = NULL, * line, * defaultLine = NULL;
1116	char * end;	char * end;
1117	struct singleEntry * entry = NULL;	struct singleEntry * entry = NULL;
1118	int i, len;	int len;
1119	char * buf;	char * buf;
1120
1121	if (!strcmp(inName, "-")) {	if (inName == NULL) {
1122		printf("Could not find bootloader configuration\n");
1123		exit(1);
1124		} else if (!strcmp(inName, "-")) {
1125	in = 0;	in = 0;
1126	} else {	} else {
1127	if ((in = open(inName, O_RDONLY)) < 0) {	if ((in = open(inName, O_RDONLY)) < 0) {
#	Line 977  static struct grubConfig * readConfig(co	Line 1181  static struct grubConfig * readConfig(co
1181	}	}
1182
1183	if (line->type == LT_SET_VARIABLE) {	if (line->type == LT_SET_VARIABLE) {
	int i;
1184	dbgPrintf("found 'set' command (%d elements): ", line->numElements);	dbgPrintf("found 'set' command (%d elements): ", line->numElements);
1185	dbgPrintf("%s", line->indent);	dbgPrintf("%s", line->indent);
1186	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1187	dbgPrintf("%s\"%s\"", line->elements[i].indent, line->elements[i].item);	dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
1188	dbgPrintf("\n");	dbgPrintf("\n");
1189	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1190	if (kwType && line->numElements == 3 &&	if (kwType && line->numElements == 3 &&
1191	!strcmp(line->elements[1].item, kwType->key)) {	!strcmp(line->elements[1].item, kwType->key) &&
1192		!is_special_grub2_variable(line->elements[2].item)) {
1193	dbgPrintf("Line sets default config\n");	dbgPrintf("Line sets default config\n");
1194	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1195	defaultLine = line;	defaultLine = line;
1196	}	}
	} else if (line->type == LT_DEFAULT && line->numElements == 2) {
	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
	defaultLine = line;
1197
1198	} else if (line->type == LT_KERNEL) {	} else if (iskernel(line->type)) {
1199	/* if by some freak chance this is multiboot and the "module"	/* if by some freak chance this is multiboot and the "module"
1200	* lines came earlier in the template, make sure to use LT_HYPER	* lines came earlier in the template, make sure to use LT_HYPER
1201	* instead of LT_KERNEL now	* instead of LT_KERNEL now
1202	*/	*/
1203	if (entry->multiboot)	if (entry && entry->multiboot)
1204	line->type = LT_HYPER;	line->type = LT_HYPER;
1205
1206	} else if (line->type == LT_MBMODULE) {	} else if (line->type == LT_MBMODULE) {
#	Line 1008  static struct grubConfig * readConfig(co	Line 1209  static struct grubConfig * readConfig(co
1209	* This only applies to grub, but that's the only place we	* This only applies to grub, but that's the only place we
1210	* should find LT_MBMODULE lines anyway.	* should find LT_MBMODULE lines anyway.
1211	*/	*/
1212	struct singleLine * l;	for (struct singleLine *l = entry->lines; l; l = l->next) {
	for (l = entry->lines; l; l = l->next) {
1213	if (l->type == LT_HYPER)	if (l->type == LT_HYPER)
1214	break;	break;
1215	else if (l->type == LT_KERNEL) {	else if (iskernel(l->type)) {
1216	l->type = LT_HYPER;	l->type = LT_HYPER;
1217	break;	break;
1218	}	}
#	Line 1026  static struct grubConfig * readConfig(co	Line 1226  static struct grubConfig * readConfig(co
1226	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1227	if (*end) cfg->fallbackImage = -1;	if (*end) cfg->fallbackImage = -1;
1228
1229	} else if (line->type == LT_TITLE && line->numElements > 1) {	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1230	/* make the title a single argument (undoing our parsing) */	(line->type == LT_TITLE && line->numElements > 1)) {
1231		/* make the title/default a single argument (undoing our parsing) */
1232	len = 0;	len = 0;
1233	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1234	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
1235	len += strlen(line->elements[i].indent);	len += strlen(line->elements[i].indent);
1236	}	}
1237	buf = malloc(len + 1);	buf = malloc(len + 1);
1238	*buf = '\0';	*buf = '\0';
1239
1240	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1241	strcat(buf, line->elements[i].item);	strcat(buf, line->elements[i].item);
1242	free(line->elements[i].item);	free(line->elements[i].item);
1243
#	Line 1050  static struct grubConfig * readConfig(co	Line 1251  static struct grubConfig * readConfig(co
1251	line->elements[line->numElements - 1].indent;	line->elements[line->numElements - 1].indent;
1252	line->elements[1].item = buf;	line->elements[1].item = buf;
1253	line->numElements = 2;	line->numElements = 2;
1254		} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
1255		/* let --remove-kernel="TITLE=what" work */
1256		len = 0;
1257		char *extras;
1258		char *title;
1259
1260		for (int i = 1; i < line->numElements; i++) {
1261		len += strlen(line->elements[i].item);
1262		len += strlen(line->elements[i].indent);
1263		}
1264		buf = malloc(len + 1);
1265		*buf = '\0';
1266
1267		/* allocate mem for extra flags. */
1268		extras = malloc(len + 1);
1269		*extras = '\0';
1270
1271		/* get title. */
1272		for (int i = 0; i < line->numElements; i++) {
1273		if (!strcmp(line->elements[i].item, "menuentry"))
1274		continue;
1275		if (isquote(*line->elements[i].item))
1276		title = line->elements[i].item + 1;
1277		else
1278		title = line->elements[i].item;
1279
1280		len = strlen(title);
1281		if (isquote(title[len-1])) {
1282		strncat(buf, title,len-1);
1283		break;
1284		} else {
1285		strcat(buf, title);
1286		strcat(buf, line->elements[i].indent);
1287		}
1288		}
1289
1290		/* get extras */
1291		int count = 0;
1292		for (int i = 0; i < line->numElements; i++) {
1293		if (count >= 2) {
1294		strcat(extras, line->elements[i].item);
1295		strcat(extras, line->elements[i].indent);
1296		}
1297
1298		if (!strcmp(line->elements[i].item, "menuentry"))
1299		continue;
1300
1301		/* count ' or ", there should be two in menuentry line. */
1302		if (isquote(*line->elements[i].item))
1303		count++;
1304
1305		len = strlen(line->elements[i].item);
1306
1307		if (isquote(line->elements[i].item[len -1]))
1308		count++;
1309
1310		/* ok, we get the final ' or ", others are extras. */
1311		}
1312		line->elements[1].indent =
1313		line->elements[line->numElements - 2].indent;
1314		line->elements[1].item = buf;
1315		line->elements[2].indent =
1316		line->elements[line->numElements - 2].indent;
1317		line->elements[2].item = extras;
1318		line->numElements = 3;
1319	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
1320	/* Strip off any " which may be present; they'll be put back	/* Strip off any " which may be present; they'll be put back
1321	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 1059  static struct grubConfig * readConfig(co	Line 1324  static struct grubConfig * readConfig(co
1324	if (line->numElements >= 2) {	if (line->numElements >= 2) {
1325	int last, len;	int last, len;
1326
1327	if (*line->elements[1].item == '"')	if (isquote(*line->elements[1].item))
1328	memmove(line->elements[1].item, line->elements[1].item + 1,	memmove(line->elements[1].item, line->elements[1].item + 1,
1329	strlen(line->elements[1].item + 1) + 1);	strlen(line->elements[1].item + 1) + 1);
1330
1331	last = line->numElements - 1;	last = line->numElements - 1;
1332	len = strlen(line->elements[last].item) - 1;	len = strlen(line->elements[last].item) - 1;
1333	if (line->elements[last].item[len] == '"')	if (isquote(line->elements[last].item[len]))
1334	line->elements[last].item[len] = '\0';	line->elements[last].item[len] = '\0';
1335	}	}
1336	}	}
1337
1338		if (line->type == LT_DEFAULT && line->numElements == 2) {
1339		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1340		defaultLine = line;
1341		}
1342
1343	/* If we find a generic config option which should live at the	/* If we find a generic config option which should live at the
1344	top of the file, move it there. Old versions of grubby were	top of the file, move it there. Old versions of grubby were
1345	probably responsible for putting new images in the wrong	probably responsible for putting new images in the wrong
#	Line 1127  static struct grubConfig * readConfig(co	Line 1397  static struct grubConfig * readConfig(co
1397	if (defaultLine->numElements > 2 &&	if (defaultLine->numElements > 2 &&
1398	cfi->defaultSupportSaved &&	cfi->defaultSupportSaved &&
1399	!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {	!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1400	cfg->defaultImage = DEFAULT_SAVED_GRUB2;	cfg->cfi->defaultIsSaved = 1;
1401		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1402		if (cfg->cfi->getEnv) {
1403		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1404		if (defTitle) {
1405		int index = 0;
1406		if (isnumber(defTitle)) {
1407		index = atoi(defTitle);
1408		entry = findEntryByIndex(cfg, index);
1409		} else {
1410		entry = findEntryByTitle(cfg, defTitle, &index);
1411		}
1412		if (entry)
1413		cfg->defaultImage = index;
1414		}
1415		}
1416	} else if (cfi->defaultIsVariable) {	} else if (cfi->defaultIsVariable) {
1417	char *value = defaultLine->elements[2].item;	char *value = defaultLine->elements[2].item;
1418	while (*value && (*value == '"' || *value == '\'' ||	while (*value && (*value == '"' || *value == '\'' ||
#	Line 1145  static struct grubConfig * readConfig(co	Line 1430  static struct grubConfig * readConfig(co
1430	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
1431	if (*end) cfg->defaultImage = -1;	if (*end) cfg->defaultImage = -1;
1432	} else if (defaultLine->numElements >= 2) {	} else if (defaultLine->numElements >= 2) {
1433	i = 0;	int i = 0;
1434	while ((entry = findEntryByIndex(cfg, i))) {	while ((entry = findEntryByIndex(cfg, i))) {
1435	for (line = entry->lines; line; line = line->next)	for (line = entry->lines; line; line = line->next)
1436	if (line->type == LT_TITLE) break;	if (line->type == LT_TITLE) break;
#	Line 1168  static struct grubConfig * readConfig(co	Line 1453  static struct grubConfig * readConfig(co
1453	cfg->defaultImage = -1;	cfg->defaultImage = -1;
1454	}	}
1455	}	}
1456		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1457		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1458		if (defTitle) {
1459		int index = 0;
1460		if (isnumber(defTitle)) {
1461		index = atoi(defTitle);
1462		entry = findEntryByIndex(cfg, index);
1463		} else {
1464		entry = findEntryByTitle(cfg, defTitle, &index);
1465		}
1466		if (entry)
1467		cfg->defaultImage = index;
1468		}
1469	} else {	} else {
1470	cfg->defaultImage = 0;	cfg->defaultImage = 0;
1471	}	}
#	Line 1185  static void writeDefault(FILE * out, cha	Line 1483  static void writeDefault(FILE * out, cha
1483
1484	if (cfg->defaultImage == DEFAULT_SAVED)	if (cfg->defaultImage == DEFAULT_SAVED)
1485	fprintf(out, "%sdefault%ssaved\n", indent, separator);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1486	else if (cfg->defaultImage == DEFAULT_SAVED_GRUB2)	else if (cfg->cfi->defaultIsSaved) {
1487	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1488	else if (cfg->defaultImage > -1) {	if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1489		char *title;
1490		entry = findEntryByIndex(cfg, cfg->defaultImage);
1491		line = getLineByType(LT_MENUENTRY, entry->lines);
1492		if (!line)
1493		line = getLineByType(LT_TITLE, entry->lines);
1494		if (line) {
1495		title = extractTitle(line);
1496		if (title)
1497		cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1498		}
1499		}
1500		} else if (cfg->defaultImage > -1) {
1501	if (cfg->cfi->defaultIsIndex) {	if (cfg->cfi->defaultIsIndex) {
1502	if (cfg->cfi->defaultIsVariable) {	if (cfg->cfi->defaultIsVariable) {
1503	fprintf(out, "%sset default=\"%d\"\n", indent,	fprintf(out, "%sset default=\"%d\"\n", indent,
#	Line 1247  static int writeConfig(struct grubConfig	Line 1557  static int writeConfig(struct grubConfig
1557
1558	/* most likely the symlink is relative, so change our	/* most likely the symlink is relative, so change our
1559	directory to the dir of the symlink */	directory to the dir of the symlink */
1560	rc = chdir(dirname(strdupa(outName)));	char *dir = strdupa(outName);
1561		rc = chdir(dirname(dir));
1562	do {	do {
1563	buf = alloca(len + 1);	buf = alloca(len + 1);
1564	rc = readlink(basename(outName), buf, len);	rc = readlink(basename(outName), buf, len);
#	Line 1289  static int writeConfig(struct grubConfig	Line 1600  static int writeConfig(struct grubConfig
1600	while (line) {	while (line) {
1601	if (line->type == LT_SET_VARIABLE && defaultKw &&	if (line->type == LT_SET_VARIABLE && defaultKw &&
1602	line->numElements == 3 &&	line->numElements == 3 &&
1603	!strcmp(line->elements[1].item, defaultKw->key)) {	!strcmp(line->elements[1].item, defaultKw->key) &&
1604		!is_special_grub2_variable(line->elements[2].item)) {
1605	writeDefault(out, line->indent, line->elements[0].indent, cfg);	writeDefault(out, line->indent, line->elements[0].indent, cfg);
1606	needs &= ~MAIN_DEFAULT;	needs &= ~MAIN_DEFAULT;
1607	} else if (line->type == LT_DEFAULT) {	} else if (line->type == LT_DEFAULT) {
#	Line 1385  static char *findDiskForRoot()	Line 1697  static char *findDiskForRoot()
1697	buf[rc] = '\0';	buf[rc] = '\0';
1698	chptr = buf;	chptr = buf;
1699
1700		char *foundanswer = NULL;
1701
1702	while (chptr && chptr != buf+rc) {	while (chptr && chptr != buf+rc) {
1703	devname = chptr;	devname = chptr;
1704
#	Line 1412  static char *findDiskForRoot()	Line 1726  static char *findDiskForRoot()
1726	* for '/' obviously.	* for '/' obviously.
1727	*/	*/
1728	if (*(++chptr) == '/' && *(++chptr) == ' ') {	if (*(++chptr) == '/' && *(++chptr) == ' ') {
1729	/*	/* remember the last / entry in mtab */
1730	* 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);
1731	}	}
1732
1733	/* Next line */	/* Next line */
#	Line 1427  static char *findDiskForRoot()	Line 1736  static char *findDiskForRoot()
1736	chptr++;	chptr++;
1737	}	}
1738
1739		/* Return the last / entry found */
1740		if (foundanswer) {
1741		chptr = strchr(foundanswer, ' ');
1742		*chptr = '\0';
1743		return strdup(foundanswer);
1744		}
1745
1746	return NULL;	return NULL;
1747	}	}
1748
1749	void printEntry(struct singleEntry * entry) {	void printEntry(struct singleEntry * entry, FILE *f) {
1750	int i;	int i;
1751	struct singleLine * line;	struct singleLine * line;
1752
1753	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
1754	fprintf(stderr, "DBG: %s", line->indent);	log_message(f, "DBG: %s", line->indent);
1755	for (i = 0; i < line->numElements; i++) {	for (i = 0; i < line->numElements; i++) {
1756	fprintf(stderr, "%s%s",	/* Need to handle this, because we strip the quotes from
1757		* menuentry when read it. */
1758		if (line->type == LT_MENUENTRY && i == 1) {
1759		if(!isquote(*line->elements[i].item))
1760		log_message(f, "\'%s\'", line->elements[i].item);
1761		else
1762		log_message(f, "%s", line->elements[i].item);
1763		log_message(f, "%s", line->elements[i].indent);
1764
1765		continue;
1766		}
1767
1768		log_message(f, "%s%s",
1769	line->elements[i].item, line->elements[i].indent);	line->elements[i].item, line->elements[i].indent);
1770	}	}
1771	fprintf(stderr, "\n");	log_message(f, "\n");
1772	}	}
1773	}	}
1774
1775	void notSuitablePrintf(struct singleEntry * entry, const char *fmt, ...)	void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1776	{	{
1777	va_list argp;	static int once;
1778		va_list argp, argq;
1779
1780	if (!debug)	va_start(argp, fmt);
1781
1782		va_copy(argq, argp);
1783		if (!once) {
1784		log_time(NULL);
1785		log_message(NULL, "command line: %s\n", saved_command_line);
1786		}
1787		log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1788		log_vmessage(NULL, fmt, argq);
1789
1790		printEntry(entry, NULL);
1791		va_end(argq);
1792
1793		if (!debug) {
1794		once = 1;
1795		va_end(argp);
1796	return;	return;
1797		}
1798
1799	va_start(argp, fmt);	if (okay) {
1800		va_end(argp);
1801		return;
1802		}
1803
1804		if (!once)
1805		log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1806		once = 1;
1807	fprintf(stderr, "DBG: Image entry failed: ");	fprintf(stderr, "DBG: Image entry failed: ");
1808	vfprintf(stderr, fmt, argp);	vfprintf(stderr, fmt, argp);
1809	printEntry(entry);	printEntry(entry, stderr);
1810	va_end(argp);	va_end(argp);
1811	}	}
1812
#	Line 1481  int suitableImage(struct singleEntry * e	Line 1833  int suitableImage(struct singleEntry * e
1833	char * rootdev;	char * rootdev;
1834
1835	if (skipRemoved && entry->skip) {	if (skipRemoved && entry->skip) {
1836	notSuitablePrintf(entry, "marked to skip\n");	notSuitablePrintf(entry, 0, "marked to skip\n");
1837	return 0;	return 0;
1838	}	}
1839
1840	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1841	if (!line) {	if (!line) {
1842	notSuitablePrintf(entry, "no line found\n");	notSuitablePrintf(entry, 0, "no line found\n");
1843	return 0;	return 0;
1844	}	}
1845	if (line->numElements < 2) {	if (line->numElements < 2) {
1846	notSuitablePrintf(entry, "line has only %d elements\n",	notSuitablePrintf(entry, 0, "line has only %d elements\n",
1847	line->numElements);	line->numElements);
1848	return 0;	return 0;
1849	}	}
1850
1851	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	if (flags & GRUBBY_BADIMAGE_OKAY) {
1852		notSuitablePrintf(entry, 1, "\n");
1853		return 1;
1854		}
1855
1856	fullName = alloca(strlen(bootPrefix) +	fullName = alloca(strlen(bootPrefix) +
1857	strlen(line->elements[1].item) + 1);	strlen(line->elements[1].item) + 1);
#	Line 1507  int suitableImage(struct singleEntry * e	Line 1862  int suitableImage(struct singleEntry * e
1862	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1863	line->elements[1].item + rootspec_offset);	line->elements[1].item + rootspec_offset);
1864	if (access(fullName, R_OK)) {	if (access(fullName, R_OK)) {
1865	notSuitablePrintf(entry, "access to %s failed\n", fullName);	notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1866	return 0;	return 0;
1867	}	}
1868	for (i = 2; i < line->numElements; i++)	for (i = 2; i < line->numElements; i++)
#	Line 1528  int suitableImage(struct singleEntry * e	Line 1883  int suitableImage(struct singleEntry * e
1883
1884	/* failed to find one */	/* failed to find one */
1885	if (!line) {	if (!line) {
1886	notSuitablePrintf(entry, "no line found\n");	notSuitablePrintf(entry, 0, "no line found\n");
1887	return 0;	return 0;
1888	}	}
1889
#	Line 1537  int suitableImage(struct singleEntry * e	Line 1892  int suitableImage(struct singleEntry * e
1892	if (i < line->numElements)	if (i < line->numElements)
1893	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1894	else {	else {
1895	notSuitablePrintf(entry, "no root= entry found\n");	notSuitablePrintf(entry, 0, "no root= entry found\n");
1896	/* it failed too...  can't find root= */	/* it failed too...  can't find root= */
1897	return 0;	return 0;
1898	}	}
#	Line 1546  int suitableImage(struct singleEntry * e	Line 1901  int suitableImage(struct singleEntry * e
1901
1902	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1903	if (!getpathbyspec(dev)) {	if (!getpathbyspec(dev)) {
1904	notSuitablePrintf(entry, "can't find blkid entry for %s\n", dev);	notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1905	return 0;	return 0;
1906	} else	} else
1907	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1908
1909	rootdev = findDiskForRoot();	rootdev = findDiskForRoot();
1910	if (!rootdev) {	if (!rootdev) {
1911	notSuitablePrintf(entry, "can't find root device\n");	notSuitablePrintf(entry, 0, "can't find root device\n");
1912	return 0;	return 0;
1913	}	}
1914
1915	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1916	notSuitablePrintf(entry, "uuid missing: rootdev %s, dev %s\n",	notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1917	getuuidbydev(rootdev), getuuidbydev(dev));	getuuidbydev(rootdev), getuuidbydev(dev));
1918	free(rootdev);	free(rootdev);
1919	return 0;	return 0;
1920	}	}
1921
1922	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1923	notSuitablePrintf(entry, "uuid mismatch: rootdev %s, dev %s\n",	notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1924	getuuidbydev(rootdev), getuuidbydev(dev));	getuuidbydev(rootdev), getuuidbydev(dev));
1925	free(rootdev);	free(rootdev);
1926	return 0;	return 0;
1927	}	}
1928
1929	free(rootdev);	free(rootdev);
1930		notSuitablePrintf(entry, 1, "\n");
1931
1932	return 1;	return 1;
1933	}	}
#	Line 1605  struct singleEntry * findEntryByPath(str	Line 1961  struct singleEntry * findEntryByPath(str
1961	}	}
1962
1963	indexVars[i + 1] = -1;	indexVars[i + 1] = -1;
1964
1965	i = 0;	i = 0;
1966	if (index) {	if (index) {
1967	while (i < *index) i++;	while (i < *index) {
1968	if (indexVars[i] == -1) return NULL;	i++;
1969		if (indexVars[i] == -1) return NULL;
1970		}
1971	}	}
1972
1973	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
1974	if (!entry) return NULL;	if (!entry) return NULL;
1975
1976	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1977	if (!line) return NULL;	if (!line) return NULL;
1978
1979	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1653  struct singleEntry * findEntryByPath(str	Line 2011  struct singleEntry * findEntryByPath(str
2011
2012	if (!strncmp(kernel, "TITLE=", 6)) {	if (!strncmp(kernel, "TITLE=", 6)) {
2013	prefix = "";	prefix = "";
2014	checkType = LT_TITLE;	checkType = LT_TITLE|LT_MENUENTRY;
2015	kernel += 6;	kernel += 6;
2016	}	}
2017
#	Line 1664  struct singleEntry * findEntryByPath(str	Line 2022  struct singleEntry * findEntryByPath(str
2022
2023	/* check all the lines matching checkType */	/* check all the lines matching checkType */
2024	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
2025	line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?	enum lineType_e ct = checkType;
2026	LT_KERNEL|LT_MBMODULE|LT_HYPER :	if (entry->multiboot && checkType == LT_KERNEL)
2027	checkType, line);	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2028	if (!line) break;  /* not found in this entry */	else if (checkType & LT_KERNEL)
2029		ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2030		line = getLineByType(ct, line);
2031		if (!line)
2032		break;  /* not found in this entry */
2033
2034	if (line && line->numElements >= 2) {	if (line && line->type != LT_MENUENTRY &&
2035		line->numElements >= 2) {
2036	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
2037	if (!strcmp(line->elements[1].item +	if (!strcmp(line->elements[1].item +
2038	((rootspec != NULL) ? strlen(rootspec) : 0),	((rootspec != NULL) ? strlen(rootspec) : 0),
2039	kernel + strlen(prefix)))	kernel + strlen(prefix)))
2040	break;	break;
2041	}	}
2042		if(line->type == LT_MENUENTRY &&
2043		!strcmp(line->elements[1].item, kernel))
2044		break;
2045	}	}
2046
2047	/* make sure this entry has a kernel identifier; this skips	/* make sure this entry has a kernel identifier; this skips
2048	* non-Linux boot entries (could find netbsd etc, though, which is	* non-Linux boot entries (could find netbsd etc, though, which is
2049	* unfortunate)	* unfortunate)
2050	*/	*/
2051	if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2052	break; /* found 'im! */	break; /* found 'im! */
2053	}	}
2054
#	Line 1692  struct singleEntry * findEntryByPath(str	Line 2058  struct singleEntry * findEntryByPath(str
2058	return entry;	return entry;
2059	}	}
2060
2061		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2062		int * index) {
2063		struct singleEntry * entry;
2064		struct singleLine * line;
2065		int i;
2066		char * newtitle;
2067
2068		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2069		if (index && i < *index)
2070		continue;
2071		line = getLineByType(LT_TITLE, entry->lines);
2072		if (!line)
2073		line = getLineByType(LT_MENUENTRY, entry->lines);
2074		if (!line)
2075		continue;
2076		newtitle = grub2ExtractTitle(line);
2077		if (!newtitle)
2078		continue;
2079		if (!strcmp(title, newtitle))
2080		break;
2081		}
2082
2083		if (!entry)
2084		return NULL;
2085
2086		if (index)
2087		*index = i;
2088		return entry;
2089		}
2090
2091	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2092	struct singleEntry * entry;	struct singleEntry * entry;
2093
#	Line 1714  struct singleEntry * findTemplate(struct	Line 2110  struct singleEntry * findTemplate(struct
2110	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2111	int index;	int index;
2112
2113	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2114		if (cfg->cfi->getEnv) {
2115		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2116		if (defTitle) {
2117		int index = 0;
2118		if (isnumber(defTitle)) {
2119		index = atoi(defTitle);
2120		entry = findEntryByIndex(cfg, index);
2121		} else {
2122		entry = findEntryByTitle(cfg, defTitle, &index);
2123		}
2124		if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2125		cfg->defaultImage = index;
2126		if (indexPtr)
2127		*indexPtr = index;
2128		return entry;
2129		}
2130		}
2131		}
2132		} else if (cfg->defaultImage > -1) {
2133	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2134	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2135	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1767  void markRemovedImage(struct grubConfig	Line 2182  void markRemovedImage(struct grubConfig
2182	const char * prefix) {	const char * prefix) {
2183	struct singleEntry * entry;	struct singleEntry * entry;
2184
2185	if (!image) return;	if (!image)
2186		return;
2187
2188		/* check and see if we're removing the default image */
2189		if (isdigit(*image)) {
2190		entry = findEntryByPath(cfg, image, prefix, NULL);
2191		if(entry)
2192		entry->skip = 1;
2193		return;
2194		}
2195
2196	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2197	entry->skip = 1;	entry->skip = 1;
#	Line 1775  void markRemovedImage(struct grubConfig	Line 2199  void markRemovedImage(struct grubConfig
2199
2200	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2201	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2202	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2203	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2204	int i, j;	int i, j;
2205
2206	if (newIsDefault) {	if (newIsDefault) {
2207	config->defaultImage = 0;	config->defaultImage = 0;
2208	return;	return;
2209		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2210		if (findEntryByIndex(config, index))
2211		config->defaultImage = index;
2212		else
2213		config->defaultImage = -1;
2214		return;
2215	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2216	i = 0;	i = 0;
2217	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1853  void displayEntry(struct singleEntry * e	Line 2283  void displayEntry(struct singleEntry * e
2283	struct singleLine * line;	struct singleLine * line;
2284	char * root = NULL;	char * root = NULL;
2285	int i;	int i;
2286		int j;
2287
2288	printf("index=%d\n", index);	printf("index=%d\n", index);
2289
2290	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2291	if (!line) {	if (!line) {
2292	printf("non linux entry\n");	printf("non linux entry\n");
2293	return;	return;
2294	}	}
2295
2296	printf("kernel=%s%s\n", prefix, line->elements[1].item);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2297		printf("kernel=%s\n", line->elements[1].item);
2298		else
2299		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2300
2301	if (line->numElements >= 3) {	if (line->numElements >= 3) {
2302	printf("args=\"");	printf("args=\"");
#	Line 1918  void displayEntry(struct singleEntry * e	Line 2352  void displayEntry(struct singleEntry * e
2352	printf("root=%s\n", s);	printf("root=%s\n", s);
2353	}	}
2354
2355	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2356
2357	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
2358	printf("initrd=%s", prefix);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2359		printf("initrd=");
2360		else
2361		printf("initrd=%s", prefix);
2362
2363	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
2364	printf("%s%s", line->elements[i].item, line->elements[i].indent);	printf("%s%s", line->elements[i].item, line->elements[i].indent);
2365	printf("\n");	printf("\n");
#	Line 1933  void displayEntry(struct singleEntry * e	Line 2371  void displayEntry(struct singleEntry * e
2371	} else {	} else {
2372	char * title;	char * title;
2373	line = getLineByType(LT_MENUENTRY, entry->lines);	line = getLineByType(LT_MENUENTRY, entry->lines);
2374	title = grub2ExtractTitle(line);	if (line) {
2375	if (title)	title = grub2ExtractTitle(line);
2376	printf("title=%s\n", title);	if (title)
2377		printf("title=%s\n", title);
2378		}
2379		}
2380
2381		for (j = 0, line = entry->lines; line; line = line->next) {
2382		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2383		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2384		printf("mbmodule%d=", j);
2385		else
2386		printf("mbmodule%d=%s", j, prefix);
2387
2388		for (i = 1; i < line->numElements; i++)
2389		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2390		printf("\n");
2391		j++;
2392		}
2393		}
2394		}
2395
2396		int isSuseSystem(void) {
2397		const char * path;
2398		const static char default_path[] = "/etc/SuSE-release";
2399
2400		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2401		path = default_path;
2402
2403		if (!access(path, R_OK))
2404		return 1;
2405		return 0;
2406		}
2407
2408		int isSuseGrubConf(const char * path) {
2409		FILE * grubConf;
2410		char * line = NULL;
2411		size_t len = 0, res = 0;
2412
2413		grubConf = fopen(path, "r");
2414		if (!grubConf) {
2415		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2416		return 0;
2417		}
2418
2419		while ((res = getline(&line, &len, grubConf)) != -1) {
2420		if (!strncmp(line, "setup", 5)) {
2421		fclose(grubConf);
2422		free(line);
2423		return 1;
2424		}
2425		}
2426
2427		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2428		path);
2429
2430		fclose(grubConf);
2431		free(line);
2432		return 0;
2433		}
2434
2435		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2436		FILE * grubConf;
2437		char * line = NULL;
2438		size_t res = 0, len = 0;
2439
2440		if (!path) return 1;
2441		if (!lbaPtr) return 1;
2442
2443		grubConf = fopen(path, "r");
2444		if (!grubConf) return 1;
2445
2446		while ((res = getline(&line, &len, grubConf)) != -1) {
2447		if (line[res - 1] == '\n')
2448		line[res - 1] = '\0';
2449		else if (len > res)
2450		line[res] = '\0';
2451		else {
2452		line = realloc(line, res + 1);
2453		line[res] = '\0';
2454		}
2455
2456		if (!strncmp(line, "setup", 5)) {
2457		if (strstr(line, "--force-lba")) {
2458		*lbaPtr = 1;
2459		} else {
2460		*lbaPtr = 0;
2461		}
2462		dbgPrintf("lba: %i\n", *lbaPtr);
2463		break;
2464		}
2465		}
2466
2467		free(line);
2468		fclose(grubConf);
2469		return 0;
2470		}
2471
2472		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2473		FILE * grubConf;
2474		char * line = NULL;
2475		size_t res = 0, len = 0;
2476		char * lastParamPtr = NULL;
2477		char * secLastParamPtr = NULL;
2478		char installDeviceNumber = '\0';
2479		char * bounds = NULL;
2480
2481		if (!path) return 1;
2482		if (!devicePtr) return 1;
2483
2484		grubConf = fopen(path, "r");
2485		if (!grubConf) return 1;
2486
2487		while ((res = getline(&line, &len, grubConf)) != -1) {
2488		if (strncmp(line, "setup", 5))
2489		continue;
2490
2491		if (line[res - 1] == '\n')
2492		line[res - 1] = '\0';
2493		else if (len > res)
2494		line[res] = '\0';
2495		else {
2496		line = realloc(line, res + 1);
2497		line[res] = '\0';
2498		}
2499
2500		lastParamPtr = bounds = line + res;
2501
2502		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2503		while (!isspace(*lastParamPtr))
2504		lastParamPtr--;
2505		lastParamPtr++;
2506
2507		secLastParamPtr = lastParamPtr - 2;
2508		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2509
2510		if (lastParamPtr + 3 > bounds) {
2511		dbgPrintf("lastParamPtr going over boundary");
2512		fclose(grubConf);
2513		free(line);
2514		return 1;
2515		}
2516		if (!strncmp(lastParamPtr, "(hd", 3))
2517		lastParamPtr += 3;
2518		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2519
2520		/*
2521		* Second last parameter will decide wether last parameter is
2522		* an IMAGE_DEVICE or INSTALL_DEVICE
2523		*/
2524		while (!isspace(*secLastParamPtr))
2525		secLastParamPtr--;
2526		secLastParamPtr++;
2527
2528		if (secLastParamPtr + 3 > bounds) {
2529		dbgPrintf("secLastParamPtr going over boundary");
2530		fclose(grubConf);
2531		free(line);
2532		return 1;
2533		}
2534		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2535		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2536		secLastParamPtr += 3;
2537		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2538		installDeviceNumber = *secLastParamPtr;
2539		} else {
2540		installDeviceNumber = *lastParamPtr;
2541		}
2542
2543		*devicePtr = malloc(6);
2544		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2545		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2546		fclose(grubConf);
2547		free(line);
2548		return 0;
2549	}	}
2550
2551		free(line);
2552		fclose(grubConf);
2553		return 1;
2554		}
2555
2556		int grubGetBootFromDeviceMap(const char * device,
2557		char ** bootPtr) {
2558		FILE * deviceMap;
2559		char * line = NULL;
2560		size_t res = 0, len = 0;
2561		char * devicePtr;
2562		char * bounds = NULL;
2563		const char * path;
2564		const static char default_path[] = "/boot/grub/device.map";
2565
2566		if (!device) return 1;
2567		if (!bootPtr) return 1;
2568
2569		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2570		path = default_path;
2571
2572		dbgPrintf("opening grub device.map file from: %s\n", path);
2573		deviceMap = fopen(path, "r");
2574		if (!deviceMap)
2575		return 1;
2576
2577		while ((res = getline(&line, &len, deviceMap)) != -1) {
2578		if (!strncmp(line, "#", 1))
2579		continue;
2580
2581		if (line[res - 1] == '\n')
2582		line[res - 1] = '\0';
2583		else if (len > res)
2584		line[res] = '\0';
2585		else {
2586		line = realloc(line, res + 1);
2587		line[res] = '\0';
2588		}
2589
2590		devicePtr = line;
2591		bounds = line + res;
2592
2593		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2594		devicePtr++;
2595		dbgPrintf("device: %s\n", devicePtr);
2596
2597		if (!strncmp(devicePtr, device, strlen(device))) {
2598		devicePtr += strlen(device);
2599		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2600		devicePtr++;
2601
2602		*bootPtr = strdup(devicePtr);
2603		break;
2604		}
2605		}
2606
2607		free(line);
2608		fclose(deviceMap);
2609		return 0;
2610		}
2611
2612		int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2613		char * grubDevice;
2614
2615		if (suseGrubConfGetInstallDevice(path, &grubDevice))
2616		dbgPrintf("error looking for grub installation device\n");
2617		else
2618		dbgPrintf("grubby installation device: %s\n", grubDevice);
2619
2620		if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2621		dbgPrintf("error looking for grub boot device\n");
2622		else
2623		dbgPrintf("grubby boot device: %s\n", *bootPtr);
2624
2625		free(grubDevice);
2626		return 0;
2627		}
2628
2629		int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2630		/*
2631		* This SuSE grub configuration file at this location is not your average
2632		* grub configuration file, but instead the grub commands used to setup
2633		* grub on that system.
2634		*/
2635		const char * path;
2636		const static char default_path[] = "/etc/grub.conf";
2637
2638		if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2639		path = default_path;
2640
2641		if (!isSuseGrubConf(path)) return 1;
2642
2643		if (lbaPtr) {
2644		*lbaPtr = 0;
2645		if (suseGrubConfGetLba(path, lbaPtr))
2646		return 1;
2647		}
2648
2649		if (bootPtr) {
2650		*bootPtr = NULL;
2651		suseGrubConfGetBoot(path, bootPtr);
2652		}
2653
2654		return 0;
2655	}	}
2656
2657	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
#	Line 1987  int parseSysconfigGrub(int * lbaPtr, cha	Line 2702  int parseSysconfigGrub(int * lbaPtr, cha
2702	}	}
2703
2704	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2705	char * boot;	char * boot = NULL;
2706	int lba;	int lba;
2707
2708	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2709	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2710	if (boot) printf("boot=%s\n", boot);	free(boot);
2711		return;
2712		}
2713		} else {
2714		if (parseSysconfigGrub(&lba, &boot)) {
2715		free(boot);
2716		return;
2717		}
2718		}
2719
2720		if (lba) printf("lba\n");
2721		if (boot) {
2722		printf("boot=%s\n", boot);
2723		free(boot);
2724	}	}
2725	}	}
2726
#	Line 2041  struct singleLine * addLineTmpl(struct s	Line 2769  struct singleLine * addLineTmpl(struct s
2769	{	{
2770	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2771
2772		if (isEfi && cfi == &grub2ConfigType) {
2773		enum lineType_e old = newLine->type;
2774		newLine->type = preferredLineType(newLine->type, cfi);
2775		if (old != newLine->type)
2776		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2777		}
2778
2779	if (val) {	if (val) {
2780	/* override the inherited value with our own.	/* override the inherited value with our own.
2781	* 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 2050  struct singleLine * addLineTmpl(struct s	Line 2785  struct singleLine * addLineTmpl(struct s
2785	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2786
2787	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2788	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)) {
2789	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2790	if (rootspec != NULL) {	if (rootspec != NULL) {
2791	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 2087  struct singleLine *  addLine(struct sing	Line 2822  struct singleLine *  addLine(struct sing
2822	/* 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
2823	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2824	*/	*/
2825	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2826	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2827	tmpl.type = type;	tmpl.type = type;
#	Line 2191  void removeLine(struct singleEntry * ent	Line 2925  void removeLine(struct singleEntry * ent
2925	free(line);	free(line);
2926	}	}
2927
	static int isquote(char q)
	{
	if (q == '\'' || q == '\"')
	return 1;
	return 0;
	}
2928	static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)	static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
2929	{	{
2930	struct singleLine newLine = {	struct singleLine newLine = {
#	Line 2428  int updateActualImage(struct grubConfig	Line 3155  int updateActualImage(struct grubConfig
3155	firstElement = 2;	firstElement = 2;
3156
3157	} else {	} else {
3158	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3159	if (!line) {	if (!line) {
3160	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3161	continue;	continue;
#	Line 2584  int updateImage(struct grubConfig * cfg,	Line 3311  int updateImage(struct grubConfig * cfg,
3311	return rc;	return rc;
3312	}	}
3313
3314		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3315		const char * image, const char * prefix, const char * initrd,
3316		const char * title) {
3317		struct singleEntry * entry;
3318		struct singleLine * line, * kernelLine, *endLine = NULL;
3319		int index = 0;
3320
3321		if (!image) return 0;
3322
3323		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3324		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3325		if (!kernelLine) continue;
3326
3327		/* if title is supplied, the entry's title must match it. */
3328		if (title) {
3329		char *linetitle;
3330
3331		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3332		if (!line)
3333		continue;
3334
3335		linetitle = extractTitle(line);
3336		if (!linetitle)
3337		continue;
3338		if (strcmp(title, linetitle)) {
3339		free(linetitle);
3340		continue;
3341		}
3342		free(linetitle);
3343		}
3344
3345		if (prefix) {
3346		int prefixLen = strlen(prefix);
3347		if (!strncmp(initrd, prefix, prefixLen))
3348		initrd += prefixLen;
3349		}
3350		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3351		if (endLine)
3352		removeLine(entry, endLine);
3353		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3354		kernelLine->indent, initrd);
3355		if (!line)
3356		return 1;
3357		if (endLine) {
3358		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3359		if (!line)
3360		return 1;
3361		}
3362
3363		break;
3364		}
3365
3366		return 0;
3367		}
3368
3369	int updateInitrd(struct grubConfig * cfg, const char * image,	int updateInitrd(struct grubConfig * cfg, const char * image,
3370	const char * prefix, const char * initrd) {	const char * prefix, const char * initrd, const char * title) {
3371	struct singleEntry * entry;	struct singleEntry * entry;
3372	struct singleLine * line, * kernelLine, *endLine = NULL;	struct singleLine * line, * kernelLine, *endLine = NULL;
3373	int index = 0;	int index = 0;
#	Line 2593  int updateInitrd(struct grubConfig * cfg	Line 3375  int updateInitrd(struct grubConfig * cfg
3375	if (!image) return 0;	if (!image) return 0;
3376
3377	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3378	kernelLine = getLineByType(LT_KERNEL, entry->lines);	kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3379	if (!kernelLine) continue;	if (!kernelLine) continue;
3380
3381	line = getLineByType(LT_INITRD, entry->lines);	/* if title is supplied, the entry's title must match it. */
3382		if (title) {
3383		char *linetitle;
3384
3385		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3386		if (!line)
3387		continue;
3388
3389		linetitle = extractTitle(line);
3390		if (!linetitle)
3391		continue;
3392		if (strcmp(title, linetitle)) {
3393		free(linetitle);
3394		continue;
3395		}
3396		free(linetitle);
3397		}
3398
3399		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3400	if (line)	if (line)
3401	removeLine(entry, line);	removeLine(entry, line);
3402	if (prefix) {	if (prefix) {
#	Line 2607  int updateInitrd(struct grubConfig * cfg	Line 3407  int updateInitrd(struct grubConfig * cfg
3407	endLine = getLineByType(LT_ENTRY_END, entry->lines);	endLine = getLineByType(LT_ENTRY_END, entry->lines);
3408	if (endLine)	if (endLine)
3409	removeLine(entry, endLine);	removeLine(entry, endLine);
3410	line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);	enum lineType_e lt;
3411		switch(kernelLine->type) {
3412		case LT_KERNEL:
3413		lt = LT_INITRD;
3414		break;
3415		case LT_KERNEL_EFI:
3416		lt = LT_INITRD_EFI;
3417		break;
3418		case LT_KERNEL_16:
3419		lt = LT_INITRD_16;
3420		break;
3421		default:
3422		lt = preferredLineType(LT_INITRD, cfg->cfi);
3423		}
3424		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3425	if (!line)	if (!line)
3426	return 1;	return 1;
3427	if (endLine) {	if (endLine) {
#	Line 2813  int checkForGrub(struct grubConfig * con	Line 3627  int checkForGrub(struct grubConfig * con
3627	int fd;	int fd;
3628	unsigned char bootSect[512];	unsigned char bootSect[512];
3629	char * boot;	char * boot;
3630		int onSuse = isSuseSystem();
3631
3632	if (parseSysconfigGrub(NULL, &boot))
3633	return 0;	if (onSuse) {
3634		if (parseSuseGrubConf(NULL, &boot))
3635		return 0;
3636		} else {
3637		if (parseSysconfigGrub(NULL, &boot))
3638		return 0;
3639		}
3640
3641	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3642	if (!boot)	if (!boot)
#	Line 2834  int checkForGrub(struct grubConfig * con	Line 3655  int checkForGrub(struct grubConfig * con
3655	}	}
3656	close(fd);	close(fd);
3657
3658		/* The more elaborate checks do not work on SuSE. The checks done
3659		* seem to be reasonble (at least for now), so just return success
3660		*/
3661		if (onSuse)
3662		return 2;
3663
3664	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3665	}	}
3666
#	Line 2867  int checkForExtLinux(struct grubConfig *	Line 3694  int checkForExtLinux(struct grubConfig *
3694	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3695	}	}
3696
3697		int checkForYaboot(struct grubConfig * config) {
3698		/*
3699		* This is a simplistic check that we consider good enough for own puporses
3700		*
3701		* If we were to properly check if yaboot is *installed* we'd need to:
3702		* 1) get the system boot device (LT_BOOT)
3703		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3704		*    the content on the boot device
3705		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3706		* 4) check again if binary and boot device contents match
3707		*/
3708		if (!access("/etc/yaboot.conf", R_OK))
3709		return 2;
3710
3711		return 1;
3712		}
3713
3714		int checkForElilo(struct grubConfig * config) {
3715		if (!access("/etc/elilo.conf", R_OK))
3716		return 2;
3717
3718		return 1;
3719		}
3720
3721	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3722	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3723
#	Line 2881  static char * getRootSpecifier(char * st	Line 3732  static char * getRootSpecifier(char * st
3732	static char * getInitrdVal(struct grubConfig * config,	static char * getInitrdVal(struct grubConfig * config,
3733	const char * prefix, struct singleLine *tmplLine,	const char * prefix, struct singleLine *tmplLine,
3734	const char * newKernelInitrd,	const char * newKernelInitrd,
3735	char ** extraInitrds, int extraInitrdCount)	const char ** extraInitrds, int extraInitrdCount)
3736	{	{
3737	char *initrdVal, *end;	char *initrdVal, *end;
3738	int i;	int i;
#	Line 2926  static char * getInitrdVal(struct grubCo	Line 3777  static char * getInitrdVal(struct grubCo
3777
3778	int addNewKernel(struct grubConfig * config, struct singleEntry * template,	int addNewKernel(struct grubConfig * config, struct singleEntry * template,
3779	const char * prefix,	const char * prefix,
3780	char * newKernelPath, char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3781	char * newKernelArgs, char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3782	char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3783	char * newMBKernel, char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs,
3784		const char * newDevTreePath) {
3785	struct singleEntry * new;	struct singleEntry * new;
3786	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3787	int needs;	int needs;
#	Line 2970  int addNewKernel(struct grubConfig * con	Line 3822  int addNewKernel(struct grubConfig * con
3822	needs |= NEED_MB;	needs |= NEED_MB;
3823	new->multiboot = 1;	new->multiboot = 1;
3824	}	}
3825		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3826		needs |= NEED_DEVTREE;
3827
3828	if (template) {	if (template) {
3829	for (masterLine = template->lines;	for (masterLine = template->lines;
#	Line 2983  int addNewKernel(struct grubConfig * con	Line 3837  int addNewKernel(struct grubConfig * con
3837	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3838	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3839
3840	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3841	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3842	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3843	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 3061  int addNewKernel(struct grubConfig * con	Line 3914  int addNewKernel(struct grubConfig * con
3914	/* template is multi but new is not,	/* template is multi but new is not,
3915	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3916	*/	*/
3917	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3918	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3919	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3920	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3921		config->cfi)->key);
3922	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3923	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3924		config->cfi);
3925	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3926	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3927	char *initrdVal;	char *initrdVal;
3928	/* template is multi but new is not,	/* template is multi but new is not,
3929	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3930	*/	*/
3931	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3932	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3933	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3934	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3935		config->cfi)->key);
3936	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3937	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3938	free(initrdVal);	free(initrdVal);
3939	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3940	}	}
3941
3942	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3943	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3944	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3945	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 3138  int addNewKernel(struct grubConfig * con	Line 3993  int addNewKernel(struct grubConfig * con
3993	static const char *prefix = "'Loading ";	static const char *prefix = "'Loading ";
3994	if (tmplLine->numElements > 1 &&	if (tmplLine->numElements > 1 &&
3995	strstr(tmplLine->elements[1].item, prefix) &&	strstr(tmplLine->elements[1].item, prefix) &&
3996	masterLine->next && masterLine->next->type == LT_KERNEL) {	masterLine->next &&
3997		iskernel(masterLine->next->type)) {
3998	char *newTitle = malloc(strlen(prefix) +	char *newTitle = malloc(strlen(prefix) +
3999	strlen(newKernelTitle) + 2);	strlen(newKernelTitle) + 2);
4000
#	Line 3153  int addNewKernel(struct grubConfig * con	Line 4009  int addNewKernel(struct grubConfig * con
4009	newLine = addLineTmpl(new, tmplLine, newLine, NULL,	newLine = addLineTmpl(new, tmplLine, newLine, NULL,
4010	config->cfi);	config->cfi);
4011	}	}
4012		} else if (tmplLine->type == LT_DEVTREE &&
4013		tmplLine->numElements == 2 && newDevTreePath) {
4014		newLine = addLineTmpl(new, tmplLine, newLine,
4015		newDevTreePath + strlen(prefix),
4016		config->cfi);
4017		needs &= ~NEED_DEVTREE;
4018		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
4019		const char *ndtp = newDevTreePath;
4020		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
4021		ndtp += strlen(prefix);
4022		newLine = addLine(new, config->cfi, LT_DEVTREE,
4023		config->secondaryIndent,
4024		ndtp);
4025		needs &= ~NEED_DEVTREE;
4026		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
4027	} else {	} else {
4028	/* pass through other lines from the template */	/* pass through other lines from the template */
4029	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
#	Line 3165  int addNewKernel(struct grubConfig * con	Line 4036  int addNewKernel(struct grubConfig * con
4036	*/	*/
4037	switch (config->cfi->entryStart) {	switch (config->cfi->entryStart) {
4038	case LT_KERNEL:	case LT_KERNEL:
4039		case LT_KERNEL_EFI:
4040		case LT_KERNEL_16:
4041	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
4042	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
4043	} else {	} else {
4044	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
4045		preferredLineType(LT_KERNEL, config->cfi),
4046	config->primaryIndent,	config->primaryIndent,
4047	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4048	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3225  int addNewKernel(struct grubConfig * con	Line 4099  int addNewKernel(struct grubConfig * con
4099	}	}
4100	}	}
4101
4102		struct singleLine *endLine = NULL;
4103		endLine = getLineByType(LT_ENTRY_END, new->lines);
4104		if (endLine) {
4105		removeLine(new, endLine);
4106		needs |= NEED_END;
4107		}
4108
4109	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4110	* 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,
4111	* all the lines following the entryStart.	* all the lines following the entryStart.
#	Line 3244  int addNewKernel(struct grubConfig * con	Line 4125  int addNewKernel(struct grubConfig * con
4125	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
4126	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4127	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4128	config->cfi)) ?	config->cfi))
4129	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
4130		: preferredLineType(LT_KERNEL, config->cfi),
4131	config->secondaryIndent,	config->secondaryIndent,
4132	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4133	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3261  int addNewKernel(struct grubConfig * con	Line 4143  int addNewKernel(struct grubConfig * con
4143	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4144	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4145	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4146	config->cfi)) ?	config->cfi))
4147	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
4148		: preferredLineType(LT_INITRD, config->cfi),
4149	config->secondaryIndent,	config->secondaryIndent,
4150	initrdVal);	initrdVal);
4151	free(initrdVal);	free(initrdVal);
4152	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4153	}	}
4154		if (needs & NEED_DEVTREE) {
4155		newLine = addLine(new, config->cfi, LT_DEVTREE,
4156		config->secondaryIndent,
4157		newDevTreePath);
4158		needs &= ~NEED_DEVTREE;
4159		}
4160
4161		/* NEEDS_END must be last on bootloaders that need it... */
4162	if (needs & NEED_END) {	if (needs & NEED_END) {
4163	newLine = addLine(new, config->cfi, LT_ENTRY_END,	newLine = addLine(new, config->cfi, LT_ENTRY_END,
4164	config->secondaryIndent, NULL);	config->secondaryIndent, NULL);
#	Line 3294  static void traceback(int signum)	Line 4185  static void traceback(int signum)
4185	memset(array, '\0', sizeof (array));	memset(array, '\0', sizeof (array));
4186	size = backtrace(array, 40);	size = backtrace(array, 40);
4187
4188	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",	fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4189	(unsigned long)size);	(unsigned long)size);
4190	backtrace_symbols_fd(array, size, STDERR_FILENO);	backtrace_symbols_fd(array, size, STDERR_FILENO);
4191	exit(1);	exit(1);
#	Line 3319  int main(int argc, const char ** argv) {	Line 4210  int main(int argc, const char ** argv) {
4210	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4211	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4212	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4213	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4214	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4215	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4216	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 3329  int main(int argc, const char ** argv) {	Line 4220  int main(int argc, const char ** argv) {
4220	char * removeArgs = NULL;	char * removeArgs = NULL;
4221	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4222	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4223		char * envPath = NULL;
4224	const char * chptr = NULL;	const char * chptr = NULL;
4225	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4226	struct grubConfig * config;	struct grubConfig * config;
#	Line 3337  int main(int argc, const char ** argv) {	Line 4229  int main(int argc, const char ** argv) {
4229	int displayDefault = 0;	int displayDefault = 0;
4230	int displayDefaultIndex = 0;	int displayDefaultIndex = 0;
4231	int displayDefaultTitle = 0;	int displayDefaultTitle = 0;
4232		int defaultIndex = -1;
4233	struct poptOption options[] = {	struct poptOption options[] = {
4234	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4235	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 3354  int main(int argc, const char ** argv) {	Line 4247  int main(int argc, const char ** argv) {
4247	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4248	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4249	_("bootfs") },	_("bootfs") },
4250	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4251	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4252	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4253	#endif	#endif
4254	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4255	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
#	Line 3375  int main(int argc, const char ** argv) {	Line 4268  int main(int argc, const char ** argv) {
4268	_("display the index of the default kernel") },	_("display the index of the default kernel") },
4269	{ "default-title", 0, 0, &displayDefaultTitle, 0,	{ "default-title", 0, 0, &displayDefaultTitle, 0,
4270	_("display the title of the default kernel") },	_("display the title of the default kernel") },
4271		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4272		_("device tree file for new stanza"), _("dtb-path") },
4273	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4274	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4275		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4276		_("force grub2 stanzas to use efi") },
4277		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4278		_("path for environment data"),
4279		_("path") },
4280	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4281	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4282	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
#	Line 3389  int main(int argc, const char ** argv) {	Line 4289  int main(int argc, const char ** argv) {
4289	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4290	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4291	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4292	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4293	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4294	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4295	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 3409  int main(int argc, const char ** argv) {	Line 4309  int main(int argc, const char ** argv) {
4309	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4310	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4311	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4312		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4313		_("make the given entry index the default entry"),
4314		_("entry-index") },
4315	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4316	_("configure silo bootloader") },	_("configure silo bootloader") },
4317	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 3430  int main(int argc, const char ** argv) {	Line 4333  int main(int argc, const char ** argv) {
4333
4334	signal(SIGSEGV, traceback);	signal(SIGSEGV, traceback);
4335
4336		int i = 0;
4337		for (int j = 1; j < argc; j++)
4338		i += strlen(argv[j]) + 1;
4339		saved_command_line = malloc(i);
4340		if (!saved_command_line) {
4341		fprintf(stderr, "grubby: %m\n");
4342		exit(1);
4343		}
4344		saved_command_line[0] = '\0';
4345		for (int j = 1; j < argc; j++) {
4346		strcat(saved_command_line, argv[j]);
4347		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4348		}
4349
4350	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4351	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4352
#	Line 3473  int main(int argc, const char ** argv) {	Line 4390  int main(int argc, const char ** argv) {
4390	return 1;	return 1;
4391	} else if (configureGrub2) {	} else if (configureGrub2) {
4392	cfi = &grub2ConfigType;	cfi = &grub2ConfigType;
4393		if (envPath)
4394		cfi->envFile = envPath;
4395	} else if (configureLilo) {	} else if (configureLilo) {
4396	cfi = &liloConfigType;	cfi = &liloConfigType;
4397	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 3491  int main(int argc, const char ** argv) {	Line 4410  int main(int argc, const char ** argv) {
4410	}	}
4411
4412	if (!cfi) {	if (!cfi) {
4413		if (grub2FindConfig(&grub2ConfigType))
4414		cfi = &grub2ConfigType;
4415		else
4416	#ifdef __ia64__	#ifdef __ia64__
4417	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4418	#elif __powerpc__	#elif __powerpc__
4419	cfi = &yabootConfigType;	cfi = &yabootConfigType;
4420	#elif __sparc__	#elif __sparc__
4421	cfi = &siloConfigType;	cfi = &siloConfigType;
4422	#elif __s390__	#elif __s390__
4423	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4424	#elif __s390x__	#elif __s390x__
4425	cfi = &ziplConfigtype;	cfi = &ziplConfigtype;
4426	#else	#else
	if (grub2FindConfig(&grub2ConfigType))
	cfi = &grub2ConfigType;
	else
4427	cfi = &grubConfigType;	cfi = &grubConfigType;
4428	#endif	#endif
4429	}	}
#	Line 3516  int main(int argc, const char ** argv) {	Line 4435  int main(int argc, const char ** argv) {
4435	grubConfig = cfi->defaultConfig;	grubConfig = cfi->defaultConfig;
4436	}	}
4437
4438	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4439	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4440	defaultKernel || displayDefaultIndex || displayDefaultTitle)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4441		(defaultIndex >= 0))) {
4442	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4443	"specified option"));	"specified option"));
4444	return 1;	return 1;
4445	}	}
4446
4447	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4448	removeKernelPath)) {	removeKernelPath)) {
4449	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4450	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 3534  int main(int argc, const char ** argv) {	Line 4454  int main(int argc, const char ** argv) {
4454	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4455	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4456	return 1;	return 1;
4457	} else if (!newKernelPath && (newKernelTitle  || copyDefault ||	} else if (!newKernelPath && (copyDefault ||
4458	(newKernelInitrd && !updateKernelPath)||	(newKernelInitrd && !updateKernelPath)||
4459	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4460	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
#	Line 3560  int main(int argc, const char ** argv) {	Line 4480  int main(int argc, const char ** argv) {
4480	makeDefault = 1;	makeDefault = 1;
4481	defaultKernel = NULL;	defaultKernel = NULL;
4482	}	}
4483		else if (defaultKernel && (defaultIndex >= 0)) {
4484		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4485		"may not be used together\n"));
4486		return 1;
4487		}
4488
4489	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4490	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
#	Line 3568  int main(int argc, const char ** argv) {	Line 4493  int main(int argc, const char ** argv) {
4493	}	}
4494
4495	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4496	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4497	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4498		&& (defaultIndex == -1)) {
4499	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4500	return 1;	return 1;
4501	}	}
#	Line 3596  int main(int argc, const char ** argv) {	Line 4522  int main(int argc, const char ** argv) {
4522	}	}
4523
4524	if (bootloaderProbe) {	if (bootloaderProbe) {
4525	int lrc = 0, grc = 0, gr2c = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4526	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4527
4528	const char *grub2config = grub2FindConfig(&grub2ConfigType);	const char *grub2config = grub2FindConfig(&grub2ConfigType);
4529	if (grub2config) {	if (grub2config) {
#	Line 3625  int main(int argc, const char ** argv) {	Line 4551  int main(int argc, const char ** argv) {
4551	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4552	}	}
4553
4554		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4555		econfig = readConfig(eliloConfigType.defaultConfig,
4556		&eliloConfigType);
4557		if (!econfig)
4558		erc = 1;
4559		else
4560		erc = checkForElilo(econfig);
4561		}
4562
4563	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4564	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4565	if (!lconfig)	if (!lconfig)
4566	erc = 1;	extrc = 1;
4567	else	else
4568	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4569	}	}
4570
4571	if (lrc == 1 || grc == 1 || gr2c == 1) return 1;
4572		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4573		yconfig = readConfig(yabootConfigType.defaultConfig,
4574		&yabootConfigType);
4575		if (!yconfig)
4576		yrc = 1;
4577		else
4578		yrc = checkForYaboot(yconfig);
4579		}
4580
4581		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4582		erc == 1)
4583		return 1;
4584
4585	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4586	if (gr2c == 2) printf("grub2\n");	if (gr2c == 2) printf("grub2\n");
4587	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4588	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4589		if (yrc == 2) printf("yaboot\n");
4590		if (erc == 2) printf("elilo\n");
4591
4592	return 0;	return 0;
4593	}	}
4594
4595		if (grubConfig == NULL) {
4596		printf("Could not find bootloader configuration file.\n");
4597		exit(1);
4598		}
4599
4600	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4601	if (!config) return 1;	if (!config) return 1;
4602
#	Line 3652  int main(int argc, const char ** argv) {	Line 4606  int main(int argc, const char ** argv) {
4606	char * rootspec;	char * rootspec;
4607
4608	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4609		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4610		cfi->defaultIsSaved)
4611		config->defaultImage = 0;
4612	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4613	if (!entry) return 0;	if (!entry) return 0;
4614	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4615
4616	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4617	if (!line) return 0;	if (!line) return 0;
4618
4619	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3670  int main(int argc, const char ** argv) {	Line 4627  int main(int argc, const char ** argv) {
4627	struct singleEntry * entry;	struct singleEntry * entry;
4628
4629	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4630		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4631		cfi->defaultIsSaved)
4632		config->defaultImage = 0;
4633	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4634	if (!entry) return 0;	if (!entry) return 0;
4635
#	Line 3692  int main(int argc, const char ** argv) {	Line 4652  int main(int argc, const char ** argv) {
4652
4653	} else if (displayDefaultIndex) {	} else if (displayDefaultIndex) {
4654	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4655		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4656		cfi->defaultIsSaved)
4657		config->defaultImage = 0;
4658	printf("%i\n", config->defaultImage);	printf("%i\n", config->defaultImage);
4659		return 0;
4660
4661	} else if (kernelInfo)	} else if (kernelInfo)
4662	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
#	Line 3705  int main(int argc, const char ** argv) {	Line 4669  int main(int argc, const char ** argv) {
4669	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4670	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4671	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4672	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4673	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4674	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4675	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4676	if (updateKernelPath && newKernelInitrd) {	if (updateKernelPath && newKernelInitrd) {
4677	if (updateInitrd(config, updateKernelPath, bootPrefix,	if (newMBKernel) {
4678	newKernelInitrd)) return 1;	if (addMBInitrd(config, newMBKernel, updateKernelPath,
4679		bootPrefix, newKernelInitrd,
4680		newKernelTitle))
4681		return 1;
4682		} else {
4683		if (updateInitrd(config, updateKernelPath, bootPrefix,
4684		newKernelInitrd, newKernelTitle))
4685		return 1;
4686		}
4687	}	}
4688	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4689	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4690	extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4691	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4692
4693
4694	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.1751   changed lines   Added in v.2971