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

Parent Directory | Revision Log | Patch

	trunk/grubby/grubby.c revision 1844 by niro, Mon Jul 2 12:59:07 2012 UTC	tags/grubby-8_34/grubby.c revision 2713 by niro, Wed Jul 16 10:59:23 2014 UTC
#	Line 36	Line 36
36	#include <signal.h>	#include <signal.h>
37	#include <blkid/blkid.h>	#include <blkid/blkid.h>
38
39		#include "log.h"
40
41	#ifndef DEBUG	#ifndef DEBUG
42	#define DEBUG 0	#define DEBUG 0
43	#endif	#endif
#	Line 56  int debug = 0; /* Currently just for tem	Line 58  int debug = 0; /* Currently just for tem
58	#define NOOP_OPCODE 0x90	#define NOOP_OPCODE 0x90
59	#define JMP_SHORT_OPCODE 0xeb	#define JMP_SHORT_OPCODE 0xeb
60
61		int isEfi = 0;
62
63		#if defined(__aarch64__)
64		#define isEfiOnly 1
65		#else
66		#define isEfiOnly 0
67		#endif
68
69		char *saved_command_line = NULL;
70
71	/* comments get lumped in with indention */	/* comments get lumped in with indention */
72	struct lineElement {	struct lineElement {
73	char * item;	char * item;
#	Line 82  enum lineType_e {	Line 94  enum lineType_e {
94	LT_MENUENTRY    = 1 << 17,	LT_MENUENTRY    = 1 << 17,
95	LT_ENTRY_END    = 1 << 18,	LT_ENTRY_END    = 1 << 18,
96	LT_SET_VARIABLE = 1 << 19,	LT_SET_VARIABLE = 1 << 19,
97	LT_UNKNOWN      = 1 << 20,	LT_KERNEL_EFI   = 1 << 20,
98		LT_INITRD_EFI   = 1 << 21,
99		LT_KERNEL_16    = 1 << 22,
100		LT_INITRD_16    = 1 << 23,
101		LT_DEVTREE      = 1 << 24,
102		LT_UNKNOWN      = 1 << 25,
103	};	};
104
105	struct singleLine {	struct singleLine {
#	Line 111  struct singleEntry {	Line 128  struct singleEntry {
128	#define NEED_ARGS    (1 << 3)	#define NEED_ARGS    (1 << 3)
129	#define NEED_MB      (1 << 4)	#define NEED_MB      (1 << 4)
130	#define NEED_END     (1 << 5)	#define NEED_END     (1 << 5)
131		#define NEED_DEVTREE (1 << 6)
132
133	#define MAIN_DEFAULT    (1 << 0)	#define MAIN_DEFAULT    (1 << 0)
134	#define DEFAULT_SAVED       -2	#define DEFAULT_SAVED       -2
#	Line 128  struct configFileInfo;	Line 146  struct configFileInfo;
146	typedef const char *(*findConfigFunc)(struct configFileInfo *);	typedef const char *(*findConfigFunc)(struct configFileInfo *);
147	typedef const int (*writeLineFunc)(struct configFileInfo *,	typedef const int (*writeLineFunc)(struct configFileInfo *,
148	struct singleLine *line);	struct singleLine *line);
149		typedef char *(*getEnvFunc)(struct configFileInfo *, char *name);
150		typedef int (*setEnvFunc)(struct configFileInfo *, char *name, char *value);
151
152	struct configFileInfo {	struct configFileInfo {
153	char * defaultConfig;	char * defaultConfig;
154	findConfigFunc findConfig;	findConfigFunc findConfig;
155	writeLineFunc writeLine;	writeLineFunc writeLine;
156		getEnvFunc getEnv;
157		setEnvFunc setEnv;
158	struct keywordTypes * keywords;	struct keywordTypes * keywords;
159		int caseInsensitive;
160	int defaultIsIndex;	int defaultIsIndex;
161	int defaultIsVariable;	int defaultIsVariable;
162	int defaultSupportSaved;	int defaultSupportSaved;
163		int defaultIsSaved;
164		int defaultIsUnquoted;
165	enum lineType_e entryStart;	enum lineType_e entryStart;
166	enum lineType_e entryEnd;	enum lineType_e entryEnd;
167	int needsBootPrefix;	int needsBootPrefix;
#	Line 148  struct configFileInfo {	Line 173  struct configFileInfo {
173	int mbInitRdIsModule;	int mbInitRdIsModule;
174	int mbConcatArgs;	int mbConcatArgs;
175	int mbAllowExtraInitRds;	int mbAllowExtraInitRds;
176		char *envFile;
177	};	};
178
179	struct keywordTypes grubKeywords[] = {	struct keywordTypes grubKeywords[] = {
#	Line 164  struct keywordTypes grubKeywords[] = {	Line 190  struct keywordTypes grubKeywords[] = {
190
191	const char *grubFindConfig(struct configFileInfo *cfi) {	const char *grubFindConfig(struct configFileInfo *cfi) {
192	static const char *configFiles[] = {	static const char *configFiles[] = {
	"/etc/grub.conf",
193	"/boot/grub/grub.conf",	"/boot/grub/grub.conf",
194	"/boot/grub/menu.lst",	"/boot/grub/menu.lst",
195		"/etc/grub.conf",
196		"/boot/grub2/grub.cfg",
197		"/boot/grub2-efi/grub.cfg",
198	NULL	NULL
199	};	};
200	static int i = -1;	static int i = -1;
#	Line 205  struct keywordTypes grub2Keywords[] = {	Line 233  struct keywordTypes grub2Keywords[] = {
233	{ "default",    LT_DEFAULT,     ' ' },	{ "default",    LT_DEFAULT,     ' ' },
234	{ "fallback",   LT_FALLBACK,    ' ' },	{ "fallback",   LT_FALLBACK,    ' ' },
235	{ "linux",      LT_KERNEL,      ' ' },	{ "linux",      LT_KERNEL,      ' ' },
236		{ "linuxefi",   LT_KERNEL_EFI,  ' ' },
237		{ "linux16",    LT_KERNEL_16,   ' ' },
238	{ "initrd",     LT_INITRD,      ' ', ' ' },	{ "initrd",     LT_INITRD,      ' ', ' ' },
239		{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
240		{ "initrd16",   LT_INITRD_16,   ' ', ' ' },
241	{ "module",     LT_MBMODULE,    ' ' },	{ "module",     LT_MBMODULE,    ' ' },
242	{ "kernel",     LT_HYPER,       ' ' },	{ "kernel",     LT_HYPER,       ' ' },
243		{ "devicetree", LT_DEVTREE,  ' ' },
244	{ NULL, 0, 0 },	{ NULL, 0, 0 },
245	};	};
246
#	Line 219  const char *grub2FindConfig(struct confi	Line 252  const char *grub2FindConfig(struct confi
252	};	};
253	static int i = -1;	static int i = -1;
254	static const char *grub_cfg = "/boot/grub/grub.cfg";	static const char *grub_cfg = "/boot/grub/grub.cfg";
255		int rc = -1;
256
257	if (i == -1) {	if (i == -1) {
258	for (i = 0; configFiles[i] != NULL; i++) {	for (i = 0; configFiles[i] != NULL; i++) {
259	dbgPrintf("Checking \"%s\": ", configFiles[i]);	dbgPrintf("Checking \"%s\": ", configFiles[i]);
260	if (!access(configFiles[i], R_OK)) {	if ((rc = access(configFiles[i], R_OK))) {
261		if (errno == EACCES) {
262		printf("Unable to access bootloader configuration file "
263		"\"%s\": %m\n", configFiles[i]);
264		exit(1);
265		}
266		continue;
267		} else {
268	dbgPrintf("found\n");	dbgPrintf("found\n");
269	return configFiles[i];	return configFiles[i];
270	}	}
#	Line 242  const char *grub2FindConfig(struct confi	Line 283  const char *grub2FindConfig(struct confi
283	return configFiles[i];	return configFiles[i];
284	}	}
285
286		/* kind of hacky.  It'll give the first 1024 bytes, ish. */
287		static char *grub2GetEnv(struct configFileInfo *info, char *name)
288		{
289		static char buf[1025];
290		char *s = NULL;
291		char *ret = NULL;
292		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
293		int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
294
295		if (rc < 0)
296		return NULL;
297
298		FILE *f = popen(s, "r");
299		if (!f)
300		goto out;
301
302		memset(buf, '\0', sizeof (buf));
303		ret = fgets(buf, 1024, f);
304		pclose(f);
305
306		if (ret) {
307		ret += strlen(name) + 1;
308		ret[strlen(ret) - 1] = '\0';
309		}
310		dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
311		out:
312		free(s);
313		return ret;
314		}
315
316		static int sPopCount(const char *s, const char *c)
317		{
318		int ret = 0;
319		if (!s)
320		return -1;
321		for (int i = 0; s[i] != '\0'; i++)
322		for (int j = 0; c[j] != '\0'; j++)
323		if (s[i] == c[j])
324		ret++;
325		return ret;
326		}
327
328		static char *shellEscape(const char *s)
329		{
330		int l = strlen(s) + sPopCount(s, "'") * 2;
331
332		char *ret = calloc(l+1, sizeof (*ret));
333		if (!ret)
334		return NULL;
335		for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
336		if (s[i] == '\'')
337		ret[j++] = '\\';
338		ret[j] = s[i];
339		}
340		return ret;
341		}
342
343		static void unquote(char *s)
344		{
345		int l = strlen(s);
346
347		if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
348		memmove(s, s+1, l-2);
349		s[l-2] = '\0';
350		}
351		}
352
353		static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
354		{
355		char *s = NULL;
356		int rc = 0;
357		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
358
359		unquote(value);
360		value = shellEscape(value);
361		if (!value)
362		return -1;
363
364		rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
365		free(value);
366		if (rc <0)
367		return -1;
368
369		dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
370		rc = system(s);
371		free(s);
372		return rc;
373		}
374
375		/* this is a gigantic hack to avoid clobbering grub2 variables... */
376		static int is_special_grub2_variable(const char *name)
377		{
378		if (!strcmp(name,"\"${next_entry}\""))
379		return 1;
380		if (!strcmp(name,"\"${prev_saved_entry}\""))
381		return 1;
382		return 0;
383		}
384
385	int sizeOfSingleLine(struct singleLine * line) {	int sizeOfSingleLine(struct singleLine * line) {
	int i;
386	int count = 0;	int count = 0;
387
388	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
389	int indentSize = 0;	int indentSize = 0;
390
391	count = count + strlen(line->elements[i].item);	count = count + strlen(line->elements[i].item);
#	Line 272  static int isquote(char q)	Line 411  static int isquote(char q)
411	return 0;	return 0;
412	}	}
413
414		static int iskernel(enum lineType_e type) {
415		return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
416		}
417
418		static int isinitrd(enum lineType_e type) {
419		return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
420		}
421
422	char *grub2ExtractTitle(struct singleLine * line) {	char *grub2ExtractTitle(struct singleLine * line) {
423	char * current;	char * current;
424	char * current_indent;	char * current_indent;
#	Line 329  char *grub2ExtractTitle(struct singleLin	Line 476  char *grub2ExtractTitle(struct singleLin
476
477	struct configFileInfo grub2ConfigType = {	struct configFileInfo grub2ConfigType = {
478	.findConfig = grub2FindConfig,	.findConfig = grub2FindConfig,
479		.getEnv = grub2GetEnv,
480		.setEnv = grub2SetEnv,
481	.keywords = grub2Keywords,	.keywords = grub2Keywords,
482	.defaultIsIndex = 1,	.defaultIsIndex = 1,
483	.defaultSupportSaved = 1,	.defaultSupportSaved = 1,
#	Line 483  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 507  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 571  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 604  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 646  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 692  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 702  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 711  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 726  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	/* Need to handle this, because we strip the quotes from
917	* menuentry when read it. */	* menuentry when read it. */
918	if (line->type == LT_MENUENTRY && i == 1) {	if (line->type == LT_MENUENTRY && i == 1) {
#	Line 836  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 848  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 867  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 888  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 915  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 926  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 989  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].item, line->elements[i].indent);	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 1020  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 1038  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 1068  static struct grubConfig * readConfig(co	Line 1256  static struct grubConfig * readConfig(co
1256	char *extras;	char *extras;
1257	char *title;	char *title;
1258
1259	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1260	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
1261	len += strlen(line->elements[i].indent);	len += strlen(line->elements[i].indent);
1262	}	}
#	Line 1080  static struct grubConfig * readConfig(co	Line 1268  static struct grubConfig * readConfig(co
1268	*extras = '\0';	*extras = '\0';
1269
1270	/* get title. */	/* get title. */
1271	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1272	if (!strcmp(line->elements[i].item, "menuentry"))	if (!strcmp(line->elements[i].item, "menuentry"))
1273	continue;	continue;
1274	if (isquote(*line->elements[i].item))	if (isquote(*line->elements[i].item))
#	Line 1100  static struct grubConfig * readConfig(co	Line 1288  static struct grubConfig * readConfig(co
1288
1289	/* get extras */	/* get extras */
1290	int count = 0;	int count = 0;
1291	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1292	if (count >= 2) {	if (count >= 2) {
1293	strcat(extras, line->elements[i].item);	strcat(extras, line->elements[i].item);
1294	strcat(extras, line->elements[i].indent);	strcat(extras, line->elements[i].indent);
#	Line 1146  static struct grubConfig * readConfig(co	Line 1334  static struct grubConfig * readConfig(co
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 1203  static struct grubConfig * readConfig(co	Line 1396  static struct grubConfig * readConfig(co
1396	if (defaultLine->numElements > 2 &&	if (defaultLine->numElements > 2 &&
1397	cfi->defaultSupportSaved &&	cfi->defaultSupportSaved &&
1398	!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {	!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1399	cfg->defaultImage = DEFAULT_SAVED_GRUB2;	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) {	} 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 == '\'' ||
#	Line 1221  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 1244  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 1261  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 == DEFAULT_SAVED_GRUB2)	else if (cfg->cfi->defaultIsSaved) {
1486	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1487	else if (cfg->defaultImage > -1) {	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 1323  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 1365  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 1510  static char *findDiskForRoot()	Line 1745  static char *findDiskForRoot()
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	/* Need to handle this, because we strip the quotes from	/* Need to handle this, because we strip the quotes from
1756	* menuentry when read it. */	* menuentry when read it. */
1757	if (line->type == LT_MENUENTRY && i == 1) {	if (line->type == LT_MENUENTRY && i == 1) {
1758	if(!isquote(*line->elements[i].item))	if(!isquote(*line->elements[i].item))
1759	fprintf(stderr, "\'%s\'", line->elements[i].item);	log_message(f, "\'%s\'", line->elements[i].item);
1760	else	else
1761	fprintf(stderr, "%s", line->elements[i].item);	log_message(f, "%s", line->elements[i].item);
1762	fprintf(stderr, "%s", line->elements[i].indent);	log_message(f, "%s", line->elements[i].indent);
1763
1764	continue;	continue;
1765	}	}
1766
1767	fprintf(stderr, "%s%s",	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		va_start(argp, fmt);
1780
1781	if (!debug)	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
#	Line 1573  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);
#	Line 1599  int suitableImage(struct singleEntry * e	Line 1861  int suitableImage(struct singleEntry * e
1861	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1862	line->elements[1].item + rootspec_offset);	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 1620  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 1629  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 1638  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 1707  struct singleEntry * findEntryByPath(str	Line 1970  struct singleEntry * findEntryByPath(str
1970	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
1971	if (!entry) return NULL;	if (!entry) return NULL;
1972
1973	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1974	if (!line) return NULL;	if (!line) return NULL;
1975
1976	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1756  struct singleEntry * findEntryByPath(str	Line 2019  struct singleEntry * findEntryByPath(str
2019
2020	/* check all the lines matching checkType */	/* check all the lines matching checkType */
2021	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
2022	line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?	enum lineType_e ct = checkType;
2023	LT_KERNEL|LT_MBMODULE|LT_HYPER :	if (entry->multiboot && checkType == LT_KERNEL)
2024	checkType, line);	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2025	if (!line) break;  /* not found in this entry */	else if (checkType & LT_KERNEL)
2026		ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2027		line = getLineByType(ct, line);
2028		if (!line)
2029		break;  /* not found in this entry */
2030
2031	if (line && line->type != LT_MENUENTRY &&	if (line && line->type != LT_MENUENTRY &&
2032	line->numElements >= 2) {	line->numElements >= 2) {
#	Line 1778  struct singleEntry * findEntryByPath(str	Line 2045  struct singleEntry * findEntryByPath(str
2045	* non-Linux boot entries (could find netbsd etc, though, which is	* non-Linux boot entries (could find netbsd etc, though, which is
2046	* unfortunate)	* unfortunate)
2047	*/	*/
2048	if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2049	break; /* found 'im! */	break; /* found 'im! */
2050	}	}
2051
#	Line 1788  struct singleEntry * findEntryByPath(str	Line 2055  struct singleEntry * findEntryByPath(str
2055	return entry;	return entry;
2056	}	}
2057
2058		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2059		int * index) {
2060		struct singleEntry * entry;
2061		struct singleLine * line;
2062		int i;
2063		char * newtitle;
2064
2065		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2066		if (index && i < *index)
2067		continue;
2068		line = getLineByType(LT_TITLE, entry->lines);
2069		if (!line)
2070		line = getLineByType(LT_MENUENTRY, entry->lines);
2071		if (!line)
2072		continue;
2073		newtitle = grub2ExtractTitle(line);
2074		if (!newtitle)
2075		continue;
2076		if (!strcmp(title, newtitle))
2077		break;
2078		}
2079
2080		if (!entry)
2081		return NULL;
2082
2083		if (index)
2084		*index = i;
2085		return entry;
2086		}
2087
2088	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2089	struct singleEntry * entry;	struct singleEntry * entry;
2090
#	Line 1810  struct singleEntry * findTemplate(struct	Line 2107  struct singleEntry * findTemplate(struct
2107	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2108	int index;	int index;
2109
2110	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2111		if (cfg->cfi->getEnv) {
2112		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2113		if (defTitle) {
2114		int index = 0;
2115		if (isnumber(defTitle)) {
2116		index = atoi(defTitle);
2117		entry = findEntryByIndex(cfg, index);
2118		} else {
2119		entry = findEntryByTitle(cfg, defTitle, &index);
2120		}
2121		if (entry)
2122		cfg->defaultImage = index;
2123		}
2124		}
2125		} else if (cfg->defaultImage > -1) {
2126	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2127	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2128	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1880  void markRemovedImage(struct grubConfig	Line 2192  void markRemovedImage(struct grubConfig
2192
2193	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2194	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2195	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2196	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2197	int i, j;	int i, j;
2198
2199	if (newIsDefault) {	if (newIsDefault) {
2200	config->defaultImage = 0;	config->defaultImage = 0;
2201	return;	return;
2202		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2203		if (findEntryByIndex(config, index))
2204		config->defaultImage = index;
2205		else
2206		config->defaultImage = -1;
2207		return;
2208	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2209	i = 0;	i = 0;
2210	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1958  void displayEntry(struct singleEntry * e	Line 2276  void displayEntry(struct singleEntry * e
2276	struct singleLine * line;	struct singleLine * line;
2277	char * root = NULL;	char * root = NULL;
2278	int i;	int i;
2279		int j;
2280
2281	printf("index=%d\n", index);	printf("index=%d\n", index);
2282
2283	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2284	if (!line) {	if (!line) {
2285	printf("non linux entry\n");	printf("non linux entry\n");
2286	return;	return;
2287	}	}
2288
2289	printf("kernel=%s%s\n", prefix, line->elements[1].item);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2290		printf("kernel=%s\n", line->elements[1].item);
2291		else
2292		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2293
2294	if (line->numElements >= 3) {	if (line->numElements >= 3) {
2295	printf("args=\"");	printf("args=\"");
#	Line 2023  void displayEntry(struct singleEntry * e	Line 2345  void displayEntry(struct singleEntry * e
2345	printf("root=%s\n", s);	printf("root=%s\n", s);
2346	}	}
2347
2348	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2349
2350	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
2351	printf("initrd=%s", prefix);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2352		printf("initrd=");
2353		else
2354		printf("initrd=%s", prefix);
2355
2356	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
2357	printf("%s%s", line->elements[i].item, line->elements[i].indent);	printf("%s%s", line->elements[i].item, line->elements[i].indent);
2358	printf("\n");	printf("\n");
#	Line 2042  void displayEntry(struct singleEntry * e	Line 2368  void displayEntry(struct singleEntry * e
2368	if (title)	if (title)
2369	printf("title=%s\n", title);	printf("title=%s\n", title);
2370	}	}
2371
2372		for (j = 0, line = entry->lines; line; line = line->next) {
2373		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2374		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2375		printf("mbmodule%d=", j);
2376		else
2377		printf("mbmodule%d=%s", j, prefix);
2378
2379		for (i = 1; i < line->numElements; i++)
2380		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2381		printf("\n");
2382		j++;
2383		}
2384		}
2385		}
2386
2387		int isSuseSystem(void) {
2388		const char * path;
2389		const static char default_path[] = "/etc/SuSE-release";
2390
2391		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2392		path = default_path;
2393
2394		if (!access(path, R_OK))
2395		return 1;
2396		return 0;
2397		}
2398
2399		int isSuseGrubConf(const char * path) {
2400		FILE * grubConf;
2401		char * line = NULL;
2402		size_t len = 0, res = 0;
2403
2404		grubConf = fopen(path, "r");
2405		if (!grubConf) {
2406		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2407		return 0;
2408		}
2409
2410		while ((res = getline(&line, &len, grubConf)) != -1) {
2411		if (!strncmp(line, "setup", 5)) {
2412		fclose(grubConf);
2413		free(line);
2414		return 1;
2415		}
2416		}
2417
2418		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2419		path);
2420
2421		fclose(grubConf);
2422		free(line);
2423		return 0;
2424		}
2425
2426		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2427		FILE * grubConf;
2428		char * line = NULL;
2429		size_t res = 0, len = 0;
2430
2431		if (!path) return 1;
2432		if (!lbaPtr) return 1;
2433
2434		grubConf = fopen(path, "r");
2435		if (!grubConf) return 1;
2436
2437		while ((res = getline(&line, &len, grubConf)) != -1) {
2438		if (line[res - 1] == '\n')
2439		line[res - 1] = '\0';
2440		else if (len > res)
2441		line[res] = '\0';
2442		else {
2443		line = realloc(line, res + 1);
2444		line[res] = '\0';
2445		}
2446
2447		if (!strncmp(line, "setup", 5)) {
2448		if (strstr(line, "--force-lba")) {
2449		*lbaPtr = 1;
2450		} else {
2451		*lbaPtr = 0;
2452		}
2453		dbgPrintf("lba: %i\n", *lbaPtr);
2454		break;
2455		}
2456		}
2457
2458		free(line);
2459		fclose(grubConf);
2460		return 0;
2461		}
2462
2463		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2464		FILE * grubConf;
2465		char * line = NULL;
2466		size_t res = 0, len = 0;
2467		char * lastParamPtr = NULL;
2468		char * secLastParamPtr = NULL;
2469		char installDeviceNumber = '\0';
2470		char * bounds = NULL;
2471
2472		if (!path) return 1;
2473		if (!devicePtr) return 1;
2474
2475		grubConf = fopen(path, "r");
2476		if (!grubConf) return 1;
2477
2478		while ((res = getline(&line, &len, grubConf)) != -1) {
2479		if (strncmp(line, "setup", 5))
2480		continue;
2481
2482		if (line[res - 1] == '\n')
2483		line[res - 1] = '\0';
2484		else if (len > res)
2485		line[res] = '\0';
2486		else {
2487		line = realloc(line, res + 1);
2488		line[res] = '\0';
2489		}
2490
2491		lastParamPtr = bounds = line + res;
2492
2493		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2494		while (!isspace(*lastParamPtr))
2495		lastParamPtr--;
2496		lastParamPtr++;
2497
2498		secLastParamPtr = lastParamPtr - 2;
2499		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2500
2501		if (lastParamPtr + 3 > bounds) {
2502		dbgPrintf("lastParamPtr going over boundary");
2503		fclose(grubConf);
2504		free(line);
2505		return 1;
2506		}
2507		if (!strncmp(lastParamPtr, "(hd", 3))
2508		lastParamPtr += 3;
2509		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2510
2511		/*
2512		* Second last parameter will decide wether last parameter is
2513		* an IMAGE_DEVICE or INSTALL_DEVICE
2514		*/
2515		while (!isspace(*secLastParamPtr))
2516		secLastParamPtr--;
2517		secLastParamPtr++;
2518
2519		if (secLastParamPtr + 3 > bounds) {
2520		dbgPrintf("secLastParamPtr going over boundary");
2521		fclose(grubConf);
2522		free(line);
2523		return 1;
2524		}
2525		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2526		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2527		secLastParamPtr += 3;
2528		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2529		installDeviceNumber = *secLastParamPtr;
2530		} else {
2531		installDeviceNumber = *lastParamPtr;
2532		}
2533
2534		*devicePtr = malloc(6);
2535		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2536		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2537		fclose(grubConf);
2538		free(line);
2539		return 0;
2540		}
2541
2542		free(line);
2543		fclose(grubConf);
2544		return 1;
2545		}
2546
2547		int grubGetBootFromDeviceMap(const char * device,
2548		char ** bootPtr) {
2549		FILE * deviceMap;
2550		char * line = NULL;
2551		size_t res = 0, len = 0;
2552		char * devicePtr;
2553		char * bounds = NULL;
2554		const char * path;
2555		const static char default_path[] = "/boot/grub/device.map";
2556
2557		if (!device) return 1;
2558		if (!bootPtr) return 1;
2559
2560		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2561		path = default_path;
2562
2563		dbgPrintf("opening grub device.map file from: %s\n", path);
2564		deviceMap = fopen(path, "r");
2565		if (!deviceMap)
2566		return 1;
2567
2568		while ((res = getline(&line, &len, deviceMap)) != -1) {
2569		if (!strncmp(line, "#", 1))
2570		continue;
2571
2572		if (line[res - 1] == '\n')
2573		line[res - 1] = '\0';
2574		else if (len > res)
2575		line[res] = '\0';
2576		else {
2577		line = realloc(line, res + 1);
2578		line[res] = '\0';
2579		}
2580
2581		devicePtr = line;
2582		bounds = line + res;
2583
2584		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2585		devicePtr++;
2586		dbgPrintf("device: %s\n", devicePtr);
2587
2588		if (!strncmp(devicePtr, device, strlen(device))) {
2589		devicePtr += strlen(device);
2590		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2591		devicePtr++;
2592
2593		*bootPtr = strdup(devicePtr);
2594		break;
2595		}
2596		}
2597
2598		free(line);
2599		fclose(deviceMap);
2600		return 0;
2601		}
2602
2603		int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2604		char * grubDevice;
2605
2606		if (suseGrubConfGetInstallDevice(path, &grubDevice))
2607		dbgPrintf("error looking for grub installation device\n");
2608		else
2609		dbgPrintf("grubby installation device: %s\n", grubDevice);
2610
2611		if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2612		dbgPrintf("error looking for grub boot device\n");
2613		else
2614		dbgPrintf("grubby boot device: %s\n", *bootPtr);
2615
2616		free(grubDevice);
2617		return 0;
2618		}
2619
2620		int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2621		/*
2622		* This SuSE grub configuration file at this location is not your average
2623		* grub configuration file, but instead the grub commands used to setup
2624		* grub on that system.
2625		*/
2626		const char * path;
2627		const static char default_path[] = "/etc/grub.conf";
2628
2629		if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2630		path = default_path;
2631
2632		if (!isSuseGrubConf(path)) return 1;
2633
2634		if (lbaPtr) {
2635		*lbaPtr = 0;
2636		if (suseGrubConfGetLba(path, lbaPtr))
2637		return 1;
2638		}
2639
2640		if (bootPtr) {
2641		*bootPtr = NULL;
2642		suseGrubConfGetBoot(path, bootPtr);
2643		}
2644
2645		return 0;
2646	}	}
2647
2648	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
#	Line 2092  int parseSysconfigGrub(int * lbaPtr, cha	Line 2693  int parseSysconfigGrub(int * lbaPtr, cha
2693	}	}
2694
2695	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2696	char * boot;	char * boot = NULL;
2697	int lba;	int lba;
2698
2699	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2700	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2701	if (boot) printf("boot=%s\n", boot);	free(boot);
2702		return;
2703		}
2704		} else {
2705		if (parseSysconfigGrub(&lba, &boot)) {
2706		free(boot);
2707		return;
2708		}
2709		}
2710
2711		if (lba) printf("lba\n");
2712		if (boot) {
2713		printf("boot=%s\n", boot);
2714		free(boot);
2715	}	}
2716	}	}
2717
#	Line 2146  struct singleLine * addLineTmpl(struct s	Line 2760  struct singleLine * addLineTmpl(struct s
2760	{	{
2761	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2762
2763		if (isEfi && cfi == &grub2ConfigType) {
2764		enum lineType_e old = newLine->type;
2765		newLine->type = preferredLineType(newLine->type, cfi);
2766		if (old != newLine->type)
2767		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2768		}
2769
2770	if (val) {	if (val) {
2771	/* override the inherited value with our own.	/* override the inherited value with our own.
2772	* 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 2155  struct singleLine * addLineTmpl(struct s	Line 2776  struct singleLine * addLineTmpl(struct s
2776	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2777
2778	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2779	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)) {
2780	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2781	if (rootspec != NULL) {	if (rootspec != NULL) {
2782	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 2192  struct singleLine *  addLine(struct sing	Line 2813  struct singleLine *  addLine(struct sing
2813	/* 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
2814	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2815	*/	*/
2816	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2817	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2818	tmpl.type = type;	tmpl.type = type;
#	Line 2526  int updateActualImage(struct grubConfig	Line 3146  int updateActualImage(struct grubConfig
3146	firstElement = 2;	firstElement = 2;
3147
3148	} else {	} else {
3149	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3150	if (!line) {	if (!line) {
3151	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3152	continue;	continue;
#	Line 2682  int updateImage(struct grubConfig * cfg,	Line 3302  int updateImage(struct grubConfig * cfg,
3302	return rc;	return rc;
3303	}	}
3304
3305		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3306		const char * image, const char * prefix, const char * initrd) {
3307		struct singleEntry * entry;
3308		struct singleLine * line, * kernelLine, *endLine = NULL;
3309		int index = 0;
3310
3311		if (!image) return 0;
3312
3313		for (; (entry = findEntryByPath(cfg, newMBKernel, prefix, &index)); index++) {
3314		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3315		if (!kernelLine) continue;
3316
3317		if (prefix) {
3318		int prefixLen = strlen(prefix);
3319		if (!strncmp(initrd, prefix, prefixLen))
3320		initrd += prefixLen;
3321		}
3322		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3323		if (endLine)
3324		removeLine(entry, endLine);
3325		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3326		kernelLine->indent, initrd);
3327		if (!line)
3328		return 1;
3329		if (endLine) {
3330		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3331		if (!line)
3332		return 1;
3333		}
3334
3335		break;
3336		}
3337
3338		return 0;
3339		}
3340
3341	int updateInitrd(struct grubConfig * cfg, const char * image,	int updateInitrd(struct grubConfig * cfg, const char * image,
3342	const char * prefix, const char * initrd) {	const char * prefix, const char * initrd) {
3343	struct singleEntry * entry;	struct singleEntry * entry;
#	Line 2691  int updateInitrd(struct grubConfig * cfg	Line 3347  int updateInitrd(struct grubConfig * cfg
3347	if (!image) return 0;	if (!image) return 0;
3348
3349	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3350	kernelLine = getLineByType(LT_KERNEL, entry->lines);	kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3351	if (!kernelLine) continue;	if (!kernelLine) continue;
3352
3353	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3354	if (line)	if (line)
3355	removeLine(entry, line);	removeLine(entry, line);
3356	if (prefix) {	if (prefix) {
#	Line 2705  int updateInitrd(struct grubConfig * cfg	Line 3361  int updateInitrd(struct grubConfig * cfg
3361	endLine = getLineByType(LT_ENTRY_END, entry->lines);	endLine = getLineByType(LT_ENTRY_END, entry->lines);
3362	if (endLine)	if (endLine)
3363	removeLine(entry, endLine);	removeLine(entry, endLine);
3364	line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);	enum lineType_e lt;
3365		switch(kernelLine->type) {
3366		case LT_KERNEL:
3367		lt = LT_INITRD;
3368		break;
3369		case LT_KERNEL_EFI:
3370		lt = LT_INITRD_EFI;
3371		break;
3372		case LT_KERNEL_16:
3373		lt = LT_INITRD_16;
3374		break;
3375		default:
3376		lt = preferredLineType(LT_INITRD, cfg->cfi);
3377		}
3378		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3379	if (!line)	if (!line)
3380	return 1;	return 1;
3381	if (endLine) {	if (endLine) {
#	Line 2911  int checkForGrub(struct grubConfig * con	Line 3581  int checkForGrub(struct grubConfig * con
3581	int fd;	int fd;
3582	unsigned char bootSect[512];	unsigned char bootSect[512];
3583	char * boot;	char * boot;
3584		int onSuse = isSuseSystem();
3585
3586	if (parseSysconfigGrub(NULL, &boot))
3587	return 0;	if (onSuse) {
3588		if (parseSuseGrubConf(NULL, &boot))
3589		return 0;
3590		} else {
3591		if (parseSysconfigGrub(NULL, &boot))
3592		return 0;
3593		}
3594
3595	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3596	if (!boot)	if (!boot)
#	Line 2932  int checkForGrub(struct grubConfig * con	Line 3609  int checkForGrub(struct grubConfig * con
3609	}	}
3610	close(fd);	close(fd);
3611
3612		/* The more elaborate checks do not work on SuSE. The checks done
3613		* seem to be reasonble (at least for now), so just return success
3614		*/
3615		if (onSuse)
3616		return 2;
3617
3618	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3619	}	}
3620
#	Line 2965  int checkForExtLinux(struct grubConfig *	Line 3648  int checkForExtLinux(struct grubConfig *
3648	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3649	}	}
3650
3651		int checkForYaboot(struct grubConfig * config) {
3652		/*
3653		* This is a simplistic check that we consider good enough for own puporses
3654		*
3655		* If we were to properly check if yaboot is *installed* we'd need to:
3656		* 1) get the system boot device (LT_BOOT)
3657		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3658		*    the content on the boot device
3659		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3660		* 4) check again if binary and boot device contents match
3661		*/
3662		if (!access("/etc/yaboot.conf", R_OK))
3663		return 2;
3664
3665		return 1;
3666		}
3667
3668		int checkForElilo(struct grubConfig * config) {
3669		if (!access("/etc/elilo.conf", R_OK))
3670		return 2;
3671
3672		return 1;
3673		}
3674
3675	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3676	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3677
#	Line 3027  int addNewKernel(struct grubConfig * con	Line 3734  int addNewKernel(struct grubConfig * con
3734	const char * newKernelPath, const char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3735	const char * newKernelArgs, const char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3736	const char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3737	const char * newMBKernel, const char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs,
3738		const char * newDevTreePath) {
3739	struct singleEntry * new;	struct singleEntry * new;
3740	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3741	int needs;	int needs;
#	Line 3068  int addNewKernel(struct grubConfig * con	Line 3776  int addNewKernel(struct grubConfig * con
3776	needs |= NEED_MB;	needs |= NEED_MB;
3777	new->multiboot = 1;	new->multiboot = 1;
3778	}	}
3779		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3780		needs |= NEED_DEVTREE;
3781
3782	if (template) {	if (template) {
3783	for (masterLine = template->lines;	for (masterLine = template->lines;
#	Line 3081  int addNewKernel(struct grubConfig * con	Line 3791  int addNewKernel(struct grubConfig * con
3791	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3792	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3793
3794	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3795	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3796	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3797	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 3159  int addNewKernel(struct grubConfig * con	Line 3868  int addNewKernel(struct grubConfig * con
3868	/* template is multi but new is not,	/* template is multi but new is not,
3869	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3870	*/	*/
3871	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3872	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3873	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3874	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3875		config->cfi)->key);
3876	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3877	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3878		config->cfi);
3879	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3880	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3881	char *initrdVal;	char *initrdVal;
3882	/* template is multi but new is not,	/* template is multi but new is not,
3883	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3884	*/	*/
3885	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3886	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3887	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3888	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3889		config->cfi)->key);
3890	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3891	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3892	free(initrdVal);	free(initrdVal);
3893	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3894	}	}
3895
3896	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3897	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3898	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3899	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 3236  int addNewKernel(struct grubConfig * con	Line 3947  int addNewKernel(struct grubConfig * con
3947	static const char *prefix = "'Loading ";	static const char *prefix = "'Loading ";
3948	if (tmplLine->numElements > 1 &&	if (tmplLine->numElements > 1 &&
3949	strstr(tmplLine->elements[1].item, prefix) &&	strstr(tmplLine->elements[1].item, prefix) &&
3950	masterLine->next && masterLine->next->type == LT_KERNEL) {	masterLine->next &&
3951		iskernel(masterLine->next->type)) {
3952	char *newTitle = malloc(strlen(prefix) +	char *newTitle = malloc(strlen(prefix) +
3953	strlen(newKernelTitle) + 2);	strlen(newKernelTitle) + 2);
3954
#	Line 3251  int addNewKernel(struct grubConfig * con	Line 3963  int addNewKernel(struct grubConfig * con
3963	newLine = addLineTmpl(new, tmplLine, newLine, NULL,	newLine = addLineTmpl(new, tmplLine, newLine, NULL,
3964	config->cfi);	config->cfi);
3965	}	}
3966		} else if (tmplLine->type == LT_DEVTREE &&
3967		tmplLine->numElements == 2 && newDevTreePath) {
3968		newLine = addLineTmpl(new, tmplLine, newLine,
3969		newDevTreePath + strlen(prefix),
3970		config->cfi);
3971		needs &= ~NEED_DEVTREE;
3972		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
3973		const char *ndtp = newDevTreePath;
3974		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
3975		ndtp += strlen(prefix);
3976		newLine = addLine(new, config->cfi, LT_DEVTREE,
3977		config->secondaryIndent,
3978		ndtp);
3979		needs &= ~NEED_DEVTREE;
3980		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
3981	} else {	} else {
3982	/* pass through other lines from the template */	/* pass through other lines from the template */
3983	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
#	Line 3263  int addNewKernel(struct grubConfig * con	Line 3990  int addNewKernel(struct grubConfig * con
3990	*/	*/
3991	switch (config->cfi->entryStart) {	switch (config->cfi->entryStart) {
3992	case LT_KERNEL:	case LT_KERNEL:
3993		case LT_KERNEL_EFI:
3994		case LT_KERNEL_16:
3995	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
3996	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
3997	} else {	} else {
3998	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
3999		preferredLineType(LT_KERNEL, config->cfi),
4000	config->primaryIndent,	config->primaryIndent,
4001	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4002	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3323  int addNewKernel(struct grubConfig * con	Line 4053  int addNewKernel(struct grubConfig * con
4053	}	}
4054	}	}
4055
4056		struct singleLine *endLine = NULL;
4057		endLine = getLineByType(LT_ENTRY_END, new->lines);
4058		if (endLine) {
4059		removeLine(new, endLine);
4060		needs |= NEED_END;
4061		}
4062
4063	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4064	* 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,
4065	* all the lines following the entryStart.	* all the lines following the entryStart.
#	Line 3342  int addNewKernel(struct grubConfig * con	Line 4079  int addNewKernel(struct grubConfig * con
4079	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
4080	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4081	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4082	config->cfi)) ?	config->cfi))
4083	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
4084		: preferredLineType(LT_KERNEL, config->cfi),
4085	config->secondaryIndent,	config->secondaryIndent,
4086	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4087	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3359  int addNewKernel(struct grubConfig * con	Line 4097  int addNewKernel(struct grubConfig * con
4097	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4098	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4099	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4100	config->cfi)) ?	config->cfi))
4101	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
4102		: preferredLineType(LT_INITRD, config->cfi),
4103	config->secondaryIndent,	config->secondaryIndent,
4104	initrdVal);	initrdVal);
4105	free(initrdVal);	free(initrdVal);
4106	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4107	}	}
4108		if (needs & NEED_DEVTREE) {
4109		newLine = addLine(new, config->cfi, LT_DEVTREE,
4110		config->secondaryIndent,
4111		newDevTreePath);
4112		needs &= ~NEED_DEVTREE;
4113		}
4114
4115		/* NEEDS_END must be last on bootloaders that need it... */
4116	if (needs & NEED_END) {	if (needs & NEED_END) {
4117	newLine = addLine(new, config->cfi, LT_ENTRY_END,	newLine = addLine(new, config->cfi, LT_ENTRY_END,
4118	config->secondaryIndent, NULL);	config->secondaryIndent, NULL);
#	Line 3392  static void traceback(int signum)	Line 4139  static void traceback(int signum)
4139	memset(array, '\0', sizeof (array));	memset(array, '\0', sizeof (array));
4140	size = backtrace(array, 40);	size = backtrace(array, 40);
4141
4142	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",	fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4143	(unsigned long)size);	(unsigned long)size);
4144	backtrace_symbols_fd(array, size, STDERR_FILENO);	backtrace_symbols_fd(array, size, STDERR_FILENO);
4145	exit(1);	exit(1);
#	Line 3417  int main(int argc, const char ** argv) {	Line 4164  int main(int argc, const char ** argv) {
4164	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4165	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4166	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4167	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4168	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4169	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4170	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 3427  int main(int argc, const char ** argv) {	Line 4174  int main(int argc, const char ** argv) {
4174	char * removeArgs = NULL;	char * removeArgs = NULL;
4175	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4176	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4177		char * envPath = NULL;
4178	const char * chptr = NULL;	const char * chptr = NULL;
4179	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4180	struct grubConfig * config;	struct grubConfig * config;
#	Line 3435  int main(int argc, const char ** argv) {	Line 4183  int main(int argc, const char ** argv) {
4183	int displayDefault = 0;	int displayDefault = 0;
4184	int displayDefaultIndex = 0;	int displayDefaultIndex = 0;
4185	int displayDefaultTitle = 0;	int displayDefaultTitle = 0;
4186		int defaultIndex = -1;
4187	struct poptOption options[] = {	struct poptOption options[] = {
4188	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4189	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 3452  int main(int argc, const char ** argv) {	Line 4201  int main(int argc, const char ** argv) {
4201	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4202	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4203	_("bootfs") },	_("bootfs") },
4204	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4205	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4206	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4207	#endif	#endif
4208	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4209	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
#	Line 3473  int main(int argc, const char ** argv) {	Line 4222  int main(int argc, const char ** argv) {
4222	_("display the index of the default kernel") },	_("display the index of the default kernel") },
4223	{ "default-title", 0, 0, &displayDefaultTitle, 0,	{ "default-title", 0, 0, &displayDefaultTitle, 0,
4224	_("display the title of the default kernel") },	_("display the title of the default kernel") },
4225		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4226		_("device tree file for new stanza"), _("dtb-path") },
4227	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4228	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4229		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4230		_("force grub2 stanzas to use efi") },
4231		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4232		_("path for environment data"),
4233		_("path") },
4234	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4235	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4236	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
#	Line 3487  int main(int argc, const char ** argv) {	Line 4243  int main(int argc, const char ** argv) {
4243	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4244	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4245	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4246	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4247	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4248	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4249	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 3507  int main(int argc, const char ** argv) {	Line 4263  int main(int argc, const char ** argv) {
4263	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4264	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4265	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4266		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4267		_("make the given entry index the default entry"),
4268		_("entry-index") },
4269	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4270	_("configure silo bootloader") },	_("configure silo bootloader") },
4271	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 3528  int main(int argc, const char ** argv) {	Line 4287  int main(int argc, const char ** argv) {
4287
4288	signal(SIGSEGV, traceback);	signal(SIGSEGV, traceback);
4289
4290		int i = 0;
4291		for (int j = 1; j < argc; j++)
4292		i += strlen(argv[j]) + 1;
4293		saved_command_line = malloc(i);
4294		if (!saved_command_line) {
4295		fprintf(stderr, "grubby: %m\n");
4296		exit(1);
4297		}
4298		saved_command_line[0] = '\0';
4299		for (int j = 1; j < argc; j++) {
4300		strcat(saved_command_line, argv[j]);
4301		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4302		}
4303
4304	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4305	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4306
#	Line 3571  int main(int argc, const char ** argv) {	Line 4344  int main(int argc, const char ** argv) {
4344	return 1;	return 1;
4345	} else if (configureGrub2) {	} else if (configureGrub2) {
4346	cfi = &grub2ConfigType;	cfi = &grub2ConfigType;
4347		if (envPath)
4348		cfi->envFile = envPath;
4349	} else if (configureLilo) {	} else if (configureLilo) {
4350	cfi = &liloConfigType;	cfi = &liloConfigType;
4351	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 3614  int main(int argc, const char ** argv) {	Line 4389  int main(int argc, const char ** argv) {
4389	grubConfig = cfi->defaultConfig;	grubConfig = cfi->defaultConfig;
4390	}	}
4391
4392	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4393	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4394	defaultKernel || displayDefaultIndex || displayDefaultTitle)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4395		(defaultIndex >= 0))) {
4396	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4397	"specified option"));	"specified option"));
4398	return 1;	return 1;
4399	}	}
4400
4401	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4402	removeKernelPath)) {	removeKernelPath)) {
4403	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4404	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 3658  int main(int argc, const char ** argv) {	Line 4434  int main(int argc, const char ** argv) {
4434	makeDefault = 1;	makeDefault = 1;
4435	defaultKernel = NULL;	defaultKernel = NULL;
4436	}	}
4437		else if (defaultKernel && (defaultIndex >= 0)) {
4438		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4439		"may not be used together\n"));
4440		return 1;
4441		}
4442
4443	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4444	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
#	Line 3666  int main(int argc, const char ** argv) {	Line 4447  int main(int argc, const char ** argv) {
4447	}	}
4448
4449	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4450	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4451	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4452		&& (defaultIndex == -1)) {
4453	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4454	return 1;	return 1;
4455	}	}
#	Line 3694  int main(int argc, const char ** argv) {	Line 4476  int main(int argc, const char ** argv) {
4476	}	}
4477
4478	if (bootloaderProbe) {	if (bootloaderProbe) {
4479	int lrc = 0, grc = 0, gr2c = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4480	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4481
4482	const char *grub2config = grub2FindConfig(&grub2ConfigType);	const char *grub2config = grub2FindConfig(&grub2ConfigType);
4483	if (grub2config) {	if (grub2config) {
#	Line 3723  int main(int argc, const char ** argv) {	Line 4505  int main(int argc, const char ** argv) {
4505	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4506	}	}
4507
4508		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4509		econfig = readConfig(eliloConfigType.defaultConfig,
4510		&eliloConfigType);
4511		if (!econfig)
4512		erc = 1;
4513		else
4514		erc = checkForElilo(econfig);
4515		}
4516
4517	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4518	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4519	if (!lconfig)	if (!lconfig)
4520	erc = 1;	extrc = 1;
4521	else	else
4522	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4523	}	}
4524
4525	if (lrc == 1 || grc == 1 || gr2c == 1) return 1;
4526		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4527		yconfig = readConfig(yabootConfigType.defaultConfig,
4528		&yabootConfigType);
4529		if (!yconfig)
4530		yrc = 1;
4531		else
4532		yrc = checkForYaboot(yconfig);
4533		}
4534
4535		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4536		erc == 1)
4537		return 1;
4538
4539	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4540	if (gr2c == 2) printf("grub2\n");	if (gr2c == 2) printf("grub2\n");
4541	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4542	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4543		if (yrc == 2) printf("yaboot\n");
4544		if (erc == 2) printf("elilo\n");
4545
4546	return 0;	return 0;
4547	}	}
4548
4549		if (grubConfig == NULL) {
4550		printf("Could not find bootloader configuration file.\n");
4551		exit(1);
4552		}
4553
4554	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4555	if (!config) return 1;	if (!config) return 1;
4556
#	Line 3750  int main(int argc, const char ** argv) {	Line 4560  int main(int argc, const char ** argv) {
4560	char * rootspec;	char * rootspec;
4561
4562	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4563		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4564		cfi->defaultIsSaved)
4565		config->defaultImage = 0;
4566	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4567	if (!entry) return 0;	if (!entry) return 0;
4568	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4569
4570	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4571	if (!line) return 0;	if (!line) return 0;
4572
4573	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3768  int main(int argc, const char ** argv) {	Line 4581  int main(int argc, const char ** argv) {
4581	struct singleEntry * entry;	struct singleEntry * entry;
4582
4583	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4584		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4585		cfi->defaultIsSaved)
4586		config->defaultImage = 0;
4587	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4588	if (!entry) return 0;	if (!entry) return 0;
4589
#	Line 3790  int main(int argc, const char ** argv) {	Line 4606  int main(int argc, const char ** argv) {
4606
4607	} else if (displayDefaultIndex) {	} else if (displayDefaultIndex) {
4608	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4609		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4610		cfi->defaultIsSaved)
4611		config->defaultImage = 0;
4612	printf("%i\n", config->defaultImage);	printf("%i\n", config->defaultImage);
4613		return 0;
4614
4615	} else if (kernelInfo)	} else if (kernelInfo)
4616	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
#	Line 3803  int main(int argc, const char ** argv) {	Line 4623  int main(int argc, const char ** argv) {
4623	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4624	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4625	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4626	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4627	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4628	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4629	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4630	if (updateKernelPath && newKernelInitrd) {	if (updateKernelPath && newKernelInitrd) {
4631	if (updateInitrd(config, updateKernelPath, bootPrefix,	if (newMBKernel) {
4632	newKernelInitrd)) return 1;	if (addMBInitrd(config, newMBKernel, updateKernelPath,
4633		bootPrefix, newKernelInitrd))
4634		return 1;
4635		} else {
4636		if (updateInitrd(config, updateKernelPath, bootPrefix,
4637		newKernelInitrd))
4638		return 1;
4639		}
4640	}	}
4641	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4642	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4643	(const char **)extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4644	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4645
4646
4647	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.1844   changed lines   Added in v.2713