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

Parent Directory | Revision Log | Patch

	revision 1736 by niro, Sat Feb 18 01:02:17 2012 UTC	revision 2960 by niro, Wed Jun 29 14:07:59 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
135		#define DEFAULT_SAVED_GRUB2 -3
136
137	struct keywordTypes {	struct keywordTypes {
138	char * key;	char * key;
#	Line 127  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 147  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 163  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 204  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 218  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 241  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) {
386		int count = 0;
387
388		for (int i = 0; i < line->numElements; i++) {
389		int indentSize = 0;
390
391		count = count + strlen(line->elements[i].item);
392
393		indentSize = strlen(line->elements[i].indent);
394		if (indentSize > 0)
395		count = count + indentSize;
396		else
397		/* be extra safe and add room for whitespaces */
398		count = count + 1;
399		}
400
401		/* room for trailing terminator */
402		count = count + 1;
403
404		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) {
423		char * current;
424		char * current_indent;
425		int current_len;
426		int current_indent_len;
427		int i;
428
429		/* bail out if line does not start with menuentry */
430		if (strcmp(line->elements[0].item, "menuentry"))
431		return NULL;
432
433		i = 1;
434		current = line->elements[i].item;
435		current_len = strlen(current);
436
437		/* if second word is quoted, strip the quotes and return single word */
438		if (isquote(*current) && isquote(current[current_len - 1])) {
439		char *tmp;
440
441		tmp = strdup(current);
442		*(tmp + current_len - 1) = '\0';
443		return ++tmp;
444		}
445
446		/* if no quotes, return second word verbatim */
447		if (!isquote(*current))
448		return current;
449
450		/* 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) */
452		int resultMaxSize;
453		char * result;
454
455		resultMaxSize = sizeOfSingleLine(line);
456		result = malloc(resultMaxSize);
457		snprintf(result, resultMaxSize, "%s", ++current);
458
459		i++;
460		for (; i < line->numElements; ++i) {
461		current = line->elements[i].item;
462		current_len = strlen(current);
463		current_indent = line->elements[i].indent;
464		current_indent_len = strlen(current_indent);
465
466		strncat(result, current_indent, current_indent_len);
467		if (!isquote(current[current_len-1])) {
468		strncat(result, current, current_len);
469		} else {
470		strncat(result, current, current_len - 1);
471		break;
472		}
473		}
474		return result;
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 = 0,	.defaultSupportSaved = 1,
484	.defaultIsVariable = 1,	.defaultIsVariable = 1,
485	.entryStart = LT_MENUENTRY,	.entryStart = LT_MENUENTRY,
486	.entryEnd = LT_ENTRY_END,	.entryEnd = LT_ENTRY_END,
#	Line 397  struct configFileInfo ziplConfigType = {	Line 632  struct configFileInfo ziplConfigType = {
632	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
633	.defaultConfig = "/boot/extlinux/extlinux.conf",	.defaultConfig = "/boot/extlinux/extlinux.conf",
634	.keywords = extlinuxKeywords,	.keywords = extlinuxKeywords,
635		.caseInsensitive = 1,
636	.entryStart = LT_TITLE,	.entryStart = LT_TITLE,
637	.needsBootPrefix = 1,	.needsBootPrefix = 1,
638	.maxTitleLength = 255,	.maxTitleLength = 255,
639	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
640		.defaultIsUnquoted = 1,
641	};	};
642
643	struct grubConfig {	struct grubConfig {
#	Line 421  struct singleEntry * findEntryByIndex(st	Line 658  struct singleEntry * findEntryByIndex(st
658	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
659	const char * path, const char * prefix,	const char * path, const char * prefix,
660	int * index);	int * index);
661		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
662		int * index);
663	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
664	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
665	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 485  static char * sdupprintf(const char *for	Line 724  static char * sdupprintf(const char *for
724	return buf;	return buf;
725	}	}
726
727		static enum lineType_e preferredLineType(enum lineType_e type,
728		struct configFileInfo *cfi) {
729		if (isEfi && cfi == &grub2ConfigType) {
730		switch (type) {
731		case LT_KERNEL:
732		return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
733		case LT_INITRD:
734		return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
735		default:
736		return type;
737		}
738		#if defined(__i386__) || defined(__x86_64__)
739		} else if (cfi == &grub2ConfigType) {
740		switch (type) {
741		case LT_KERNEL:
742		return LT_KERNEL_16;
743		case LT_INITRD:
744		return LT_INITRD_16;
745		default:
746		return type;
747		}
748		#endif
749		}
750		return type;
751		}
752
753	static struct keywordTypes * getKeywordByType(enum lineType_e type,	static struct keywordTypes * getKeywordByType(enum lineType_e type,
754	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
755	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
	for (kw = cfi->keywords; kw->key; kw++) {
756	if (kw->type == type)	if (kw->type == type)
757	return kw;	return kw;
758	}	}
#	Line 518  static char * getuuidbydev(char *device)	Line 782  static char * getuuidbydev(char *device)
782
783	static enum lineType_e getTypeByKeyword(char * keyword,	static enum lineType_e getTypeByKeyword(char * keyword,
784	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
785	struct keywordTypes * kw;	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
786	for (kw = cfi->keywords; kw->key; kw++) {	if (cfi->caseInsensitive) {
787	if (!strcmp(keyword, kw->key))	if (!strcasecmp(keyword, kw->key))
788	return kw->type;	return kw->type;
789		} else {
790		if (!strcmp(keyword, kw->key))
791		return kw->type;
792		}
793	}	}
794	return LT_UNKNOWN;	return LT_UNKNOWN;
795	}	}
#	Line 560  static int isEntryStart(struct singleLin	Line 828  static int isEntryStart(struct singleLin
828	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
829	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct singleLine * line) {
830	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it (leaks a byte) */
831	char * title;	char * title = NULL;
832	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
833	title++;	title = strdup(line->elements[0].item);
834	*(title + strlen(title) - 1) = '\0';	title++;
835		*(title + strlen(title) - 1) = '\0';
836		} else if (line->type == LT_MENUENTRY)
837		title = strdup(line->elements[1].item);
838		else
839		return NULL;
840	return title;	return title;
841	}	}
842
#	Line 606  static void lineInit(struct singleLine *	Line 879  static void lineInit(struct singleLine *
879	}	}
880
881	struct singleLine * lineDup(struct singleLine * line) {	struct singleLine * lineDup(struct singleLine * line) {
	int i;
882	struct singleLine * newLine = malloc(sizeof(*newLine));	struct singleLine * newLine = malloc(sizeof(*newLine));
883
884	newLine->indent = strdup(line->indent);	newLine->indent = strdup(line->indent);
#	Line 616  struct singleLine * lineDup(struct singl	Line 888  struct singleLine * lineDup(struct singl
888	newLine->elements = malloc(sizeof(*newLine->elements) *	newLine->elements = malloc(sizeof(*newLine->elements) *
889	newLine->numElements);	newLine->numElements);
890
891	for (i = 0; i < newLine->numElements; i++) {	for (int i = 0; i < newLine->numElements; i++) {
892	newLine->elements[i].indent = strdup(line->elements[i].indent);	newLine->elements[i].indent = strdup(line->elements[i].indent);
893	newLine->elements[i].item = strdup(line->elements[i].item);	newLine->elements[i].item = strdup(line->elements[i].item);
894	}	}
#	Line 625  struct singleLine * lineDup(struct singl	Line 897  struct singleLine * lineDup(struct singl
897	}	}
898
899	static void lineFree(struct singleLine * line) {	static void lineFree(struct singleLine * line) {
	int i;
900	if (line->indent) free(line->indent);	if (line->indent) free(line->indent);
901
902	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
903	free(line->elements[i].item);	free(line->elements[i].item);
904	free(line->elements[i].indent);	free(line->elements[i].indent);
905	}	}
#	Line 640  static void lineFree(struct singleLine *	Line 910  static void lineFree(struct singleLine *
910
911	static int lineWrite(FILE * out, struct singleLine * line,	static int lineWrite(FILE * out, struct singleLine * line,
912	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
	int i;
913	if (fprintf(out, "%s", line->indent) == -1) return -1;	if (fprintf(out, "%s", line->indent) == -1) return -1;
914
915	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
916		/* Need to handle this, because we strip the quotes from
917		* menuentry when read it. */
918		if (line->type == LT_MENUENTRY && i == 1) {
919		if(!isquote(*line->elements[i].item))
920		fprintf(out, "\'%s\'", line->elements[i].item);
921		else
922		fprintf(out, "%s", line->elements[i].item);
923		fprintf(out, "%s", line->elements[i].indent);
924
925		continue;
926		}
927
928	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
929	if (fputc('"', out) == EOF) return -1;	if (fputc('"', out) == EOF) return -1;
930
#	Line 738  static int getNextLine(char ** bufPtr, s	Line 1018  static int getNextLine(char ** bufPtr, s
1018	if (*line->elements[0].item == '#') {	if (*line->elements[0].item == '#') {
1019	char * fullLine;	char * fullLine;
1020	int len;	int len;
	int i;
1021
1022	len = strlen(line->indent);	len = strlen(line->indent);
1023	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1024	len += strlen(line->elements[i].item) +	len += strlen(line->elements[i].item) +
1025	strlen(line->elements[i].indent);	strlen(line->elements[i].indent);
1026
#	Line 750  static int getNextLine(char ** bufPtr, s	Line 1029  static int getNextLine(char ** bufPtr, s
1029	free(line->indent);	free(line->indent);
1030	line->indent = fullLine;	line->indent = fullLine;
1031
1032	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1033	strcat(fullLine, line->elements[i].item);	strcat(fullLine, line->elements[i].item);
1034	strcat(fullLine, line->elements[i].indent);	strcat(fullLine, line->elements[i].indent);
1035	free(line->elements[i].item);	free(line->elements[i].item);
#	Line 769  static int getNextLine(char ** bufPtr, s	Line 1048  static int getNextLine(char ** bufPtr, s
1048	* elements up more	* elements up more
1049	*/	*/
1050	if (!isspace(kw->separatorChar)) {	if (!isspace(kw->separatorChar)) {
	int i;
1051	char indent[2] = "";	char indent[2] = "";
1052	indent[0] = kw->separatorChar;	indent[0] = kw->separatorChar;
1053	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1054	char *p;	char *p;
	int j;
1055	int numNewElements;	int numNewElements;
1056
1057	numNewElements = 0;	numNewElements = 0;
#	Line 790  static int getNextLine(char ** bufPtr, s	Line 1067  static int getNextLine(char ** bufPtr, s
1067	sizeof(*line->elements) * elementsAlloced);	sizeof(*line->elements) * elementsAlloced);
1068	}	}
1069
1070	for (j = line->numElements; j > i; j--) {	for (int j = line->numElements; j > i; j--) {
1071	line->elements[j + numNewElements] = line->elements[j];	line->elements[j + numNewElements] = line->elements[j];
1072	}	}
1073	line->numElements += numNewElements;	line->numElements += numNewElements;
#	Line 803  static int getNextLine(char ** bufPtr, s	Line 1080  static int getNextLine(char ** bufPtr, s
1080	break;	break;
1081	}	}
1082
1083	free(line->elements[i].indent);	line->elements[i + 1].indent = line->elements[i].indent;
1084	line->elements[i].indent = strdup(indent);	line->elements[i].indent = strdup(indent);
1085	*p++ = '\0';	*p++ = '\0';
1086	i++;	i++;
1087	line->elements[i].item = strdup(p);	line->elements[i].item = strdup(p);
	line->elements[i].indent = strdup("");
	p = line->elements[i].item;
