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

Parent Directory | Revision Log | Patch

	revision 1750 by niro, Sat Feb 18 01:09:51 2012 UTC	revision 2957 by niro, Wed Jun 29 14:06:18 2016 UTC
#	Line 36	Line 36
36	#include <signal.h>	#include <signal.h>
37	#include <blkid/blkid.h>	#include <blkid/blkid.h>
38
39		#include "log.h"
40
41	#ifndef DEBUG	#ifndef DEBUG
42	#define DEBUG 0	#define DEBUG 0
43	#endif	#endif
#	Line 56  int debug = 0; /* Currently just for tem	Line 58  int debug = 0; /* Currently just for tem
58	#define NOOP_OPCODE 0x90	#define NOOP_OPCODE 0x90
59	#define JMP_SHORT_OPCODE 0xeb	#define JMP_SHORT_OPCODE 0xeb
60
61		int isEfi = 0;
62
63		#if defined(__aarch64__)
64		#define isEfiOnly 1
65		#else
66		#define isEfiOnly 0
67		#endif
68
69		char *saved_command_line = NULL;
70
71	/* comments get lumped in with indention */	/* comments get lumped in with indention */
72	struct lineElement {	struct lineElement {
73	char * item;	char * item;
#	Line 82  enum lineType_e {	Line 94  enum lineType_e {
94	LT_MENUENTRY    = 1 << 17,	LT_MENUENTRY    = 1 << 17,
95	LT_ENTRY_END    = 1 << 18,	LT_ENTRY_END    = 1 << 18,
96	LT_SET_VARIABLE = 1 << 19,	LT_SET_VARIABLE = 1 << 19,
97	LT_UNKNOWN      = 1 << 20,	LT_KERNEL_EFI   = 1 << 20,
98		LT_INITRD_EFI   = 1 << 21,
99		LT_KERNEL_16    = 1 << 22,
100		LT_INITRD_16    = 1 << 23,
101		LT_DEVTREE      = 1 << 24,
102		LT_UNKNOWN      = 1 << 25,
103	};	};
104
105	struct singleLine {	struct singleLine {
#	Line 111  struct singleEntry {	Line 128  struct singleEntry {
128	#define NEED_ARGS    (1 << 3)	#define NEED_ARGS    (1 << 3)
129	#define NEED_MB      (1 << 4)	#define NEED_MB      (1 << 4)
130	#define NEED_END     (1 << 5)	#define NEED_END     (1 << 5)
131		#define NEED_DEVTREE (1 << 6)
132
133	#define MAIN_DEFAULT    (1 << 0)	#define MAIN_DEFAULT    (1 << 0)
134	#define DEFAULT_SAVED       -2	#define DEFAULT_SAVED       -2
#	Line 128  struct configFileInfo;	Line 146  struct configFileInfo;
146	typedef const char *(*findConfigFunc)(struct configFileInfo *);	typedef const char *(*findConfigFunc)(struct configFileInfo *);
147	typedef const int (*writeLineFunc)(struct configFileInfo *,	typedef const int (*writeLineFunc)(struct configFileInfo *,
148	struct singleLine *line);	struct singleLine *line);
149		typedef char *(*getEnvFunc)(struct configFileInfo *, char *name);
150		typedef int (*setEnvFunc)(struct configFileInfo *, char *name, char *value);
151
152	struct configFileInfo {	struct configFileInfo {
153	char * defaultConfig;	char * defaultConfig;
154	findConfigFunc findConfig;	findConfigFunc findConfig;
155	writeLineFunc writeLine;	writeLineFunc writeLine;
156		getEnvFunc getEnv;
157		setEnvFunc setEnv;
158	struct keywordTypes * keywords;	struct keywordTypes * keywords;
159		int caseInsensitive;
160	int defaultIsIndex;	int defaultIsIndex;
161	int defaultIsVariable;	int defaultIsVariable;
162	int defaultSupportSaved;	int defaultSupportSaved;
163		int defaultIsSaved;
164		int defaultIsUnquoted;
165	enum lineType_e entryStart;	enum lineType_e entryStart;
166	enum lineType_e entryEnd;	enum lineType_e entryEnd;
167	int needsBootPrefix;	int needsBootPrefix;
#	Line 148  struct configFileInfo {	Line 173  struct configFileInfo {
173	int mbInitRdIsModule;	int mbInitRdIsModule;
174	int mbConcatArgs;	int mbConcatArgs;
175	int mbAllowExtraInitRds;	int mbAllowExtraInitRds;
176		char *envFile;
177	};	};
178
179	struct keywordTypes grubKeywords[] = {	struct keywordTypes grubKeywords[] = {
#	Line 164  struct keywordTypes grubKeywords[] = {	Line 190  struct keywordTypes grubKeywords[] = {
190
191	const char *grubFindConfig(struct configFileInfo *cfi) {	const char *grubFindConfig(struct configFileInfo *cfi) {
192	static const char *configFiles[] = {	static const char *configFiles[] = {
	"/etc/grub.conf",
193	"/boot/grub/grub.conf",	"/boot/grub/grub.conf",
194	"/boot/grub/menu.lst",	"/boot/grub/menu.lst",
195		"/etc/grub.conf",
196		"/boot/grub2/grub.cfg",
197		"/boot/grub2-efi/grub.cfg",
198	NULL	NULL
199	};	};
200	static int i = -1;	static int i = -1;
#	Line 205  struct keywordTypes grub2Keywords[] = {	Line 233  struct keywordTypes grub2Keywords[] = {
233	{ "default",    LT_DEFAULT,     ' ' },	{ "default",    LT_DEFAULT,     ' ' },
234	{ "fallback",   LT_FALLBACK,    ' ' },	{ "fallback",   LT_FALLBACK,    ' ' },
235	{ "linux",      LT_KERNEL,      ' ' },	{ "linux",      LT_KERNEL,      ' ' },
236		{ "linuxefi",   LT_KERNEL_EFI,  ' ' },
237		{ "linux16",    LT_KERNEL_16,   ' ' },
238	{ "initrd",     LT_INITRD,      ' ', ' ' },	{ "initrd",     LT_INITRD,      ' ', ' ' },
239		{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
240		{ "initrd16",   LT_INITRD_16,   ' ', ' ' },
241	{ "module",     LT_MBMODULE,    ' ' },	{ "module",     LT_MBMODULE,    ' ' },
242	{ "kernel",     LT_HYPER,       ' ' },	{ "kernel",     LT_HYPER,       ' ' },
243		{ "devicetree", LT_DEVTREE,  ' ' },
244	{ NULL, 0, 0 },	{ NULL, 0, 0 },
245	};	};
246
#	Line 219  const char *grub2FindConfig(struct confi	Line 252  const char *grub2FindConfig(struct confi
252	};	};
253	static int i = -1;	static int i = -1;
254	static const char *grub_cfg = "/boot/grub/grub.cfg";	static const char *grub_cfg = "/boot/grub/grub.cfg";
255		int rc = -1;
256
257	if (i == -1) {	if (i == -1) {
258	for (i = 0; configFiles[i] != NULL; i++) {	for (i = 0; configFiles[i] != NULL; i++) {
259	dbgPrintf("Checking \"%s\": ", configFiles[i]);	dbgPrintf("Checking \"%s\": ", configFiles[i]);
260	if (!access(configFiles[i], R_OK)) {	if ((rc = access(configFiles[i], R_OK))) {
261		if (errno == EACCES) {
262		printf("Unable to access bootloader configuration file "
263		"\"%s\": %m\n", configFiles[i]);
264		exit(1);
265		}
266		continue;
267		} else {
268	dbgPrintf("found\n");	dbgPrintf("found\n");
269	return configFiles[i];	return configFiles[i];
270	}	}
#	Line 242  const char *grub2FindConfig(struct confi	Line 283  const char *grub2FindConfig(struct confi
283	return configFiles[i];	return configFiles[i];
284	}	}
285
286		/* kind of hacky.  It'll give the first 1024 bytes, ish. */
287		static char *grub2GetEnv(struct configFileInfo *info, char *name)
288		{
289		static char buf[1025];
290		char *s = NULL;
291		char *ret = NULL;
292		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
293		int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
294
295		if (rc < 0)
296		return NULL;
297
298		FILE *f = popen(s, "r");
299		if (!f)
300		goto out;
301
302		memset(buf, '\0', sizeof (buf));
303		ret = fgets(buf, 1024, f);
304		pclose(f);
305
306		if (ret) {
307		ret += strlen(name) + 1;
308		ret[strlen(ret) - 1] = '\0';
309		}
310		dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
311		out:
312		free(s);
313		return ret;
314		}
315
316		static int sPopCount(const char *s, const char *c)
317		{
318		int ret = 0;
319		if (!s)
320		return -1;
321		for (int i = 0; s[i] != '\0'; i++)
322		for (int j = 0; c[j] != '\0'; j++)
323		if (s[i] == c[j])
324		ret++;
325		return ret;
326		}
327
328		static char *shellEscape(const char *s)
329		{
330		int l = strlen(s) + sPopCount(s, "'") * 2;
331
332		char *ret = calloc(l+1, sizeof (*ret));
333		if (!ret)
334		return NULL;
335		for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
336		if (s[i] == '\'')
337		ret[j++] = '\\';
338		ret[j] = s[i];
339		}
340		return ret;
341		}
342
343		static void unquote(char *s)
344		{
345		int l = strlen(s);
346
347		if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
348		memmove(s, s+1, l-2);
349		s[l-2] = '\0';
350		}
351		}
352
353		static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
354		{
355		char *s = NULL;
356		int rc = 0;
357		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
358
359		unquote(value);
360		value = shellEscape(value);
361		if (!value)
362		return -1;
363
364		rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
365		free(value);
366		if (rc <0)
367		return -1;
368
369		dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
370		rc = system(s);
371		free(s);
372		return rc;
373		}
374
375		/* this is a gigantic hack to avoid clobbering grub2 variables... */
376		static int is_special_grub2_variable(const char *name)
377		{
378		if (!strcmp(name,"\"${next_entry}\""))
379		return 1;
380		if (!strcmp(name,"\"${prev_saved_entry}\""))
381		return 1;
382		return 0;
383		}
384
385	int sizeOfSingleLine(struct singleLine * line) {	int sizeOfSingleLine(struct singleLine * line) {
	int i;
386	int count = 0;	int count = 0;
387
388	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
389	int indentSize = 0;	int indentSize = 0;
390
391	count = count + strlen(line->elements[i].item);	count = count + strlen(line->elements[i].item);
#	Line 265  int sizeOfSingleLine(struct singleLine *	Line 404  int sizeOfSingleLine(struct singleLine *
404	return count;	return count;
405	}	}
406
407		static int isquote(char q)
408		{
409		if (q == '\'' || q == '\"')
410		return 1;
411		return 0;
412		}
413
414		static int iskernel(enum lineType_e type) {
415		return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
416		}
417
418		static int isinitrd(enum lineType_e type) {
419		return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
420		}
421
422	char *grub2ExtractTitle(struct singleLine * line) {	char *grub2ExtractTitle(struct singleLine * line) {
423	char * current;	char * current;
424	char * current_indent;	char * current_indent;
#	Line 281  char *grub2ExtractTitle(struct singleLin	Line 435  char *grub2ExtractTitle(struct singleLin
435	current_len = strlen(current);	current_len = strlen(current);
436
437	/* if second word is quoted, strip the quotes and return single word */	/* if second word is quoted, strip the quotes and return single word */
438	if ((*current == '\'') && (*(current + current_len - 1) == '\'')) {	if (isquote(*current) && isquote(current[current_len - 1])) {
439	char *tmp;	char *tmp;
440
441	tmp = strdup(current);	tmp = strdup(current);
442	*(tmp + current_len - 1) = '\0';	*(tmp + current_len - 1) = '\0';
443	return ++tmp;	return ++tmp;
444	}	}
445
446	/* if no quotes, return second word verbatim */	/* if no quotes, return second word verbatim */
447	if (*current != '\'') {	if (!isquote(*current))
448	return current;	return current;
	}
449
450	/* second element start with a quote, so we have to find the element	/* second element start with a quote, so we have to find the element
451	* whose last character is also quote (assuming it's the closing one) */	* whose last character is also quote (assuming it's the closing one) */
452	if (*current == '\'') {	int resultMaxSize;
453	int resultMaxSize;	char * result;
454	char * result;
455		resultMaxSize = sizeOfSingleLine(line);
456	resultMaxSize = sizeOfSingleLine(line);	result = malloc(resultMaxSize);
457	result = malloc(resultMaxSize);	snprintf(result, resultMaxSize, "%s", ++current);
458	snprintf(result, resultMaxSize, "%s", ++current);
459		i++;
460	i++;	for (; i < line->numElements; ++i) {
	for (; i < line->numElements; ++i) {
461	current = line->elements[i].item;	current = line->elements[i].item;
462	current_len = strlen(current);	current_len = strlen(current);
463	current_indent = line->elements[i].indent;	current_indent = line->elements[i].indent;
464	current_indent_len = strlen(current_indent);	current_indent_len = strlen(current_indent);
465
466	strncat(result, current_indent, current_indent_len);	strncat(result, current_indent, current_indent_len);
467	if (*(current + current_len - 1) != '\'') {	if (!isquote(current[current_len-1])) {
468	strncat(result, current, current_len);	strncat(result, current, current_len);
469	} else {	} else {
470	strncat(result, current, current_len - 1);	strncat(result, current, current_len - 1);
471	break;	break;
472	}	}
	}
	return result;
473	}	}
474		return result;
	return NULL;
475	}	}
476
477	struct configFileInfo grub2ConfigType = {	struct configFileInfo grub2ConfigType = {
478	.findConfig = grub2FindConfig,	.findConfig = grub2FindConfig,
479		.getEnv = grub2GetEnv,
480		.setEnv = grub2SetEnv,
481	.keywords = grub2Keywords,	.keywords = grub2Keywords,
482	.defaultIsIndex = 1,	.defaultIsIndex = 1,
483	.defaultSupportSaved = 1,	.defaultSupportSaved = 1,
#	Line 481  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 505  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 569  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 602  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 644  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 690  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 700  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 709  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 724  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 822  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 834  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 853  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 874  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 887  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 903  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 914  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 977  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 1008  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 1026  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 1050  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 1059  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 1127  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 1145  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 1168  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 1185  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 1247  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 1289  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 1385  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 1412  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 1427  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		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)	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 1481  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 1507  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 1528  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 1537  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 1546  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 1605  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 1653  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 1664  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 1692  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 1714  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)
2124		cfg->defaultImage = index;
2125		}
2126		}
2127		} else if (cfg->defaultImage > -1) {
2128	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2129	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2130	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1767  void markRemovedImage(struct grubConfig	Line 2177  void markRemovedImage(struct grubConfig
2177	const char * prefix) {	const char * prefix) {
2178	struct singleEntry * entry;	struct singleEntry * entry;
2179
2180	if (!image) return;	if (!image)
2181		return;
2182
2183		/* check and see if we're removing the default image */
2184		if (isdigit(*image)) {
2185		entry = findEntryByPath(cfg, image, prefix, NULL);
2186		if(entry)
2187		entry->skip = 1;
2188		return;
2189		}
2190
2191	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2192	entry->skip = 1;	entry->skip = 1;
#	Line 1775  void markRemovedImage(struct grubConfig	Line 2194  void markRemovedImage(struct grubConfig
2194
2195	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2196	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2197	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2198	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2199	int i, j;	int i, j;
2200
2201	if (newIsDefault) {	if (newIsDefault) {
2202	config->defaultImage = 0;	config->defaultImage = 0;
2203	return;	return;
2204		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2205		if (findEntryByIndex(config, index))
2206		config->defaultImage = index;
2207		else
2208		config->defaultImage = -1;
2209		return;
2210	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2211	i = 0;	i = 0;
2212	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1853  void displayEntry(struct singleEntry * e	Line 2278  void displayEntry(struct singleEntry * e
2278	struct singleLine * line;	struct singleLine * line;
2279	char * root = NULL;	char * root = NULL;
2280	int i;	int i;
2281		int j;
2282
2283	printf("index=%d\n", index);	printf("index=%d\n", index);
2284
2285	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2286	if (!line) {	if (!line) {
2287	printf("non linux entry\n");	printf("non linux entry\n");
2288	return;	return;
2289	}	}
2290
2291	printf("kernel=%s%s\n", prefix, line->elements[1].item);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2292		printf("kernel=%s\n", line->elements[1].item);
2293		else
2294		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2295
2296	if (line->numElements >= 3) {	if (line->numElements >= 3) {
2297	printf("args=\"");	printf("args=\"");
#	Line 1918  void displayEntry(struct singleEntry * e	Line 2347  void displayEntry(struct singleEntry * e
2347	printf("root=%s\n", s);	printf("root=%s\n", s);
2348	}	}
2349
2350	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2351
2352	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
2353	printf("initrd=%s", prefix);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2354		printf("initrd=");
2355		else
2356		printf("initrd=%s", prefix);
2357
2358	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
2359	printf("%s%s", line->elements[i].item, line->elements[i].indent);	printf("%s%s", line->elements[i].item, line->elements[i].indent);
2360	printf("\n");	printf("\n");
2361	}	}
2362
2363		line = getLineByType(LT_TITLE, entry->lines);
2364		if (line) {
2365		printf("title=%s\n", line->elements[1].item);
2366		} else {
2367		char * title;
2368		line = getLineByType(LT_MENUENTRY, entry->lines);
2369		title = grub2ExtractTitle(line);
2370		if (title)
2371		printf("title=%s\n", title);
2372		}
2373
2374		for (j = 0, line = entry->lines; line; line = line->next) {
2375		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2376		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2377		printf("mbmodule%d=", j);
2378		else
2379		printf("mbmodule%d=%s", j, prefix);
2380
2381		for (i = 1; i < line->numElements; i++)
2382		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2383		printf("\n");
2384		j++;
2385		}
2386		}
2387		}
2388
2389		int isSuseSystem(void) {
2390		const char * path;
2391		const static char default_path[] = "/etc/SuSE-release";
2392
2393		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2394		path = default_path;
2395
2396		if (!access(path, R_OK))
2397		return 1;
2398		return 0;
2399		}
2400
2401		int isSuseGrubConf(const char * path) {
2402		FILE * grubConf;
2403		char * line = NULL;
2404		size_t len = 0, res = 0;
2405
2406		grubConf = fopen(path, "r");
2407		if (!grubConf) {
2408		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2409		return 0;
2410		}
2411
2412		while ((res = getline(&line, &len, grubConf)) != -1) {
2413		if (!strncmp(line, "setup", 5)) {
2414		fclose(grubConf);
2415		free(line);
2416		return 1;
2417		}
2418		}
2419
2420		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2421		path);
2422
2423		fclose(grubConf);
2424		free(line);
2425		return 0;
2426		}
2427
2428		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2429		FILE * grubConf;
2430		char * line = NULL;
2431		size_t res = 0, len = 0;
2432
2433		if (!path) return 1;
2434		if (!lbaPtr) return 1;
2435
2436		grubConf = fopen(path, "r");
2437		if (!grubConf) return 1;
2438
2439		while ((res = getline(&line, &len, grubConf)) != -1) {
2440		if (line[res - 1] == '\n')
2441		line[res - 1] = '\0';
2442		else if (len > res)
2443		line[res] = '\0';
2444		else {
2445		line = realloc(line, res + 1);
2446		line[res] = '\0';
2447		}
2448
2449		if (!strncmp(line, "setup", 5)) {
2450		if (strstr(line, "--force-lba")) {
2451		*lbaPtr = 1;
2452		} else {
2453		*lbaPtr = 0;
2454		}
2455		dbgPrintf("lba: %i\n", *lbaPtr);
2456		break;
2457		}
2458		}
2459
2460		free(line);
2461		fclose(grubConf);
2462		return 0;
2463		}
2464
2465		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2466		FILE * grubConf;
2467		char * line = NULL;
2468		size_t res = 0, len = 0;
2469		char * lastParamPtr = NULL;
2470		char * secLastParamPtr = NULL;
2471		char installDeviceNumber = '\0';
2472		char * bounds = NULL;
2473
2474		if (!path) return 1;
2475		if (!devicePtr) return 1;
2476
2477		grubConf = fopen(path, "r");
2478		if (!grubConf) return 1;
2479
2480		while ((res = getline(&line, &len, grubConf)) != -1) {
2481		if (strncmp(line, "setup", 5))
2482		continue;
2483
2484		if (line[res - 1] == '\n')
2485		line[res - 1] = '\0';
2486		else if (len > res)
2487		line[res] = '\0';
2488		else {
2489		line = realloc(line, res + 1);
2490		line[res] = '\0';
2491		}
2492
2493		lastParamPtr = bounds = line + res;
2494
2495		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2496		while (!isspace(*lastParamPtr))
2497		lastParamPtr--;
2498		lastParamPtr++;
2499
2500		secLastParamPtr = lastParamPtr - 2;
2501		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2502
2503		if (lastParamPtr + 3 > bounds) {
2504		dbgPrintf("lastParamPtr going over boundary");
2505		fclose(grubConf);
2506		free(line);
2507		return 1;
2508		}
2509		if (!strncmp(lastParamPtr, "(hd", 3))
2510		lastParamPtr += 3;
2511		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2512
2513		/*
2514		* Second last parameter will decide wether last parameter is
2515		* an IMAGE_DEVICE or INSTALL_DEVICE
2516		*/
2517		while (!isspace(*secLastParamPtr))
2518		secLastParamPtr--;
2519		secLastParamPtr++;
2520
2521		if (secLastParamPtr + 3 > bounds) {
2522		dbgPrintf("secLastParamPtr going over boundary");
2523		fclose(grubConf);
2524		free(line);
2525		return 1;
2526		}
2527		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2528		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2529		secLastParamPtr += 3;
2530		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2531		installDeviceNumber = *secLastParamPtr;
2532		} else {
2533		installDeviceNumber = *lastParamPtr;
2534		}
2535
2536		*devicePtr = malloc(6);
2537		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2538		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2539		fclose(grubConf);
2540		free(line);
2541		return 0;
2542		}
2543
2544		free(line);
2545		fclose(grubConf);
2546		return 1;
2547		}
2548
2549		int grubGetBootFromDeviceMap(const char * device,
2550		char ** bootPtr) {
2551		FILE * deviceMap;
2552		char * line = NULL;
2553		size_t res = 0, len = 0;
2554		char * devicePtr;
2555		char * bounds = NULL;
2556		const char * path;
2557		const static char default_path[] = "/boot/grub/device.map";
2558
2559		if (!device) return 1;
2560		if (!bootPtr) return 1;
2561
2562		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2563		path = default_path;
2564
2565		dbgPrintf("opening grub device.map file from: %s\n", path);
2566		deviceMap = fopen(path, "r");
2567		if (!deviceMap)
2568		return 1;
2569
2570		while ((res = getline(&line, &len, deviceMap)) != -1) {
2571		if (!strncmp(line, "#", 1))
2572		continue;
2573
2574		if (line[res - 1] == '\n')
2575		line[res - 1] = '\0';
2576		else if (len > res)
2577		line[res] = '\0';
2578		else {
2579		line = realloc(line, res + 1);
2580		line[res] = '\0';
2581		}
2582
2583		devicePtr = line;
2584		bounds = line + res;
2585
2586		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2587		devicePtr++;
2588		dbgPrintf("device: %s\n", devicePtr);
2589
2590		if (!strncmp(devicePtr, device, strlen(device))) {
2591		devicePtr += strlen(device);
2592		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2593		devicePtr++;
2594
2595		*bootPtr = strdup(devicePtr);
2596		break;
2597		}
2598		}
2599
2600		free(line);
2601		fclose(deviceMap);
2602		return 0;
2603		}
2604
2605		int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2606		char * grubDevice;
2607
2608		if (suseGrubConfGetInstallDevice(path, &grubDevice))
2609		dbgPrintf("error looking for grub installation device\n");
2610		else
2611		dbgPrintf("grubby installation device: %s\n", grubDevice);
2612
2613		if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2614		dbgPrintf("error looking for grub boot device\n");
2615		else
2616		dbgPrintf("grubby boot device: %s\n", *bootPtr);
2617
2618		free(grubDevice);
2619		return 0;
2620		}
2621
2622		int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2623		/*
2624		* This SuSE grub configuration file at this location is not your average
2625		* grub configuration file, but instead the grub commands used to setup
2626		* grub on that system.
2627		*/
2628		const char * path;
2629		const static char default_path[] = "/etc/grub.conf";
2630
2631		if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2632		path = default_path;
2633
2634		if (!isSuseGrubConf(path)) return 1;
2635
2636		if (lbaPtr) {
2637		*lbaPtr = 0;
2638		if (suseGrubConfGetLba(path, lbaPtr))
2639		return 1;
2640		}
2641
2642		if (bootPtr) {
2643		*bootPtr = NULL;
2644		suseGrubConfGetBoot(path, bootPtr);
2645		}
2646
2647		return 0;
2648	}	}
2649
2650	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
#	Line 1976  int parseSysconfigGrub(int * lbaPtr, cha	Line 2695  int parseSysconfigGrub(int * lbaPtr, cha
2695	}	}
2696
2697	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2698	char * boot;	char * boot = NULL;
2699	int lba;	int lba;
2700
2701	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2702	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2703	if (boot) printf("boot=%s\n", boot);	free(boot);
2704		return;
2705		}
2706		} else {
2707		if (parseSysconfigGrub(&lba, &boot)) {
2708		free(boot);
2709		return;
2710		}
2711		}
2712
2713		if (lba) printf("lba\n");
2714		if (boot) {
2715		printf("boot=%s\n", boot);
2716		free(boot);
2717	}	}
2718	}	}
2719
#	Line 2030  struct singleLine * addLineTmpl(struct s	Line 2762  struct singleLine * addLineTmpl(struct s
2762	{	{
2763	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2764
2765		if (isEfi && cfi == &grub2ConfigType) {
2766		enum lineType_e old = newLine->type;
2767		newLine->type = preferredLineType(newLine->type, cfi);
2768		if (old != newLine->type)
2769		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2770		}
2771
2772	if (val) {	if (val) {
2773	/* override the inherited value with our own.	/* override the inherited value with our own.
2774	* 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 2039  struct singleLine * addLineTmpl(struct s	Line 2778  struct singleLine * addLineTmpl(struct s
2778	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2779
2780	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2781	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)) {
2782	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2783	if (rootspec != NULL) {	if (rootspec != NULL) {
2784	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 2076  struct singleLine *  addLine(struct sing	Line 2815  struct singleLine *  addLine(struct sing
2815	/* 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
2816	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2817	*/	*/
2818	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2819	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2820	tmpl.type = type;	tmpl.type = type;
#	Line 2180  void removeLine(struct singleEntry * ent	Line 2918  void removeLine(struct singleEntry * ent
2918	free(line);	free(line);
2919	}	}
2920
	static int isquote(char q)
	{
	if (q == '\'' || q == '\"')
	return 1;
	return 0;
	}
2921	static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)	static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
2922	{	{
2923	struct singleLine newLine = {	struct singleLine newLine = {
#	Line 2417  int updateActualImage(struct grubConfig	Line 3148  int updateActualImage(struct grubConfig
3148	firstElement = 2;	firstElement = 2;
3149
3150	} else {	} else {
3151	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3152	if (!line) {	if (!line) {
3153	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3154	continue;	continue;
#	Line 2573  int updateImage(struct grubConfig * cfg,	Line 3304  int updateImage(struct grubConfig * cfg,
3304	return rc;	return rc;
3305	}	}
3306
3307		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3308		const char * image, const char * prefix, const char * initrd) {
3309		struct singleEntry * entry;
3310		struct singleLine * line, * kernelLine, *endLine = NULL;
3311		int index = 0;
3312
3313		if (!image) return 0;
3314
3315		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3316		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3317		if (!kernelLine) continue;
3318
3319		if (prefix) {
3320		int prefixLen = strlen(prefix);
3321		if (!strncmp(initrd, prefix, prefixLen))
3322		initrd += prefixLen;
3323		}
3324		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3325		if (endLine)
3326		removeLine(entry, endLine);
3327		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3328		kernelLine->indent, initrd);
3329		if (!line)
3330		return 1;
3331		if (endLine) {
3332		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3333		if (!line)
3334		return 1;
3335		}
3336
3337		break;
3338		}
3339
3340		return 0;
3341		}
3342
3343	int updateInitrd(struct grubConfig * cfg, const char * image,	int updateInitrd(struct grubConfig * cfg, const char * image,
3344	const char * prefix, const char * initrd) {	const char * prefix, const char * initrd) {
3345	struct singleEntry * entry;	struct singleEntry * entry;
#	Line 2582  int updateInitrd(struct grubConfig * cfg	Line 3349  int updateInitrd(struct grubConfig * cfg
3349	if (!image) return 0;	if (!image) return 0;
3350
3351	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3352	kernelLine = getLineByType(LT_KERNEL, entry->lines);	kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3353	if (!kernelLine) continue;	if (!kernelLine) continue;
3354
3355	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3356	if (line)	if (line)
3357	removeLine(entry, line);	removeLine(entry, line);
3358	if (prefix) {	if (prefix) {
#	Line 2596  int updateInitrd(struct grubConfig * cfg	Line 3363  int updateInitrd(struct grubConfig * cfg
3363	endLine = getLineByType(LT_ENTRY_END, entry->lines);	endLine = getLineByType(LT_ENTRY_END, entry->lines);
3364	if (endLine)	if (endLine)
3365	removeLine(entry, endLine);	removeLine(entry, endLine);
3366	line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);	enum lineType_e lt;
3367		switch(kernelLine->type) {
3368		case LT_KERNEL:
3369		lt = LT_INITRD;
3370		break;
3371		case LT_KERNEL_EFI:
3372		lt = LT_INITRD_EFI;
3373		break;
3374		case LT_KERNEL_16:
3375		lt = LT_INITRD_16;
3376		break;
3377		default:
3378		lt = preferredLineType(LT_INITRD, cfg->cfi);
3379		}
3380		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3381	if (!line)	if (!line)
3382	return 1;	return 1;
3383	if (endLine) {	if (endLine) {
#	Line 2802  int checkForGrub(struct grubConfig * con	Line 3583  int checkForGrub(struct grubConfig * con
3583	int fd;	int fd;
3584	unsigned char bootSect[512];	unsigned char bootSect[512];
3585	char * boot;	char * boot;
3586		int onSuse = isSuseSystem();
3587
3588	if (parseSysconfigGrub(NULL, &boot))
3589	return 0;	if (onSuse) {
3590		if (parseSuseGrubConf(NULL, &boot))
3591		return 0;
3592		} else {
3593		if (parseSysconfigGrub(NULL, &boot))
3594		return 0;
3595		}
3596
3597	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3598	if (!boot)	if (!boot)
#	Line 2823  int checkForGrub(struct grubConfig * con	Line 3611  int checkForGrub(struct grubConfig * con
3611	}	}
3612	close(fd);	close(fd);
3613
3614		/* The more elaborate checks do not work on SuSE. The checks done
3615		* seem to be reasonble (at least for now), so just return success
3616		*/
3617		if (onSuse)
3618		return 2;
3619
3620	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3621	}	}
3622
#	Line 2856  int checkForExtLinux(struct grubConfig *	Line 3650  int checkForExtLinux(struct grubConfig *
3650	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3651	}	}
3652
3653		int checkForYaboot(struct grubConfig * config) {
3654		/*
3655		* This is a simplistic check that we consider good enough for own puporses
3656		*
3657		* If we were to properly check if yaboot is *installed* we'd need to:
3658		* 1) get the system boot device (LT_BOOT)
3659		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3660		*    the content on the boot device
3661		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3662		* 4) check again if binary and boot device contents match
3663		*/
3664		if (!access("/etc/yaboot.conf", R_OK))
3665		return 2;
3666
3667		return 1;
3668		}
3669
3670		int checkForElilo(struct grubConfig * config) {
3671		if (!access("/etc/elilo.conf", R_OK))
3672		return 2;
3673
3674		return 1;
3675		}
3676
3677	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3678	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3679
#	Line 2870  static char * getRootSpecifier(char * st	Line 3688  static char * getRootSpecifier(char * st
3688	static char * getInitrdVal(struct grubConfig * config,	static char * getInitrdVal(struct grubConfig * config,
3689	const char * prefix, struct singleLine *tmplLine,	const char * prefix, struct singleLine *tmplLine,
3690	const char * newKernelInitrd,	const char * newKernelInitrd,
3691	char ** extraInitrds, int extraInitrdCount)	const char ** extraInitrds, int extraInitrdCount)
3692	{	{
3693	char *initrdVal, *end;	char *initrdVal, *end;
3694	int i;	int i;
#	Line 2915  static char * getInitrdVal(struct grubCo	Line 3733  static char * getInitrdVal(struct grubCo
3733
3734	int addNewKernel(struct grubConfig * config, struct singleEntry * template,	int addNewKernel(struct grubConfig * config, struct singleEntry * template,
3735	const char * prefix,	const char * prefix,
3736	char * newKernelPath, char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3737	char * newKernelArgs, char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3738	char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3739	char * newMBKernel, char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs,
3740		const char * newDevTreePath) {
3741	struct singleEntry * new;	struct singleEntry * new;
3742	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3743	int needs;	int needs;
#	Line 2959  int addNewKernel(struct grubConfig * con	Line 3778  int addNewKernel(struct grubConfig * con
3778	needs |= NEED_MB;	needs |= NEED_MB;
3779	new->multiboot = 1;	new->multiboot = 1;
3780	}	}
3781		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3782		needs |= NEED_DEVTREE;
3783
3784	if (template) {	if (template) {
3785	for (masterLine = template->lines;	for (masterLine = template->lines;
#	Line 2972  int addNewKernel(struct grubConfig * con	Line 3793  int addNewKernel(struct grubConfig * con
3793	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3794	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3795
3796	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3797	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3798	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3799	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 3050  int addNewKernel(struct grubConfig * con	Line 3870  int addNewKernel(struct grubConfig * con
3870	/* template is multi but new is not,	/* template is multi but new is not,
3871	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3872	*/	*/
3873	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3874	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3875	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3876	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3877		config->cfi)->key);
3878	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3879	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3880		config->cfi);
3881	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3882	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3883	char *initrdVal;	char *initrdVal;
3884	/* template is multi but new is not,	/* template is multi but new is not,
3885	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3886	*/	*/
3887	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3888	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3889	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3890	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3891		config->cfi)->key);
3892	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3893	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3894	free(initrdVal);	free(initrdVal);
3895	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3896	}	}
3897
3898	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3899	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3900	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3901	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 3127  int addNewKernel(struct grubConfig * con	Line 3949  int addNewKernel(struct grubConfig * con
3949	static const char *prefix = "'Loading ";	static const char *prefix = "'Loading ";
3950	if (tmplLine->numElements > 1 &&	if (tmplLine->numElements > 1 &&
3951	strstr(tmplLine->elements[1].item, prefix) &&	strstr(tmplLine->elements[1].item, prefix) &&
3952	masterLine->next && masterLine->next->type == LT_KERNEL) {	masterLine->next &&
3953		iskernel(masterLine->next->type)) {
3954	char *newTitle = malloc(strlen(prefix) +	char *newTitle = malloc(strlen(prefix) +
3955	strlen(newKernelTitle) + 2);	strlen(newKernelTitle) + 2);
3956
#	Line 3142  int addNewKernel(struct grubConfig * con	Line 3965  int addNewKernel(struct grubConfig * con
3965	newLine = addLineTmpl(new, tmplLine, newLine, NULL,	newLine = addLineTmpl(new, tmplLine, newLine, NULL,
3966	config->cfi);	config->cfi);
3967	}	}
3968		} else if (tmplLine->type == LT_DEVTREE &&
3969		tmplLine->numElements == 2 && newDevTreePath) {
3970		newLine = addLineTmpl(new, tmplLine, newLine,
3971		newDevTreePath + strlen(prefix),
3972		config->cfi);
3973		needs &= ~NEED_DEVTREE;
3974		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
3975		const char *ndtp = newDevTreePath;
3976		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
3977		ndtp += strlen(prefix);
3978		newLine = addLine(new, config->cfi, LT_DEVTREE,
3979		config->secondaryIndent,
3980		ndtp);
3981		needs &= ~NEED_DEVTREE;
3982		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
3983	} else {	} else {
3984	/* pass through other lines from the template */	/* pass through other lines from the template */
3985	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
#	Line 3154  int addNewKernel(struct grubConfig * con	Line 3992  int addNewKernel(struct grubConfig * con
3992	*/	*/
3993	switch (config->cfi->entryStart) {	switch (config->cfi->entryStart) {
3994	case LT_KERNEL:	case LT_KERNEL:
3995		case LT_KERNEL_EFI:
3996		case LT_KERNEL_16:
3997	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
3998	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
3999	} else {	} else {
4000	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
4001		preferredLineType(LT_KERNEL, config->cfi),
4002	config->primaryIndent,	config->primaryIndent,
4003	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4004	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3214  int addNewKernel(struct grubConfig * con	Line 4055  int addNewKernel(struct grubConfig * con
4055	}	}
4056	}	}
4057
4058		struct singleLine *endLine = NULL;
4059		endLine = getLineByType(LT_ENTRY_END, new->lines);
4060		if (endLine) {
4061		removeLine(new, endLine);
4062		needs |= NEED_END;
4063		}
4064
4065	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4066	* 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,
4067	* all the lines following the entryStart.	* all the lines following the entryStart.
#	Line 3233  int addNewKernel(struct grubConfig * con	Line 4081  int addNewKernel(struct grubConfig * con
4081	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
4082	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4083	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4084	config->cfi)) ?	config->cfi))
4085	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
4086		: preferredLineType(LT_KERNEL, config->cfi),
4087	config->secondaryIndent,	config->secondaryIndent,
4088	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4089	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3250  int addNewKernel(struct grubConfig * con	Line 4099  int addNewKernel(struct grubConfig * con
4099	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4100	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4101	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4102	config->cfi)) ?	config->cfi))
4103	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
4104		: preferredLineType(LT_INITRD, config->cfi),
4105	config->secondaryIndent,	config->secondaryIndent,
4106	initrdVal);	initrdVal);
4107	free(initrdVal);	free(initrdVal);
4108	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4109	}	}
4110		if (needs & NEED_DEVTREE) {
4111		newLine = addLine(new, config->cfi, LT_DEVTREE,
4112		config->secondaryIndent,
4113		newDevTreePath);
4114		needs &= ~NEED_DEVTREE;
4115		}
4116
4117		/* NEEDS_END must be last on bootloaders that need it... */
4118	if (needs & NEED_END) {	if (needs & NEED_END) {
4119	newLine = addLine(new, config->cfi, LT_ENTRY_END,	newLine = addLine(new, config->cfi, LT_ENTRY_END,
4120	config->secondaryIndent, NULL);	config->secondaryIndent, NULL);
#	Line 3283  static void traceback(int signum)	Line 4141  static void traceback(int signum)
4141	memset(array, '\0', sizeof (array));	memset(array, '\0', sizeof (array));
4142	size = backtrace(array, 40);	size = backtrace(array, 40);
4143
4144	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",	fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4145	(unsigned long)size);	(unsigned long)size);
4146	backtrace_symbols_fd(array, size, STDERR_FILENO);	backtrace_symbols_fd(array, size, STDERR_FILENO);
4147	exit(1);	exit(1);
#	Line 3308  int main(int argc, const char ** argv) {	Line 4166  int main(int argc, const char ** argv) {
4166	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4167	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4168	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4169	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4170	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4171	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4172	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 3318  int main(int argc, const char ** argv) {	Line 4176  int main(int argc, const char ** argv) {
4176	char * removeArgs = NULL;	char * removeArgs = NULL;
4177	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4178	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4179		char * envPath = NULL;
4180	const char * chptr = NULL;	const char * chptr = NULL;
4181	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4182	struct grubConfig * config;	struct grubConfig * config;
#	Line 3326  int main(int argc, const char ** argv) {	Line 4185  int main(int argc, const char ** argv) {
4185	int displayDefault = 0;	int displayDefault = 0;
4186	int displayDefaultIndex = 0;	int displayDefaultIndex = 0;
4187	int displayDefaultTitle = 0;	int displayDefaultTitle = 0;
4188		int defaultIndex = -1;
4189	struct poptOption options[] = {	struct poptOption options[] = {
4190	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4191	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 3343  int main(int argc, const char ** argv) {	Line 4203  int main(int argc, const char ** argv) {
4203	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4204	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4205	_("bootfs") },	_("bootfs") },
4206	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4207	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4208	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4209	#endif	#endif
4210	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4211	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
#	Line 3364  int main(int argc, const char ** argv) {	Line 4224  int main(int argc, const char ** argv) {
4224	_("display the index of the default kernel") },	_("display the index of the default kernel") },
4225	{ "default-title", 0, 0, &displayDefaultTitle, 0,	{ "default-title", 0, 0, &displayDefaultTitle, 0,
4226	_("display the title of the default kernel") },	_("display the title of the default kernel") },
4227		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4228		_("device tree file for new stanza"), _("dtb-path") },
4229	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4230	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4231		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4232		_("force grub2 stanzas to use efi") },
4233		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4234		_("path for environment data"),
4235		_("path") },
4236	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4237	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4238	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
#	Line 3378  int main(int argc, const char ** argv) {	Line 4245  int main(int argc, const char ** argv) {
4245	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4246	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4247	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4248	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4249	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4250	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4251	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 3398  int main(int argc, const char ** argv) {	Line 4265  int main(int argc, const char ** argv) {
4265	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4266	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4267	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4268		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4269		_("make the given entry index the default entry"),
4270		_("entry-index") },
4271	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4272	_("configure silo bootloader") },	_("configure silo bootloader") },
4273	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 3419  int main(int argc, const char ** argv) {	Line 4289  int main(int argc, const char ** argv) {
4289
4290	signal(SIGSEGV, traceback);	signal(SIGSEGV, traceback);
4291
4292		int i = 0;
4293		for (int j = 1; j < argc; j++)
4294		i += strlen(argv[j]) + 1;
4295		saved_command_line = malloc(i);
4296		if (!saved_command_line) {
4297		fprintf(stderr, "grubby: %m\n");
4298		exit(1);
4299		}
4300		saved_command_line[0] = '\0';
4301		for (int j = 1; j < argc; j++) {
4302		strcat(saved_command_line, argv[j]);
4303		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4304		}
4305
4306	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4307	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4308
#	Line 3462  int main(int argc, const char ** argv) {	Line 4346  int main(int argc, const char ** argv) {
4346	return 1;	return 1;
4347	} else if (configureGrub2) {	} else if (configureGrub2) {
4348	cfi = &grub2ConfigType;	cfi = &grub2ConfigType;
4349		if (envPath)
4350		cfi->envFile = envPath;
4351	} else if (configureLilo) {	} else if (configureLilo) {
4352	cfi = &liloConfigType;	cfi = &liloConfigType;
4353	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 3480  int main(int argc, const char ** argv) {	Line 4366  int main(int argc, const char ** argv) {
4366	}	}
4367
4368	if (!cfi) {	if (!cfi) {
4369		if (grub2FindConfig(&grub2ConfigType))
4370		cfi = &grub2ConfigType;
4371		else
4372	#ifdef __ia64__	#ifdef __ia64__
4373	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4374	#elif __powerpc__	#elif __powerpc__
4375	cfi = &yabootConfigType;	cfi = &yabootConfigType;
4376	#elif __sparc__	#elif __sparc__
4377	cfi = &siloConfigType;	cfi = &siloConfigType;
4378	#elif __s390__	#elif __s390__
4379	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4380	#elif __s390x__	#elif __s390x__
4381	cfi = &ziplConfigtype;	cfi = &ziplConfigtype;
4382	#else	#else
	if (grub2FindConfig(&grub2ConfigType))
	cfi = &grub2ConfigType;
	else
4383	cfi = &grubConfigType;	cfi = &grubConfigType;
4384	#endif	#endif
4385	}	}
#	Line 3505  int main(int argc, const char ** argv) {	Line 4391  int main(int argc, const char ** argv) {
4391	grubConfig = cfi->defaultConfig;	grubConfig = cfi->defaultConfig;
4392	}	}
4393
4394	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4395	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4396	defaultKernel || displayDefaultIndex || displayDefaultTitle)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4397		(defaultIndex >= 0))) {
4398	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4399	"specified option"));	"specified option"));
4400	return 1;	return 1;
4401	}	}
4402
4403	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4404	removeKernelPath)) {	removeKernelPath)) {
4405	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4406	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 3549  int main(int argc, const char ** argv) {	Line 4436  int main(int argc, const char ** argv) {
4436	makeDefault = 1;	makeDefault = 1;
4437	defaultKernel = NULL;	defaultKernel = NULL;
4438	}	}
4439		else if (defaultKernel && (defaultIndex >= 0)) {
4440		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4441		"may not be used together\n"));
4442		return 1;
4443		}
4444
4445	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4446	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
#	Line 3557  int main(int argc, const char ** argv) {	Line 4449  int main(int argc, const char ** argv) {
4449	}	}
4450
4451	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4452	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4453	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4454		&& (defaultIndex == -1)) {
4455	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4456	return 1;	return 1;
4457	}	}
#	Line 3585  int main(int argc, const char ** argv) {	Line 4478  int main(int argc, const char ** argv) {
4478	}	}
4479
4480	if (bootloaderProbe) {	if (bootloaderProbe) {
4481	int lrc = 0, grc = 0, gr2c = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4482	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4483
4484	const char *grub2config = grub2FindConfig(&grub2ConfigType);	const char *grub2config = grub2FindConfig(&grub2ConfigType);
4485	if (grub2config) {	if (grub2config) {
#	Line 3614  int main(int argc, const char ** argv) {	Line 4507  int main(int argc, const char ** argv) {
4507	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4508	}	}
4509
4510		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4511		econfig = readConfig(eliloConfigType.defaultConfig,
4512		&eliloConfigType);
4513		if (!econfig)
4514		erc = 1;
4515		else
4516		erc = checkForElilo(econfig);
4517		}
4518
4519	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4520	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4521	if (!lconfig)	if (!lconfig)
4522	erc = 1;	extrc = 1;
4523	else	else
4524	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4525	}	}
4526
4527	if (lrc == 1 || grc == 1 || gr2c == 1) return 1;
4528		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4529		yconfig = readConfig(yabootConfigType.defaultConfig,
4530		&yabootConfigType);
4531		if (!yconfig)
4532		yrc = 1;
4533		else
4534		yrc = checkForYaboot(yconfig);
4535		}
4536
4537		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4538		erc == 1)
4539		return 1;
4540
4541	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4542	if (gr2c == 2) printf("grub2\n");	if (gr2c == 2) printf("grub2\n");
4543	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4544	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4545		if (yrc == 2) printf("yaboot\n");
4546		if (erc == 2) printf("elilo\n");
4547
4548	return 0;	return 0;
4549	}	}
4550
4551		if (grubConfig == NULL) {
4552		printf("Could not find bootloader configuration file.\n");
4553		exit(1);
4554		}
4555
4556	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4557	if (!config) return 1;	if (!config) return 1;
4558
#	Line 3641  int main(int argc, const char ** argv) {	Line 4562  int main(int argc, const char ** argv) {
4562	char * rootspec;	char * rootspec;
4563
4564	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4565		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4566		cfi->defaultIsSaved)
4567		config->defaultImage = 0;
4568	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4569	if (!entry) return 0;	if (!entry) return 0;
4570	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4571
4572	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4573	if (!line) return 0;	if (!line) return 0;
4574
4575	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3659  int main(int argc, const char ** argv) {	Line 4583  int main(int argc, const char ** argv) {
4583	struct singleEntry * entry;	struct singleEntry * entry;
4584
4585	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4586		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4587		cfi->defaultIsSaved)
4588		config->defaultImage = 0;
4589	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4590	if (!entry) return 0;	if (!entry) return 0;
4591
#	Line 3681  int main(int argc, const char ** argv) {	Line 4608  int main(int argc, const char ** argv) {
4608
4609	} else if (displayDefaultIndex) {	} else if (displayDefaultIndex) {
4610	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4611		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4612		cfi->defaultIsSaved)
4613		config->defaultImage = 0;
4614	printf("%i\n", config->defaultImage);	printf("%i\n", config->defaultImage);
4615		return 0;
4616
4617	} else if (kernelInfo)	} else if (kernelInfo)
4618	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
#	Line 3694  int main(int argc, const char ** argv) {	Line 4625  int main(int argc, const char ** argv) {
4625	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4626	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4627	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4628	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4629	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4630	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4631	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4632	if (updateKernelPath && newKernelInitrd) {	if (updateKernelPath && newKernelInitrd) {
4633	if (updateInitrd(config, updateKernelPath, bootPrefix,	if (newMBKernel) {
4634	newKernelInitrd)) return 1;	if (addMBInitrd(config, newMBKernel, updateKernelPath,
4635		bootPrefix, newKernelInitrd))
4636		return 1;
4637		} else {
4638		if (updateInitrd(config, updateKernelPath, bootPrefix,
4639		newKernelInitrd))
4640		return 1;
4641		}
4642	}	}
4643	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4644	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4645	extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4646	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4647
4648
4649	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.1750   changed lines   Added in v.2957