1088	}	}
1089	}	}
1090	}	}
#	Line 819  static int getNextLine(char ** bufPtr, s	Line 1094  static int getNextLine(char ** bufPtr, s
1094	return 0;	return 0;
1095	}	}
1096
1097		static int isnumber(const char *s)
1098		{
1099		int i;
1100		for (i = 0; s[i] != '\0'; i++)
1101		if (s[i] < '0' || s[i] > '9')
1102		return 0;
1103		return i;
1104		}
1105
1106	static struct grubConfig * readConfig(const char * inName,	static struct grubConfig * readConfig(const char * inName,
1107	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
1108	int in;	int in;
#	Line 830  static struct grubConfig * readConfig(co	Line 1114  static struct grubConfig * readConfig(co
1114	struct singleLine * last = NULL, * line, * defaultLine = NULL;	struct singleLine * last = NULL, * line, * defaultLine = NULL;
1115	char * end;	char * end;
1116	struct singleEntry * entry = NULL;	struct singleEntry * entry = NULL;
1117	int i, len;	int len;
1118	char * buf;	char * buf;
1119
1120	if (!strcmp(inName, "-")) {	if (inName == NULL) {
1121		printf("Could not find bootloader configuration\n");
1122		exit(1);
1123		} else if (!strcmp(inName, "-")) {
1124	in = 0;	in = 0;
1125	} else {	} else {
1126	if ((in = open(inName, O_RDONLY)) < 0) {	if ((in = open(inName, O_RDONLY)) < 0) {
#	Line 893  static struct grubConfig * readConfig(co	Line 1180  static struct grubConfig * readConfig(co
1180	}	}
1181
1182	if (line->type == LT_SET_VARIABLE) {	if (line->type == LT_SET_VARIABLE) {
	int i;
1183	dbgPrintf("found 'set' command (%d elements): ", line->numElements);	dbgPrintf("found 'set' command (%d elements): ", line->numElements);
1184	dbgPrintf("%s", line->indent);	dbgPrintf("%s", line->indent);
1185	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1186	dbgPrintf("%s\"%s\"", line->elements[i].indent, line->elements[i].item);	dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
1187	dbgPrintf("\n");	dbgPrintf("\n");
1188	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1189	if (kwType && line->numElements == 3 &&	if (kwType && line->numElements == 3 &&
1190	!strcmp(line->elements[1].item, kwType->key)) {	!strcmp(line->elements[1].item, kwType->key) &&
1191		!is_special_grub2_variable(line->elements[2].item)) {
1192	dbgPrintf("Line sets default config\n");	dbgPrintf("Line sets default config\n");
1193	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1194	defaultLine = line;	defaultLine = line;
1195	}	}
	} else if (line->type == LT_DEFAULT && line->numElements == 2) {
	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
	defaultLine = line;
1196
1197	} else if (line->type == LT_KERNEL) {	} else if (iskernel(line->type)) {
1198	/* if by some freak chance this is multiboot and the "module"	/* if by some freak chance this is multiboot and the "module"
1199	* lines came earlier in the template, make sure to use LT_HYPER	* lines came earlier in the template, make sure to use LT_HYPER
1200	* instead of LT_KERNEL now	* instead of LT_KERNEL now
1201	*/	*/
1202	if (entry->multiboot)	if (entry && entry->multiboot)
1203	line->type = LT_HYPER;	line->type = LT_HYPER;
1204
1205	} else if (line->type == LT_MBMODULE) {	} else if (line->type == LT_MBMODULE) {
#	Line 924  static struct grubConfig * readConfig(co	Line 1208  static struct grubConfig * readConfig(co
1208	* This only applies to grub, but that's the only place we	* This only applies to grub, but that's the only place we
1209	* should find LT_MBMODULE lines anyway.	* should find LT_MBMODULE lines anyway.
1210	*/	*/
1211	struct singleLine * l;	for (struct singleLine *l = entry->lines; l; l = l->next) {
	for (l = entry->lines; l; l = l->next) {
1212	if (l->type == LT_HYPER)	if (l->type == LT_HYPER)
1213	break;	break;
1214	else if (l->type == LT_KERNEL) {	else if (iskernel(l->type)) {
1215	l->type = LT_HYPER;	l->type = LT_HYPER;
1216	break;	break;
1217	}	}
#	Line 942  static struct grubConfig * readConfig(co	Line 1225  static struct grubConfig * readConfig(co
1225	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1226	if (*end) cfg->fallbackImage = -1;	if (*end) cfg->fallbackImage = -1;
1227
1228	} else if (line->type == LT_TITLE && line->numElements > 1) {	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1229	/* make the title a single argument (undoing our parsing) */	(line->type == LT_TITLE && line->numElements > 1)) {
1230		/* make the title/default a single argument (undoing our parsing) */
1231	len = 0;	len = 0;
1232	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1233	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
1234	len += strlen(line->elements[i].indent);	len += strlen(line->elements[i].indent);
1235	}	}
1236	buf = malloc(len + 1);	buf = malloc(len + 1);
1237	*buf = '\0';	*buf = '\0';
1238
1239	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1240	strcat(buf, line->elements[i].item);	strcat(buf, line->elements[i].item);
1241	free(line->elements[i].item);	free(line->elements[i].item);
1242
#	Line 966  static struct grubConfig * readConfig(co	Line 1250  static struct grubConfig * readConfig(co
1250	line->elements[line->numElements - 1].indent;	line->elements[line->numElements - 1].indent;
1251	line->elements[1].item = buf;	line->elements[1].item = buf;
1252	line->numElements = 2;	line->numElements = 2;
1253		} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
1254		/* let --remove-kernel="TITLE=what" work */
1255		len = 0;
1256		char *extras;
1257		char *title;
1258
1259		for (int i = 1; i < line->numElements; i++) {
1260		len += strlen(line->elements[i].item);
1261		len += strlen(line->elements[i].indent);
1262		}
1263		buf = malloc(len + 1);
1264		*buf = '\0';
1265
1266		/* allocate mem for extra flags. */
1267		extras = malloc(len + 1);
1268		*extras = '\0';
1269
1270		/* get title. */
1271		for (int i = 0; i < line->numElements; i++) {
1272		if (!strcmp(line->elements[i].item, "menuentry"))
1273		continue;
1274		if (isquote(*line->elements[i].item))
1275		title = line->elements[i].item + 1;
1276		else
1277		title = line->elements[i].item;
1278
1279		len = strlen(title);
1280		if (isquote(title[len-1])) {
1281		strncat(buf, title,len-1);
1282		break;
1283		} else {
1284		strcat(buf, title);
1285		strcat(buf, line->elements[i].indent);
1286		}
1287		}
1288
1289		/* get extras */
1290		int count = 0;
1291		for (int i = 0; i < line->numElements; i++) {
1292		if (count >= 2) {
1293		strcat(extras, line->elements[i].item);
1294		strcat(extras, line->elements[i].indent);
1295		}
1296
1297		if (!strcmp(line->elements[i].item, "menuentry"))
1298		continue;
1299
1300		/* count ' or ", there should be two in menuentry line. */
1301		if (isquote(*line->elements[i].item))
1302		count++;
1303
1304		len = strlen(line->elements[i].item);
1305
1306		if (isquote(line->elements[i].item[len -1]))
1307		count++;
1308
1309		/* ok, we get the final ' or ", others are extras. */
1310		}
1311		line->elements[1].indent =
1312		line->elements[line->numElements - 2].indent;
1313		line->elements[1].item = buf;
1314		line->elements[2].indent =
1315		line->elements[line->numElements - 2].indent;
1316		line->elements[2].item = extras;
1317		line->numElements = 3;
1318	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
1319	/* Strip off any " which may be present; they'll be put back	/* Strip off any " which may be present; they'll be put back
1320	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 975  static struct grubConfig * readConfig(co	Line 1323  static struct grubConfig * readConfig(co
1323	if (line->numElements >= 2) {	if (line->numElements >= 2) {
1324	int last, len;	int last, len;
1325
1326	if (*line->elements[1].item == '"')	if (isquote(*line->elements[1].item))
1327	memmove(line->elements[1].item, line->elements[1].item + 1,	memmove(line->elements[1].item, line->elements[1].item + 1,
1328	strlen(line->elements[1].item + 1) + 1);	strlen(line->elements[1].item + 1) + 1);
1329
1330	last = line->numElements - 1;	last = line->numElements - 1;
1331	len = strlen(line->elements[last].item) - 1;	len = strlen(line->elements[last].item) - 1;
1332	if (line->elements[last].item[len] == '"')	if (isquote(line->elements[last].item[len]))
1333	line->elements[last].item[len] = '\0';	line->elements[last].item[len] = '\0';
1334	}	}
1335	}	}
1336
1337		if (line->type == LT_DEFAULT && line->numElements == 2) {
1338		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1339		defaultLine = line;
1340		}
1341
1342	/* If we find a generic config option which should live at the	/* If we find a generic config option which should live at the
1343	top of the file, move it there. Old versions of grubby were	top of the file, move it there. Old versions of grubby were
1344	probably responsible for putting new images in the wrong	probably responsible for putting new images in the wrong
#	Line 1040  static struct grubConfig * readConfig(co	Line 1393  static struct grubConfig * readConfig(co
1393
1394	dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");	dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");
1395	if (defaultLine) {	if (defaultLine) {
1396	if (cfi->defaultIsVariable) {	if (defaultLine->numElements > 2 &&
1397		cfi->defaultSupportSaved &&
1398		!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1399		cfg->cfi->defaultIsSaved = 1;
1400		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1401		if (cfg->cfi->getEnv) {
1402		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1403		if (defTitle) {
1404		int index = 0;
1405		if (isnumber(defTitle)) {
1406		index = atoi(defTitle);
1407		entry = findEntryByIndex(cfg, index);
1408		} else {
1409		entry = findEntryByTitle(cfg, defTitle, &index);
1410		}
1411		if (entry)
1412		cfg->defaultImage = index;
1413		}
1414		}
1415		} else if (cfi->defaultIsVariable) {
1416	char *value = defaultLine->elements[2].item;	char *value = defaultLine->elements[2].item;
1417	while (*value && (*value == '"' || *value == '\'' ||	while (*value && (*value == '"' || *value == '\'' ||
1418	*value == ' ' || *value == '\t'))	*value == ' ' || *value == '\t'))
#	Line 1057  static struct grubConfig * readConfig(co	Line 1429  static struct grubConfig * readConfig(co
1429	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
1430	if (*end) cfg->defaultImage = -1;	if (*end) cfg->defaultImage = -1;
1431	} else if (defaultLine->numElements >= 2) {	} else if (defaultLine->numElements >= 2) {
1432	i = 0;	int i = 0;
1433	while ((entry = findEntryByIndex(cfg, i))) {	while ((entry = findEntryByIndex(cfg, i))) {
1434	for (line = entry->lines; line; line = line->next)	for (line = entry->lines; line; line = line->next)
1435	if (line->type == LT_TITLE) break;	if (line->type == LT_TITLE) break;
#	Line 1080  static struct grubConfig * readConfig(co	Line 1452  static struct grubConfig * readConfig(co
1452	cfg->defaultImage = -1;	cfg->defaultImage = -1;
1453	}	}
1454	}	}
1455		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1456		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1457		if (defTitle) {
1458		int index = 0;
1459		if (isnumber(defTitle)) {
1460		index = atoi(defTitle);
1461		entry = findEntryByIndex(cfg, index);
1462		} else {
1463		entry = findEntryByTitle(cfg, defTitle, &index);
1464		}
1465		if (entry)
1466		cfg->defaultImage = index;
1467		}
1468	} else {	} else {
1469	cfg->defaultImage = 0;	cfg->defaultImage = 0;
1470	}	}
#	Line 1097  static void writeDefault(FILE * out, cha	Line 1482  static void writeDefault(FILE * out, cha
1482
1483	if (cfg->defaultImage == DEFAULT_SAVED)	if (cfg->defaultImage == DEFAULT_SAVED)
1484	fprintf(out, "%sdefault%ssaved\n", indent, separator);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1485	else if (cfg->defaultImage > -1) {	else if (cfg->cfi->defaultIsSaved) {
1486		fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1487		if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1488		char *title;
1489		entry = findEntryByIndex(cfg, cfg->defaultImage);
1490		line = getLineByType(LT_MENUENTRY, entry->lines);
1491		if (!line)
1492		line = getLineByType(LT_TITLE, entry->lines);
1493		if (line) {
1494		title = extractTitle(line);
1495		if (title)
1496		cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1497		}
1498		}
1499		} else if (cfg->defaultImage > -1) {
1500	if (cfg->cfi->defaultIsIndex) {	if (cfg->cfi->defaultIsIndex) {
1501	if (cfg->cfi->defaultIsVariable) {	if (cfg->cfi->defaultIsVariable) {
1502	fprintf(out, "%sset default=\"%d\"\n", indent,	fprintf(out, "%sset default=\"%d\"\n", indent,
#	Line 1157  static int writeConfig(struct grubConfig	Line 1556  static int writeConfig(struct grubConfig
1556
1557	/* most likely the symlink is relative, so change our	/* most likely the symlink is relative, so change our
1558	directory to the dir of the symlink */	directory to the dir of the symlink */
1559	rc = chdir(dirname(strdupa(outName)));	char *dir = strdupa(outName);
1560		rc = chdir(dirname(dir));
1561	do {	do {
1562	buf = alloca(len + 1);	buf = alloca(len + 1);
1563	rc = readlink(basename(outName), buf, len);	rc = readlink(basename(outName), buf, len);
#	Line 1199  static int writeConfig(struct grubConfig	Line 1599  static int writeConfig(struct grubConfig
1599	while (line) {	while (line) {
1600	if (line->type == LT_SET_VARIABLE && defaultKw &&	if (line->type == LT_SET_VARIABLE && defaultKw &&
1601	line->numElements == 3 &&	line->numElements == 3 &&
1602	!strcmp(line->elements[1].item, defaultKw->key)) {	!strcmp(line->elements[1].item, defaultKw->key) &&
1603		!is_special_grub2_variable(line->elements[2].item)) {
1604	writeDefault(out, line->indent, line->elements[0].indent, cfg);	writeDefault(out, line->indent, line->elements[0].indent, cfg);
1605	needs &= ~MAIN_DEFAULT;	needs &= ~MAIN_DEFAULT;
1606	} else if (line->type == LT_DEFAULT) {	} else if (line->type == LT_DEFAULT) {
#	Line 1295  static char *findDiskForRoot()	Line 1696  static char *findDiskForRoot()
1696	buf[rc] = '\0';	buf[rc] = '\0';
1697	chptr = buf;	chptr = buf;
1698
1699		char *foundanswer = NULL;
1700
1701	while (chptr && chptr != buf+rc) {	while (chptr && chptr != buf+rc) {
1702	devname = chptr;	devname = chptr;
1703
#	Line 1322  static char *findDiskForRoot()	Line 1725  static char *findDiskForRoot()
1725	* for '/' obviously.	* for '/' obviously.
1726	*/	*/
1727	if (*(++chptr) == '/' && *(++chptr) == ' ') {	if (*(++chptr) == '/' && *(++chptr) == ' ') {
1728	/*	/* remember the last / entry in mtab */
1729	* 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);
1730	}	}
1731
1732	/* Next line */	/* Next line */
#	Line 1337  static char *findDiskForRoot()	Line 1735  static char *findDiskForRoot()
1735	chptr++;	chptr++;
1736	}	}
1737
1738		/* Return the last / entry found */
1739		if (foundanswer) {
1740		chptr = strchr(foundanswer, ' ');
1741		*chptr = '\0';
1742		return strdup(foundanswer);
1743		}
1744
1745	return NULL;	return NULL;
1746	}	}
1747
1748	void printEntry(struct singleEntry * entry) {	void printEntry(struct singleEntry * entry, FILE *f) {
1749	int i;	int i;
1750	struct singleLine * line;	struct singleLine * line;
1751
1752	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
1753	fprintf(stderr, "DBG: %s", line->indent);	log_message(f, "DBG: %s", line->indent);
1754	for (i = 0; i < line->numElements; i++) {	for (i = 0; i < line->numElements; i++) {
1755	fprintf(stderr, "%s%s",	/* Need to handle this, because we strip the quotes from
1756		* menuentry when read it. */
1757		if (line->type == LT_MENUENTRY && i == 1) {
1758		if(!isquote(*line->elements[i].item))
1759		log_message(f, "\'%s\'", line->elements[i].item);
1760		else
1761		log_message(f, "%s", line->elements[i].item);
1762		log_message(f, "%s", line->elements[i].indent);
1763
1764		continue;
1765		}
1766
1767		log_message(f, "%s%s",
1768	line->elements[i].item, line->elements[i].indent);	line->elements[i].item, line->elements[i].indent);
1769	}	}
1770	fprintf(stderr, "\n");	log_message(f, "\n");
1771	}	}
1772	}	}
1773
1774	void notSuitablePrintf(struct singleEntry * entry, const char *fmt, ...)	void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1775	{	{
1776	va_list argp;	static int once;
1777		va_list argp, argq;
1778
1779	if (!debug)	va_start(argp, fmt);
1780
1781		va_copy(argq, argp);
1782		if (!once) {
1783		log_time(NULL);
1784		log_message(NULL, "command line: %s\n", saved_command_line);
1785		}
1786		log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1787		log_vmessage(NULL, fmt, argq);
1788
1789		printEntry(entry, NULL);
1790		va_end(argq);
1791
1792		if (!debug) {
1793		once = 1;
1794		va_end(argp);
1795	return;	return;
1796		}
1797
1798	va_start(argp, fmt);	if (okay) {
1799		va_end(argp);
1800		return;
1801		}
1802
1803		if (!once)
1804		log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1805		once = 1;
1806	fprintf(stderr, "DBG: Image entry failed: ");	fprintf(stderr, "DBG: Image entry failed: ");
1807	vfprintf(stderr, fmt, argp);	vfprintf(stderr, fmt, argp);
1808	printEntry(entry);	printEntry(entry, stderr);
1809	va_end(argp);	va_end(argp);
1810	}	}
1811
1812		#define beginswith(s, c) ((s) && (s)[0] == (c))
1813
1814		static int endswith(const char *s, char c)
1815		{
1816		int slen;
1817
1818		if (!s || !s[0])
1819		return 0;
1820		slen = strlen(s) - 1;
1821
1822		return s[slen] == c;
1823		}
1824
1825	int suitableImage(struct singleEntry * entry, const char * bootPrefix,	int suitableImage(struct singleEntry * entry, const char * bootPrefix,
1826	int skipRemoved, int flags) {	int skipRemoved, int flags) {
1827	struct singleLine * line;	struct singleLine * line;
#	Line 1378  int suitableImage(struct singleEntry * e	Line 1832  int suitableImage(struct singleEntry * e
1832	char * rootdev;	char * rootdev;
1833
1834	if (skipRemoved && entry->skip) {	if (skipRemoved && entry->skip) {
1835	notSuitablePrintf(entry, "marked to skip\n");	notSuitablePrintf(entry, 0, "marked to skip\n");
1836	return 0;	return 0;
1837	}	}
1838
1839	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1840	if (!line) {	if (!line) {
1841	notSuitablePrintf(entry, "no line found\n");	notSuitablePrintf(entry, 0, "no line found\n");
1842	return 0;	return 0;
1843	}	}
1844	if (line->numElements < 2) {	if (line->numElements < 2) {
1845	notSuitablePrintf(entry, "line has only %d elements\n",	notSuitablePrintf(entry, 0, "line has only %d elements\n",
1846	line->numElements);	line->numElements);
1847	return 0;	return 0;
1848	}	}
1849
1850	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	if (flags & GRUBBY_BADIMAGE_OKAY) {
1851		notSuitablePrintf(entry, 1, "\n");
1852		return 1;
1853		}
1854
1855	fullName = alloca(strlen(bootPrefix) +	fullName = alloca(strlen(bootPrefix) +
1856	strlen(line->elements[1].item) + 1);	strlen(line->elements[1].item) + 1);
1857	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
1858	sprintf(fullName, "%s%s", bootPrefix,	int rootspec_offset = rootspec ? strlen(rootspec) : 0;
1859	line->elements[1].item + (rootspec ? strlen(rootspec) : 0));	int hasslash = endswith(bootPrefix, '/') ||
1860		beginswith(line->elements[1].item + rootspec_offset, '/');
1861		sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1862		line->elements[1].item + rootspec_offset);
1863	if (access(fullName, R_OK)) {	if (access(fullName, R_OK)) {
1864	notSuitablePrintf(entry, "access to %s failed\n", fullName);	notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1865	return 0;	return 0;
1866	}	}
1867	for (i = 2; i < line->numElements; i++)	for (i = 2; i < line->numElements; i++)
#	Line 1422  int suitableImage(struct singleEntry * e	Line 1882  int suitableImage(struct singleEntry * e
1882
1883	/* failed to find one */	/* failed to find one */
1884	if (!line) {	if (!line) {
1885	notSuitablePrintf(entry, "no line found\n");	notSuitablePrintf(entry, 0, "no line found\n");
1886	return 0;	return 0;
1887	}	}
1888
#	Line 1431  int suitableImage(struct singleEntry * e	Line 1891  int suitableImage(struct singleEntry * e
1891	if (i < line->numElements)	if (i < line->numElements)
1892	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1893	else {	else {
1894	notSuitablePrintf(entry, "no root= entry found\n");	notSuitablePrintf(entry, 0, "no root= entry found\n");
1895	/* it failed too...  can't find root= */	/* it failed too...  can't find root= */
1896	return 0;	return 0;
1897	}	}
#	Line 1440  int suitableImage(struct singleEntry * e	Line 1900  int suitableImage(struct singleEntry * e
1900
1901	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1902	if (!getpathbyspec(dev)) {	if (!getpathbyspec(dev)) {
1903	notSuitablePrintf(entry, "can't find blkid entry for %s\n", dev);	notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1904	return 0;	return 0;
1905	} else	} else
1906	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1907
1908	rootdev = findDiskForRoot();	rootdev = findDiskForRoot();
1909	if (!rootdev) {	if (!rootdev) {
1910	notSuitablePrintf(entry, "can't find root device\n");	notSuitablePrintf(entry, 0, "can't find root device\n");
1911	return 0;	return 0;
1912	}	}
1913
1914	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1915	notSuitablePrintf(entry, "uuid missing: rootdev %s, dev %s\n",	notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1916	getuuidbydev(rootdev), getuuidbydev(dev));	getuuidbydev(rootdev), getuuidbydev(dev));
1917	free(rootdev);	free(rootdev);
1918	return 0;	return 0;
1919	}	}
1920
1921	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1922	notSuitablePrintf(entry, "uuid mismatch: rootdev %s, dev %s\n",	notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1923	getuuidbydev(rootdev), getuuidbydev(dev));	getuuidbydev(rootdev), getuuidbydev(dev));
1924	free(rootdev);	free(rootdev);
1925	return 0;	return 0;
1926	}	}
1927
1928	free(rootdev);	free(rootdev);
1929		notSuitablePrintf(entry, 1, "\n");
1930
1931	return 1;	return 1;
1932	}	}
#	Line 1499  struct singleEntry * findEntryByPath(str	Line 1960  struct singleEntry * findEntryByPath(str
1960	}	}
1961
1962	indexVars[i + 1] = -1;	indexVars[i + 1] = -1;
1963
1964	i = 0;	i = 0;
1965	if (index) {	if (index) {
1966	while (i < *index) i++;	while (i < *index) {
1967	if (indexVars[i] == -1) return NULL;	i++;
1968		if (indexVars[i] == -1) return NULL;
1969		}
1970	}	}
1971
1972	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
1973	if (!entry) return NULL;	if (!entry) return NULL;
1974
1975	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1976	if (!line) return NULL;	if (!line) return NULL;
1977
1978	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1547  struct singleEntry * findEntryByPath(str	Line 2010  struct singleEntry * findEntryByPath(str
2010
2011	if (!strncmp(kernel, "TITLE=", 6)) {	if (!strncmp(kernel, "TITLE=", 6)) {
2012	prefix = "";	prefix = "";
2013	checkType = LT_TITLE;	checkType = LT_TITLE|LT_MENUENTRY;
2014	kernel += 6;	kernel += 6;
2015	}	}
2016
#	Line 1558  struct singleEntry * findEntryByPath(str	Line 2021  struct singleEntry * findEntryByPath(str
2021
2022	/* check all the lines matching checkType */	/* check all the lines matching checkType */
2023	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
2024	line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?	enum lineType_e ct = checkType;
2025	LT_KERNEL|LT_MBMODULE|LT_HYPER :	if (entry->multiboot && checkType == LT_KERNEL)
2026	checkType, line);	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2027	if (!line) break;  /* not found in this entry */	else if (checkType & LT_KERNEL)
2028		ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2029		line = getLineByType(ct, line);
2030		if (!line)
2031		break;  /* not found in this entry */
2032
2033	if (line && line->numElements >= 2) {	if (line && line->type != LT_MENUENTRY &&
2034		line->numElements >= 2) {
2035	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
2036	if (!strcmp(line->elements[1].item +	if (!strcmp(line->elements[1].item +
2037	((rootspec != NULL) ? strlen(rootspec) : 0),	((rootspec != NULL) ? strlen(rootspec) : 0),
2038	kernel + strlen(prefix)))	kernel + strlen(prefix)))
2039	break;	break;
2040	}	}
2041		if(line->type == LT_MENUENTRY &&
2042		!strcmp(line->elements[1].item, kernel))
2043		break;
2044	}	}
2045
2046	/* make sure this entry has a kernel identifier; this skips	/* make sure this entry has a kernel identifier; this skips
2047	* non-Linux boot entries (could find netbsd etc, though, which is	* non-Linux boot entries (could find netbsd etc, though, which is
2048	* unfortunate)	* unfortunate)
2049	*/	*/
2050	if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2051	break; /* found 'im! */	break; /* found 'im! */
2052	}	}
2053
#	Line 1586  struct singleEntry * findEntryByPath(str	Line 2057  struct singleEntry * findEntryByPath(str
2057	return entry;	return entry;
2058	}	}
2059
2060		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2061		int * index) {
2062		struct singleEntry * entry;
2063		struct singleLine * line;
2064		int i;
2065		char * newtitle;
2066
2067		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2068		if (index && i < *index)
2069		continue;
2070		line = getLineByType(LT_TITLE, entry->lines);
2071		if (!line)
2072		line = getLineByType(LT_MENUENTRY, entry->lines);
2073		if (!line)
2074		continue;
2075		newtitle = grub2ExtractTitle(line);
2076		if (!newtitle)
2077		continue;
2078		if (!strcmp(title, newtitle))
2079		break;
2080		}
2081
2082		if (!entry)
2083		return NULL;
2084
2085		if (index)
2086		*index = i;
2087		return entry;
2088		}
2089
2090	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2091	struct singleEntry * entry;	struct singleEntry * entry;
2092
#	Line 1608  struct singleEntry * findTemplate(struct	Line 2109  struct singleEntry * findTemplate(struct
2109	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2110	int index;	int index;
2111
2112	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2113		if (cfg->cfi->getEnv) {
2114		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2115		if (defTitle) {
2116		int index = 0;
2117		if (isnumber(defTitle)) {
2118		index = atoi(defTitle);
2119		entry = findEntryByIndex(cfg, index);
2120		} else {
2121		entry = findEntryByTitle(cfg, defTitle, &index);
2122		}
2123		if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2124		cfg->defaultImage = index;
2125		if (indexPtr)
2126		*indexPtr = index;
2127		return entry;
2128		}
2129		}
2130		}
2131		} else if (cfg->defaultImage > -1) {
2132	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2133	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2134	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1661  void markRemovedImage(struct grubConfig	Line 2181  void markRemovedImage(struct grubConfig
2181	const char * prefix) {	const char * prefix) {
2182	struct singleEntry * entry;	struct singleEntry * entry;
2183
2184	if (!image) return;	if (!image)
2185		return;
2186
2187		/* check and see if we're removing the default image */
2188		if (isdigit(*image)) {
2189		entry = findEntryByPath(cfg, image, prefix, NULL);
2190		if(entry)
2191		entry->skip = 1;
2192		return;
2193		}
2194
2195	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2196	entry->skip = 1;	entry->skip = 1;
#	Line 1669  void markRemovedImage(struct grubConfig	Line 2198  void markRemovedImage(struct grubConfig
2198
2199	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2200	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2201	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2202	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2203	int i, j;	int i, j;
2204
2205	if (newIsDefault) {	if (newIsDefault) {
2206	config->defaultImage = 0;	config->defaultImage = 0;
2207	return;	return;
2208		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2209		if (findEntryByIndex(config, index))
2210		config->defaultImage = index;
2211		else
2212		config->defaultImage = -1;
2213		return;
2214	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2215	i = 0;	i = 0;
2216	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1688  void setDefaultImage(struct grubConfig *	Line 2223  void setDefaultImage(struct grubConfig *
2223
2224	/* defaultImage now points to what we'd like to use, but before any order	/* defaultImage now points to what we'd like to use, but before any order
2225	changes */	changes */
2226	if (config->defaultImage == DEFAULT_SAVED)	if ((config->defaultImage == DEFAULT_SAVED) ||
2227		(config->defaultImage == DEFAULT_SAVED_GRUB2))
2228	/* default is set to saved, we don't want to change it */	/* default is set to saved, we don't want to change it */
2229	return;	return;
2230
#	Line 1746  void displayEntry(struct singleEntry * e	Line 2282  void displayEntry(struct singleEntry * e
2282	struct singleLine * line;	struct singleLine * line;
2283	char * root = NULL;	char * root = NULL;
2284	int i;	int i;
2285		int j;
2286
2287	printf("index=%d\n", index);	printf("index=%d\n", index);
2288
2289	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2290	if (!line) {	if (!line) {
2291	printf("non linux entry\n");	printf("non linux entry\n");
2292	return;	return;
2293	}	}
2294
2295	printf("kernel=%s\n", line->elements[1].item);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2296		printf("kernel=%s\n", line->elements[1].item);
2297		else
2298		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2299
2300	if (line->numElements >= 3) {	if (line->numElements >= 3) {
2301	printf("args=\"");	printf("args=\"");
#	Line 1811  void displayEntry(struct singleEntry * e	Line 2351  void displayEntry(struct singleEntry * e
2351	printf("root=%s\n", s);	printf("root=%s\n", s);
2352	}	}
2353
2354	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2355
2356	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
2357	printf("initrd=%s", prefix);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2358		printf("initrd=");
2359		else
2360		printf("initrd=%s", prefix);
2361
2362	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
2363	printf("%s%s", line->elements[i].item, line->elements[i].indent);	printf("%s%s", line->elements[i].item, line->elements[i].indent);
2364	printf("\n");	printf("\n");
2365	}	}
2366
2367		line = getLineByType(LT_TITLE, entry->lines);
2368		if (line) {
2369		printf("title=%s\n", line->elements[1].item);
2370		} else {
2371		char * title;
2372		line = getLineByType(LT_MENUENTRY, entry->lines);
2373		title = grub2ExtractTitle(line);
2374		if (title)
2375		printf("title=%s\n", title);
2376		}
2377
2378		for (j = 0, line = entry->lines; line; line = line->next) {
2379		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2380		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2381		printf("mbmodule%d=", j);
2382		else
2383		printf("mbmodule%d=%s", j, prefix);
2384
2385		for (i = 1; i < line->numElements; i++)
2386		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2387		printf("\n");
2388		j++;
2389		}
2390		}
2391		}
2392
2393		int isSuseSystem(void) {
2394		const char * path;
2395		const static char default_path[] = "/etc/SuSE-release";
2396
2397		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2398		path = default_path;
2399
2400		if (!access(path, R_OK))
2401		return 1;
2402		return 0;
2403		}
2404
2405		int isSuseGrubConf(const char * path) {
2406		FILE * grubConf;
2407		char * line = NULL;
2408		size_t len = 0, res = 0;
2409
2410		grubConf = fopen(path, "r");
2411		if (!grubConf) {
2412		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2413		return 0;
2414		}
2415
2416		while ((res = getline(&line, &len, grubConf)) != -1) {
2417		if (!strncmp(line, "setup", 5)) {
2418		fclose(grubConf);
2419		free(line);
2420		return 1;
2421		}
2422		}
2423
2424		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2425		path);
2426
2427		fclose(grubConf);
2428		free(line);
2429		return 0;
2430		}
2431
2432		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2433		FILE * grubConf;
2434		char * line = NULL;
2435		size_t res = 0, len = 0;
2436
2437		if (!path) return 1;
2438		if (!lbaPtr) return 1;
2439
2440		grubConf = fopen(path, "r");
2441		if (!grubConf) return 1;
2442
2443		while ((res = getline(&line, &len, grubConf)) != -1) {
2444		if (line[res - 1] == '\n')
2445		line[res - 1] = '\0';
2446		else if (len > res)
2447		line[res] = '\0';
2448		else {
2449		line = realloc(line, res + 1);
2450		line[res] = '\0';
2451		}
2452
2453		if (!strncmp(line, "setup", 5)) {
2454		if (strstr(line, "--force-lba")) {
2455		*lbaPtr = 1;
2456		} else {
2457		*lbaPtr = 0;
2458		}
2459		dbgPrintf("lba: %i\n", *lbaPtr);
2460		break;
2461		}
2462		}
2463
2464		free(line);
2465		fclose(grubConf);
2466		return 0;
2467		}
2468
2469		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2470		FILE * grubConf;
2471		char * line = NULL;
2472		size_t res = 0, len = 0;
2473		char * lastParamPtr = NULL;
2474		char * secLastParamPtr = NULL;
2475		char installDeviceNumber = '\0';
2476		char * bounds = NULL;
2477
2478		if (!path) return 1;
2479		if (!devicePtr) return 1;
2480
2481		grubConf = fopen(path, "r");
2482		if (!grubConf) return 1;
2483
2484		while ((res = getline(&line, &len, grubConf)) != -1) {
2485		if (strncmp(line, "setup", 5))
2486		continue;
2487
2488		if (line[res - 1] == '\n')
2489		line[res - 1] = '\0';
2490		else if (len > res)
2491		line[res] = '\0';
2492		else {
2493		line = realloc(line, res + 1);
2494		line[res] = '\0';
2495		}
2496
2497		lastParamPtr = bounds = line + res;
2498
2499		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2500		while (!isspace(*lastParamPtr))
2501		lastParamPtr--;
2502		lastParamPtr++;
2503
2504		secLastParamPtr = lastParamPtr - 2;
2505		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2506
2507		if (lastParamPtr + 3 > bounds) {
2508		dbgPrintf("lastParamPtr going over boundary");
2509		fclose(grubConf);
2510		free(line);
2511		return 1;
2512		}
2513		if (!strncmp(lastParamPtr, "(hd", 3))
2514		lastParamPtr += 3;
2515		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2516
2517		/*
2518		* Second last parameter will decide wether last parameter is
2519		* an IMAGE_DEVICE or INSTALL_DEVICE
2520		*/
2521		while (!isspace(*secLastParamPtr))
2522		secLastParamPtr--;
2523		secLastParamPtr++;
2524
2525		if (secLastParamPtr + 3 > bounds) {
2526		dbgPrintf("secLastParamPtr going over boundary");
2527		fclose(grubConf);
2528		free(line);
2529		return 1;
2530		}
2531		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2532		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2533		secLastParamPtr += 3;
2534		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2535		installDeviceNumber = *secLastParamPtr;
2536		} else {
2537		installDeviceNumber = *lastParamPtr;
2538		}
2539
2540		*devicePtr = malloc(6);
2541		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2542		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2543		fclose(grubConf);
2544		free(line);
2545		return 0;
2546		}
2547
2548		free(line);
2549		fclose(grubConf);
2550		return 1;
2551		}
2552
2553		int grubGetBootFromDeviceMap(const char * device,
2554		char ** bootPtr) {
2555		FILE * deviceMap;
2556		char * line = NULL;
2557		size_t res = 0, len = 0;
2558		char * devicePtr;
2559		char * bounds = NULL;
2560		const char * path;
2561		const static char default_path[] = "/boot/grub/device.map";
2562
2563		if (!device) return 1;
2564		if (!bootPtr) return 1;
2565
2566		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2567		path = default_path;
2568
2569		dbgPrintf("opening grub device.map file from: %s\n", path);
2570		deviceMap = fopen(path, "r");
2571		if (!deviceMap)
2572		return 1;
2573
2574		while ((res = getline(&line, &len, deviceMap)) != -1) {
2575		if (!strncmp(line, "#", 1))
2576		continue;
2577
2578		if (line[res - 1] == '\n')
2579		line[res - 1] = '\0';
2580		else if (len > res)
2581		line[res] = '\0';
2582		else {
2583		line = realloc(line, res + 1);
2584		line[res] = '\0';
2585		}
2586
2587		devicePtr = line;
2588		bounds = line + res;
2589
2590		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2591		devicePtr++;
2592		dbgPrintf("device: %s\n", devicePtr);
2593
2594		if (!strncmp(devicePtr, device, strlen(device))) {
2595		devicePtr += strlen(device);
2596		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2597		devicePtr++;
2598
2599		*bootPtr = strdup(devicePtr);
2600		break;
2601		}
2602		}
2603
2604		free(line);
2605		fclose(deviceMap);
2606		return 0;
2607		}
2608
2609		int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2610		char * grubDevice;
2611
2612		if (suseGrubConfGetInstallDevice(path, &grubDevice))
2613		dbgPrintf("error looking for grub installation device\n");
2614		else
2615		dbgPrintf("grubby installation device: %s\n", grubDevice);
2616
2617		if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2618		dbgPrintf("error looking for grub boot device\n");
2619		else
2620		dbgPrintf("grubby boot device: %s\n", *bootPtr);
2621
2622		free(grubDevice);
2623		return 0;
2624		}
2625
2626		int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2627		/*
2628		* This SuSE grub configuration file at this location is not your average
2629		* grub configuration file, but instead the grub commands used to setup
2630		* grub on that system.
2631		*/
2632		const char * path;
2633		const static char default_path[] = "/etc/grub.conf";
2634
2635		if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2636		path = default_path;
2637
2638		if (!isSuseGrubConf(path)) return 1;
2639
2640		if (lbaPtr) {
2641		*lbaPtr = 0;
2642		if (suseGrubConfGetLba(path, lbaPtr))
2643		return 1;
2644		}
2645
2646		if (bootPtr) {
2647		*bootPtr = NULL;
2648		suseGrubConfGetBoot(path, bootPtr);
2649		}
2650
2651		return 0;
2652	}	}
2653
2654	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
#	Line 1869  int parseSysconfigGrub(int * lbaPtr, cha	Line 2699  int parseSysconfigGrub(int * lbaPtr, cha
2699	}	}
2700
2701	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2702	char * boot;	char * boot = NULL;
2703	int lba;	int lba;
2704
2705	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2706	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2707	if (boot) printf("boot=%s\n", boot);	free(boot);
2708		return;
2709		}
2710		} else {
2711		if (parseSysconfigGrub(&lba, &boot)) {
2712		free(boot);
2713		return;
2714		}
2715		}
2716
2717		if (lba) printf("lba\n");
2718		if (boot) {
2719		printf("boot=%s\n", boot);
2720		free(boot);
2721	}	}
2722	}	}
2723
#	Line 1923  struct singleLine * addLineTmpl(struct s	Line 2766  struct singleLine * addLineTmpl(struct s
2766	{	{
2767	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2768
2769		if (isEfi && cfi == &grub2ConfigType) {
2770		enum lineType_e old = newLine->type;
2771		newLine->type = preferredLineType(newLine->type, cfi);
2772		if (old != newLine->type)
2773		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2774		}
2775
2776	if (val) {	if (val) {
2777	/* override the inherited value with our own.	/* override the inherited value with our own.
2778	* 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 1932  struct singleLine * addLineTmpl(struct s	Line 2782  struct singleLine * addLineTmpl(struct s
2782	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2783
2784	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2785	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)) {
2786	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2787	if (rootspec != NULL) {	if (rootspec != NULL) {
2788	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 1969  struct singleLine *  addLine(struct sing	Line 2819  struct singleLine *  addLine(struct sing
2819	/* 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
2820	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2821	*/	*/
2822	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2823	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2824	tmpl.type = type;	tmpl.type = type;
#	Line 2073  void removeLine(struct singleEntry * ent	Line 2922  void removeLine(struct singleEntry * ent
2922	free(line);	free(line);
2923	}	}
2924
	static int isquote(char q)
	{
	if (q == '\'' || q == '\"')
	return 1;
	return 0;
	}
2925	static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)	static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
2926	{	{
2927	struct singleLine newLine = {	struct singleLine newLine = {
#	Line 2310  int updateActualImage(struct grubConfig	Line 3152  int updateActualImage(struct grubConfig
3152	firstElement = 2;	firstElement = 2;
3153
3154	} else {	} else {
3155	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3156	if (!line) {	if (!line) {
3157	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3158	continue;	continue;
#	Line 2466  int updateImage(struct grubConfig * cfg,	Line 3308  int updateImage(struct grubConfig * cfg,
3308	return rc;	return rc;
3309	}	}
3310
3311		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3312		const char * image, const char * prefix, const char * initrd,
3313		const char * title) {
3314		struct singleEntry * entry;
3315		struct singleLine * line, * kernelLine, *endLine = NULL;
3316		int index = 0;
3317
3318		if (!image) return 0;
3319
3320		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3321		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3322		if (!kernelLine) continue;
3323
3324		/* if title is supplied, the entry's title must match it. */
3325		if (title) {
3326		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3327		char *linetitle = extractTitle(line);
3328
3329		if (!linetitle)
3330		continue;
3331		if (strcmp(title, linetitle)) {
3332		free(linetitle);
3333		continue;
3334		}
3335		free(linetitle);
3336		}
3337
3338		if (prefix) {
3339		int prefixLen = strlen(prefix);
3340		if (!strncmp(initrd, prefix, prefixLen))
3341		initrd += prefixLen;
3342		}
3343		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3344		if (endLine)
3345		removeLine(entry, endLine);
3346		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3347		kernelLine->indent, initrd);
3348		if (!line)
3349		return 1;
3350		if (endLine) {
3351		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3352		if (!line)
3353		return 1;
3354		}
3355
3356		break;
3357		}
3358
3359		return 0;
3360		}
3361
3362	int updateInitrd(struct grubConfig * cfg, const char * image,	int updateInitrd(struct grubConfig * cfg, const char * image,
3363	const char * prefix, const char * initrd) {	const char * prefix, const char * initrd, const char * title) {
3364	struct singleEntry * entry;	struct singleEntry * entry;
3365	struct singleLine * line, * kernelLine, *endLine = NULL;	struct singleLine * line, * kernelLine, *endLine = NULL;
3366	int index = 0;	int index = 0;
#	Line 2475  int updateInitrd(struct grubConfig * cfg	Line 3368  int updateInitrd(struct grubConfig * cfg
3368	if (!image) return 0;	if (!image) return 0;
3369
3370	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3371	kernelLine = getLineByType(LT_KERNEL, entry->lines);	kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3372	if (!kernelLine) continue;	if (!kernelLine) continue;
3373
3374	line = getLineByType(LT_INITRD, entry->lines);	/* if title is supplied, the entry's title must match it. */
3375		if (title) {
3376		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3377		char *linetitle = extractTitle(line);
3378
3379		if (!linetitle)
3380		continue;
3381		if (strcmp(title, linetitle)) {
3382		free(linetitle);
3383		continue;
3384		}
3385		free(linetitle);
3386		}
3387
3388		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3389	if (line)	if (line)
3390	removeLine(entry, line);	removeLine(entry, line);
3391	if (prefix) {	if (prefix) {
#	Line 2489  int updateInitrd(struct grubConfig * cfg	Line 3396  int updateInitrd(struct grubConfig * cfg
3396	endLine = getLineByType(LT_ENTRY_END, entry->lines);	endLine = getLineByType(LT_ENTRY_END, entry->lines);
3397	if (endLine)	if (endLine)
3398	removeLine(entry, endLine);	removeLine(entry, endLine);
3399	line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);	enum lineType_e lt;
3400		switch(kernelLine->type) {
3401		case LT_KERNEL:
3402		lt = LT_INITRD;
3403		break;
3404		case LT_KERNEL_EFI:
3405		lt = LT_INITRD_EFI;
3406		break;
3407		case LT_KERNEL_16:
3408		lt = LT_INITRD_16;
3409		break;
3410		default:
3411		lt = preferredLineType(LT_INITRD, cfg->cfi);
3412		}
3413		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3414	if (!line)	if (!line)
3415	return 1;	return 1;
3416	if (endLine) {	if (endLine) {
#	Line 2695  int checkForGrub(struct grubConfig * con	Line 3616  int checkForGrub(struct grubConfig * con
3616	int fd;	int fd;
3617	unsigned char bootSect[512];	unsigned char bootSect[512];
3618	char * boot;	char * boot;
3619		int onSuse = isSuseSystem();
3620
3621	if (parseSysconfigGrub(NULL, &boot))
3622	return 0;	if (onSuse) {
3623		if (parseSuseGrubConf(NULL, &boot))
3624		return 0;
3625		} else {
3626		if (parseSysconfigGrub(NULL, &boot))
3627		return 0;
3628		}
3629
3630	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3631	if (!boot)	if (!boot)
#	Line 2716  int checkForGrub(struct grubConfig * con	Line 3644  int checkForGrub(struct grubConfig * con
3644	}	}
3645	close(fd);	close(fd);
3646
3647		/* The more elaborate checks do not work on SuSE. The checks done
3648		* seem to be reasonble (at least for now), so just return success
3649		*/
3650		if (onSuse)
3651		return 2;
3652
3653	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3654	}	}
3655
#	Line 2749  int checkForExtLinux(struct grubConfig *	Line 3683  int checkForExtLinux(struct grubConfig *
3683	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3684	}	}
3685
3686		int checkForYaboot(struct grubConfig * config) {
3687		/*
3688		* This is a simplistic check that we consider good enough for own puporses
3689		*
3690		* If we were to properly check if yaboot is *installed* we'd need to:
3691		* 1) get the system boot device (LT_BOOT)
3692		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3693		*    the content on the boot device
3694		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3695		* 4) check again if binary and boot device contents match
3696		*/
3697		if (!access("/etc/yaboot.conf", R_OK))
3698		return 2;
3699
3700		return 1;
3701		}
3702
3703		int checkForElilo(struct grubConfig * config) {
3704		if (!access("/etc/elilo.conf", R_OK))
3705		return 2;
3706
3707		return 1;
3708		}
3709
3710	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3711	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3712
#	Line 2763  static char * getRootSpecifier(char * st	Line 3721  static char * getRootSpecifier(char * st
3721	static char * getInitrdVal(struct grubConfig * config,	static char * getInitrdVal(struct grubConfig * config,
3722	const char * prefix, struct singleLine *tmplLine,	const char * prefix, struct singleLine *tmplLine,
3723	const char * newKernelInitrd,	const char * newKernelInitrd,
3724	char ** extraInitrds, int extraInitrdCount)	const char ** extraInitrds, int extraInitrdCount)
3725	{	{
3726	char *initrdVal, *end;	char *initrdVal, *end;
3727	int i;	int i;
#	Line 2808  static char * getInitrdVal(struct grubCo	Line 3766  static char * getInitrdVal(struct grubCo
3766
3767	int addNewKernel(struct grubConfig * config, struct singleEntry * template,	int addNewKernel(struct grubConfig * config, struct singleEntry * template,
3768	const char * prefix,	const char * prefix,
3769	char * newKernelPath, char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3770	char * newKernelArgs, char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3771	char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3772	char * newMBKernel, char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs,
3773		const char * newDevTreePath) {
3774	struct singleEntry * new;	struct singleEntry * new;
3775	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3776	int needs;	int needs;
#	Line 2852  int addNewKernel(struct grubConfig * con	Line 3811  int addNewKernel(struct grubConfig * con
3811	needs |= NEED_MB;	needs |= NEED_MB;
3812	new->multiboot = 1;	new->multiboot = 1;
3813	}	}
3814		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3815		needs |= NEED_DEVTREE;
3816
3817	if (template) {	if (template) {
3818	for (masterLine = template->lines;	for (masterLine = template->lines;
#	Line 2865  int addNewKernel(struct grubConfig * con	Line 3826  int addNewKernel(struct grubConfig * con
3826	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3827	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3828
3829	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3830	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3831	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3832	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 2943  int addNewKernel(struct grubConfig * con	Line 3903  int addNewKernel(struct grubConfig * con
3903	/* template is multi but new is not,	/* template is multi but new is not,
3904	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3905	*/	*/
3906	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3907	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3908	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3909	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3910		config->cfi)->key);
3911	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3912	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3913		config->cfi);
3914	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3915	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3916	char *initrdVal;	char *initrdVal;
3917	/* template is multi but new is not,	/* template is multi but new is not,
3918	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3919	*/	*/
3920	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3921	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3922	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3923	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3924		config->cfi)->key);
3925	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3926	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3927	free(initrdVal);	free(initrdVal);
3928	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3929	}	}
3930
3931	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3932	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3933	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3934	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 3020  int addNewKernel(struct grubConfig * con	Line 3982  int addNewKernel(struct grubConfig * con
3982	static const char *prefix = "'Loading ";	static const char *prefix = "'Loading ";
3983	if (tmplLine->numElements > 1 &&	if (tmplLine->numElements > 1 &&
3984	strstr(tmplLine->elements[1].item, prefix) &&	strstr(tmplLine->elements[1].item, prefix) &&
3985	masterLine->next && masterLine->next->type == LT_KERNEL) {	masterLine->next &&
3986		iskernel(masterLine->next->type)) {
3987	char *newTitle = malloc(strlen(prefix) +	char *newTitle = malloc(strlen(prefix) +
3988	strlen(newKernelTitle) + 2);	strlen(newKernelTitle) + 2);
3989
#	Line 3035  int addNewKernel(struct grubConfig * con	Line 3998  int addNewKernel(struct grubConfig * con
3998	newLine = addLineTmpl(new, tmplLine, newLine, NULL,	newLine = addLineTmpl(new, tmplLine, newLine, NULL,
3999	config->cfi);	config->cfi);
4000	}	}
4001		} else if (tmplLine->type == LT_DEVTREE &&
4002		tmplLine->numElements == 2 && newDevTreePath) {
4003		newLine = addLineTmpl(new, tmplLine, newLine,
4004		newDevTreePath + strlen(prefix),
4005		config->cfi);
4006		needs &= ~NEED_DEVTREE;
4007		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
4008		const char *ndtp = newDevTreePath;
4009		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
4010		ndtp += strlen(prefix);
4011		newLine = addLine(new, config->cfi, LT_DEVTREE,
4012		config->secondaryIndent,
4013		ndtp);
4014		needs &= ~NEED_DEVTREE;
4015		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
4016	} else {	} else {
4017	/* pass through other lines from the template */	/* pass through other lines from the template */
4018	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
#	Line 3047  int addNewKernel(struct grubConfig * con	Line 4025  int addNewKernel(struct grubConfig * con
4025	*/	*/
4026	switch (config->cfi->entryStart) {	switch (config->cfi->entryStart) {
4027	case LT_KERNEL:	case LT_KERNEL:
4028		case LT_KERNEL_EFI:
4029		case LT_KERNEL_16:
4030	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
4031	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
4032	} else {	} else {
4033	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
4034		preferredLineType(LT_KERNEL, config->cfi),
4035	config->primaryIndent,	config->primaryIndent,
4036	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4037	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3107  int addNewKernel(struct grubConfig * con	Line 4088  int addNewKernel(struct grubConfig * con
4088	}	}
4089	}	}
4090
4091		struct singleLine *endLine = NULL;
4092		endLine = getLineByType(LT_ENTRY_END, new->lines);
4093		if (endLine) {
4094		removeLine(new, endLine);
4095		needs |= NEED_END;
4096		}
4097
4098	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4099	* 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,
4100	* all the lines following the entryStart.	* all the lines following the entryStart.
#	Line 3126  int addNewKernel(struct grubConfig * con	Line 4114  int addNewKernel(struct grubConfig * con
4114	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
4115	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4116	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4117	config->cfi)) ?	config->cfi))
4118	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
4119		: preferredLineType(LT_KERNEL, config->cfi),
4120	config->secondaryIndent,	config->secondaryIndent,
4121	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4122	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3143  int addNewKernel(struct grubConfig * con	Line 4132  int addNewKernel(struct grubConfig * con
4132	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4133	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4134	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4135	config->cfi)) ?	config->cfi))
4136	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
4137		: preferredLineType(LT_INITRD, config->cfi),
4138	config->secondaryIndent,	config->secondaryIndent,
4139	initrdVal);	initrdVal);
4140	free(initrdVal);	free(initrdVal);
4141	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4142	}	}
4143		if (needs & NEED_DEVTREE) {
4144		newLine = addLine(new, config->cfi, LT_DEVTREE,
4145		config->secondaryIndent,
4146		newDevTreePath);
4147		needs &= ~NEED_DEVTREE;
4148		}
4149
4150		/* NEEDS_END must be last on bootloaders that need it... */
4151	if (needs & NEED_END) {	if (needs & NEED_END) {
4152	newLine = addLine(new, config->cfi, LT_ENTRY_END,	newLine = addLine(new, config->cfi, LT_ENTRY_END,
4153	config->secondaryIndent, NULL);	config->secondaryIndent, NULL);
#	Line 3176  static void traceback(int signum)	Line 4174  static void traceback(int signum)
4174	memset(array, '\0', sizeof (array));	memset(array, '\0', sizeof (array));
4175	size = backtrace(array, 40);	size = backtrace(array, 40);
4176
4177	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",	fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4178	(unsigned long)size);	(unsigned long)size);
4179	backtrace_symbols_fd(array, size, STDERR_FILENO);	backtrace_symbols_fd(array, size, STDERR_FILENO);
4180	exit(1);	exit(1);
#	Line 3201  int main(int argc, const char ** argv) {	Line 4199  int main(int argc, const char ** argv) {
4199	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4200	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4201	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4202	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4203	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4204	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4205	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 3211  int main(int argc, const char ** argv) {	Line 4209  int main(int argc, const char ** argv) {
4209	char * removeArgs = NULL;	char * removeArgs = NULL;
4210	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4211	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4212		char * envPath = NULL;
4213	const char * chptr = NULL;	const char * chptr = NULL;
4214	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4215	struct grubConfig * config;	struct grubConfig * config;
#	Line 3219  int main(int argc, const char ** argv) {	Line 4218  int main(int argc, const char ** argv) {
4218	int displayDefault = 0;	int displayDefault = 0;
4219	int displayDefaultIndex = 0;	int displayDefaultIndex = 0;
4220	int displayDefaultTitle = 0;	int displayDefaultTitle = 0;
4221		int defaultIndex = -1;
4222	struct poptOption options[] = {	struct poptOption options[] = {
4223	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4224	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 3236  int main(int argc, const char ** argv) {	Line 4236  int main(int argc, const char ** argv) {
4236	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4237	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4238	_("bootfs") },	_("bootfs") },
4239	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4240	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4241	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4242	#endif	#endif
4243	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4244	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
#	Line 3257  int main(int argc, const char ** argv) {	Line 4257  int main(int argc, const char ** argv) {
4257	_("display the index of the default kernel") },	_("display the index of the default kernel") },
4258	{ "default-title", 0, 0, &displayDefaultTitle, 0,	{ "default-title", 0, 0, &displayDefaultTitle, 0,
4259	_("display the title of the default kernel") },	_("display the title of the default kernel") },
4260		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4261		_("device tree file for new stanza"), _("dtb-path") },
4262	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4263	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4264		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4265		_("force grub2 stanzas to use efi") },
4266		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4267		_("path for environment data"),
4268		_("path") },
4269	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4270	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4271	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
#	Line 3271  int main(int argc, const char ** argv) {	Line 4278  int main(int argc, const char ** argv) {
4278	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4279	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4280	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4281	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4282	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4283	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4284	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 3291  int main(int argc, const char ** argv) {	Line 4298  int main(int argc, const char ** argv) {
4298	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4299	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4300	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4301		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4302		_("make the given entry index the default entry"),
4303		_("entry-index") },
4304	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4305	_("configure silo bootloader") },	_("configure silo bootloader") },
4306	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 3312  int main(int argc, const char ** argv) {	Line 4322  int main(int argc, const char ** argv) {
4322
4323	signal(SIGSEGV, traceback);	signal(SIGSEGV, traceback);
4324
4325		int i = 0;
4326		for (int j = 1; j < argc; j++)
4327		i += strlen(argv[j]) + 1;
4328		saved_command_line = malloc(i);
4329		if (!saved_command_line) {
4330		fprintf(stderr, "grubby: %m\n");
4331		exit(1);
4332		}
4333		saved_command_line[0] = '\0';
4334		for (int j = 1; j < argc; j++) {
4335		strcat(saved_command_line, argv[j]);
4336		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4337		}
4338
4339	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4340	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4341
#	Line 3355  int main(int argc, const char ** argv) {	Line 4379  int main(int argc, const char ** argv) {
4379	return 1;	return 1;
4380	} else if (configureGrub2) {	} else if (configureGrub2) {
4381	cfi = &grub2ConfigType;	cfi = &grub2ConfigType;
4382		if (envPath)
4383		cfi->envFile = envPath;
4384	} else if (configureLilo) {	} else if (configureLilo) {
4385	cfi = &liloConfigType;	cfi = &liloConfigType;
4386	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 3373  int main(int argc, const char ** argv) {	Line 4399  int main(int argc, const char ** argv) {
4399	}	}
4400
4401	if (!cfi) {	if (!cfi) {
4402		if (grub2FindConfig(&grub2ConfigType))
4403		cfi = &grub2ConfigType;
4404		else
4405	#ifdef __ia64__	#ifdef __ia64__
4406	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4407	#elif __powerpc__	#elif __powerpc__
4408	cfi = &yabootConfigType;	cfi = &yabootConfigType;
4409	#elif __sparc__	#elif __sparc__
4410	cfi = &siloConfigType;	cfi = &siloConfigType;
4411	#elif __s390__	#elif __s390__
4412	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4413	#elif __s390x__	#elif __s390x__
4414	cfi = &ziplConfigtype;	cfi = &ziplConfigtype;
4415	#else	#else
	if (grub2FindConfig(&grub2ConfigType))
	cfi = &grub2ConfigType;
	else
4416	cfi = &grubConfigType;	cfi = &grubConfigType;
4417	#endif	#endif
4418	}	}
#	Line 3398  int main(int argc, const char ** argv) {	Line 4424  int main(int argc, const char ** argv) {
4424	grubConfig = cfi->defaultConfig;	grubConfig = cfi->defaultConfig;
4425	}	}
4426
4427	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4428	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4429	defaultKernel || displayDefaultIndex || displayDefaultTitle)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4430		(defaultIndex >= 0))) {
4431	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4432	"specified option"));	"specified option"));
4433	return 1;	return 1;
4434	}	}
4435
4436	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4437	removeKernelPath)) {	removeKernelPath)) {
4438	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4439	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 3416  int main(int argc, const char ** argv) {	Line 4443  int main(int argc, const char ** argv) {
4443	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4444	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4445	return 1;	return 1;
4446	} else if (!newKernelPath && (newKernelTitle  || copyDefault ||	} else if (!newKernelPath && (copyDefault ||
4447	(newKernelInitrd && !updateKernelPath)||	(newKernelInitrd && !updateKernelPath)||
4448	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4449	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
#	Line 3442  int main(int argc, const char ** argv) {	Line 4469  int main(int argc, const char ** argv) {
4469	makeDefault = 1;	makeDefault = 1;
4470	defaultKernel = NULL;	defaultKernel = NULL;
4471	}	}
4472		else if (defaultKernel && (defaultIndex >= 0)) {
4473		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4474		"may not be used together\n"));
4475		return 1;
4476		}
4477
4478	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4479	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
#	Line 3450  int main(int argc, const char ** argv) {	Line 4482  int main(int argc, const char ** argv) {
4482	}	}
4483
4484	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4485	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4486	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4487		&& (defaultIndex == -1)) {
4488	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4489	return 1;	return 1;
4490	}	}
#	Line 3478  int main(int argc, const char ** argv) {	Line 4511  int main(int argc, const char ** argv) {
4511	}	}
4512
4513	if (bootloaderProbe) {	if (bootloaderProbe) {
4514	int lrc = 0, grc = 0, gr2c = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4515	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4516
4517	const char *grub2config = grub2FindConfig(&grub2ConfigType);	const char *grub2config = grub2FindConfig(&grub2ConfigType);
4518	if (grub2config) {	if (grub2config) {
#	Line 3507  int main(int argc, const char ** argv) {	Line 4540  int main(int argc, const char ** argv) {
4540	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4541	}	}
4542
4543		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4544		econfig = readConfig(eliloConfigType.defaultConfig,
4545		&eliloConfigType);
4546		if (!econfig)
4547		erc = 1;
4548		else
4549		erc = checkForElilo(econfig);
4550		}
4551
4552	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4553	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4554	if (!lconfig)	if (!lconfig)
4555	erc = 1;	extrc = 1;
4556	else	else
4557	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4558	}	}
4559
4560	if (lrc == 1 || grc == 1 || gr2c == 1) return 1;
4561		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4562		yconfig = readConfig(yabootConfigType.defaultConfig,
4563		&yabootConfigType);
4564		if (!yconfig)
4565		yrc = 1;
4566		else
4567		yrc = checkForYaboot(yconfig);
4568		}
4569
4570		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4571		erc == 1)
4572		return 1;
4573
4574	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4575	if (gr2c == 2) printf("grub2\n");	if (gr2c == 2) printf("grub2\n");
4576	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4577	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4578		if (yrc == 2) printf("yaboot\n");
4579		if (erc == 2) printf("elilo\n");
4580
4581	return 0;	return 0;
4582	}	}
4583
4584		if (grubConfig == NULL) {
4585		printf("Could not find bootloader configuration file.\n");
4586		exit(1);
4587		}
4588
4589	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4590	if (!config) return 1;	if (!config) return 1;
4591
#	Line 3534  int main(int argc, const char ** argv) {	Line 4595  int main(int argc, const char ** argv) {
4595	char * rootspec;	char * rootspec;
4596
4597	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4598		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4599		cfi->defaultIsSaved)
4600		config->defaultImage = 0;
4601	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4602	if (!entry) return 0;	if (!entry) return 0;
4603	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4604
4605	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4606	if (!line) return 0;	if (!line) return 0;
4607
4608	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3552  int main(int argc, const char ** argv) {	Line 4616  int main(int argc, const char ** argv) {
4616	struct singleEntry * entry;	struct singleEntry * entry;
4617
4618	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4619		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4620		cfi->defaultIsSaved)
4621		config->defaultImage = 0;
4622	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4623	if (!entry) return 0;	if (!entry) return 0;
4624
#	Line 3561  int main(int argc, const char ** argv) {	Line 4628  int main(int argc, const char ** argv) {
4628	printf("%s\n", line->elements[1].item);	printf("%s\n", line->elements[1].item);
4629
4630	} else {	} else {
4631	int i;	char * title;
	size_t len;
	char * start;
	char * tmp;
4632
4633	dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");	dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
4634	line = getLineByType(LT_MENUENTRY, entry->lines);	line = getLineByType(LT_MENUENTRY, entry->lines);
4635	if (!line) return 0;	if (!line) return 0;
4636		title = grub2ExtractTitle(line);
4637	for (i = 0; i < line->numElements; i++) {	if (title)
4638		printf("%s\n", title);
	if (!strcmp(line->elements[i].item, "menuentry"))
	continue;
	if (*line->elements[i].item == '\'')
	start = line->elements[i].item + 1;
	else
	start = line->elements[i].item;
	len = strlen(start);
	if (*(start + len - 1) == '\'') {
	tmp = strdup(start);
	*(tmp + len - 1) = '\0';
	printf("%s", tmp);
	free(tmp);
	break;
	} else {
	printf("%s ", start);
	}
	}
	printf("\n");
4639	}	}
4640	return 0;	return 0;
4641
4642	} else if (displayDefaultIndex) {	} else if (displayDefaultIndex) {
4643	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4644		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4645		cfi->defaultIsSaved)
4646		config->defaultImage = 0;
4647	printf("%i\n", config->defaultImage);	printf("%i\n", config->defaultImage);
4648		return 0;
4649
4650	} else if (kernelInfo)	} else if (kernelInfo)
4651	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
#	Line 3610  int main(int argc, const char ** argv) {	Line 4658  int main(int argc, const char ** argv) {
4658	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4659	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4660	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4661	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4662	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4663	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4664	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4665	if (updateKernelPath && newKernelInitrd) {	if (updateKernelPath && newKernelInitrd) {
4666	if (updateInitrd(config, updateKernelPath, bootPrefix,	if (newMBKernel) {
4667	newKernelInitrd)) return 1;	if (addMBInitrd(config, newMBKernel, updateKernelPath,
4668		bootPrefix, newKernelInitrd,
4669		newKernelTitle))
4670		return 1;
4671		} else {
4672		if (updateInitrd(config, updateKernelPath, bootPrefix,
4673		newKernelInitrd, newKernelTitle))
4674		return 1;
4675		}
4676	}	}
4677	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4678	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4679	extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4680	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4681
4682
4683	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.1736   changed lines   Added in v.2960