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

Parent Directory | Revision Log | Patch

	revision 1850 by niro, Mon Jul 2 13:09:12 2012 UTC	revision 2971 by niro, Thu Jun 30 10:06:57 2016 UTC
#	Line 36	Line 36
36	#include <signal.h>	#include <signal.h>
37	#include <blkid/blkid.h>	#include <blkid/blkid.h>
38
39		#include "log.h"
40
41	#ifndef DEBUG	#ifndef DEBUG
42	#define DEBUG 0	#define DEBUG 0
43	#endif	#endif
#	Line 56  int debug = 0; /* Currently just for tem	Line 58  int debug = 0; /* Currently just for tem
58	#define NOOP_OPCODE 0x90	#define NOOP_OPCODE 0x90
59	#define JMP_SHORT_OPCODE 0xeb	#define JMP_SHORT_OPCODE 0xeb
60
61		int isEfi = 0;
62
63		#if defined(__aarch64__)
64		#define isEfiOnly 1
65		#else
66		#define isEfiOnly 0
67		#endif
68
69		char *saved_command_line = NULL;
70
71	/* comments get lumped in with indention */	/* comments get lumped in with indention */
72	struct lineElement {	struct lineElement {
73	char * item;	char * item;
#	Line 82  enum lineType_e {	Line 94  enum lineType_e {
94	LT_MENUENTRY    = 1 << 17,	LT_MENUENTRY    = 1 << 17,
95	LT_ENTRY_END    = 1 << 18,	LT_ENTRY_END    = 1 << 18,
96	LT_SET_VARIABLE = 1 << 19,	LT_SET_VARIABLE = 1 << 19,
97	LT_UNKNOWN      = 1 << 20,	LT_KERNEL_EFI   = 1 << 20,
98		LT_INITRD_EFI   = 1 << 21,
99		LT_KERNEL_16    = 1 << 22,
100		LT_INITRD_16    = 1 << 23,
101		LT_DEVTREE      = 1 << 24,
102		LT_UNKNOWN      = 1 << 25,
103	};	};
104
105	struct singleLine {	struct singleLine {
#	Line 111  struct singleEntry {	Line 128  struct singleEntry {
128	#define NEED_ARGS    (1 << 3)	#define NEED_ARGS    (1 << 3)
129	#define NEED_MB      (1 << 4)	#define NEED_MB      (1 << 4)
130	#define NEED_END     (1 << 5)	#define NEED_END     (1 << 5)
131		#define NEED_DEVTREE (1 << 6)
132
133	#define MAIN_DEFAULT    (1 << 0)	#define MAIN_DEFAULT    (1 << 0)
134	#define DEFAULT_SAVED       -2	#define DEFAULT_SAVED       -2
#	Line 128  struct configFileInfo;	Line 146  struct configFileInfo;
146	typedef const char *(*findConfigFunc)(struct configFileInfo *);	typedef const char *(*findConfigFunc)(struct configFileInfo *);
147	typedef const int (*writeLineFunc)(struct configFileInfo *,	typedef const int (*writeLineFunc)(struct configFileInfo *,
148	struct singleLine *line);	struct singleLine *line);
149		typedef char *(*getEnvFunc)(struct configFileInfo *, char *name);
150		typedef int (*setEnvFunc)(struct configFileInfo *, char *name, char *value);
151
152	struct configFileInfo {	struct configFileInfo {
153	char * defaultConfig;	char * defaultConfig;
154	findConfigFunc findConfig;	findConfigFunc findConfig;
155	writeLineFunc writeLine;	writeLineFunc writeLine;
156		getEnvFunc getEnv;
157		setEnvFunc setEnv;
158	struct keywordTypes * keywords;	struct keywordTypes * keywords;
159		int caseInsensitive;
160	int defaultIsIndex;	int defaultIsIndex;
161	int defaultIsVariable;	int defaultIsVariable;
162	int defaultSupportSaved;	int defaultSupportSaved;
163		int defaultIsSaved;
164		int defaultIsUnquoted;
165	enum lineType_e entryStart;	enum lineType_e entryStart;
166	enum lineType_e entryEnd;	enum lineType_e entryEnd;
167	int needsBootPrefix;	int needsBootPrefix;
#	Line 148  struct configFileInfo {	Line 173  struct configFileInfo {
173	int mbInitRdIsModule;	int mbInitRdIsModule;
174	int mbConcatArgs;	int mbConcatArgs;
175	int mbAllowExtraInitRds;	int mbAllowExtraInitRds;
176		char *envFile;
177	};	};
178
179	struct keywordTypes grubKeywords[] = {	struct keywordTypes grubKeywords[] = {
#	Line 164  struct keywordTypes grubKeywords[] = {	Line 190  struct keywordTypes grubKeywords[] = {
190
191	const char *grubFindConfig(struct configFileInfo *cfi) {	const char *grubFindConfig(struct configFileInfo *cfi) {
192	static const char *configFiles[] = {	static const char *configFiles[] = {
	"/etc/grub.conf",
193	"/boot/grub/grub.conf",	"/boot/grub/grub.conf",
194	"/boot/grub/menu.lst",	"/boot/grub/menu.lst",
195		"/etc/grub.conf",
196		"/boot/grub2/grub.cfg",
197		"/boot/grub2-efi/grub.cfg",
198	NULL	NULL
199	};	};
200	static int i = -1;	static int i = -1;
#	Line 205  struct keywordTypes grub2Keywords[] = {	Line 233  struct keywordTypes grub2Keywords[] = {
233	{ "default",    LT_DEFAULT,     ' ' },	{ "default",    LT_DEFAULT,     ' ' },
234	{ "fallback",   LT_FALLBACK,    ' ' },	{ "fallback",   LT_FALLBACK,    ' ' },
235	{ "linux",      LT_KERNEL,      ' ' },	{ "linux",      LT_KERNEL,      ' ' },
236		{ "linuxefi",   LT_KERNEL_EFI,  ' ' },
237		{ "linux16",    LT_KERNEL_16,   ' ' },
238	{ "initrd",     LT_INITRD,      ' ', ' ' },	{ "initrd",     LT_INITRD,      ' ', ' ' },
239		{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
240		{ "initrd16",   LT_INITRD_16,   ' ', ' ' },
241	{ "module",     LT_MBMODULE,    ' ' },	{ "module",     LT_MBMODULE,    ' ' },
242	{ "kernel",     LT_HYPER,       ' ' },	{ "kernel",     LT_HYPER,       ' ' },
243		{ "devicetree", LT_DEVTREE,  ' ' },
244	{ NULL, 0, 0 },	{ NULL, 0, 0 },
245	};	};
246
#	Line 219  const char *grub2FindConfig(struct confi	Line 252  const char *grub2FindConfig(struct confi
252	};	};
253	static int i = -1;	static int i = -1;
254	static const char *grub_cfg = "/boot/grub/grub.cfg";	static const char *grub_cfg = "/boot/grub/grub.cfg";
255		int rc = -1;
256
257	if (i == -1) {	if (i == -1) {
258	for (i = 0; configFiles[i] != NULL; i++) {	for (i = 0; configFiles[i] != NULL; i++) {
259	dbgPrintf("Checking \"%s\": ", configFiles[i]);	dbgPrintf("Checking \"%s\": ", configFiles[i]);
260	if (!access(configFiles[i], R_OK)) {	if ((rc = access(configFiles[i], R_OK))) {
261		if (errno == EACCES) {
262		printf("Unable to access bootloader configuration file "
263		"\"%s\": %m\n", configFiles[i]);
264		exit(1);
265		}
266		continue;
267		} else {
268	dbgPrintf("found\n");	dbgPrintf("found\n");
269	return configFiles[i];	return configFiles[i];
270	}	}
#	Line 242  const char *grub2FindConfig(struct confi	Line 283  const char *grub2FindConfig(struct confi
283	return configFiles[i];	return configFiles[i];
284	}	}
285
286		/* kind of hacky.  It'll give the first 1024 bytes, ish. */
287		static char *grub2GetEnv(struct configFileInfo *info, char *name)
288		{
289		static char buf[1025];
290		char *s = NULL;
291		char *ret = NULL;
292		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
293		int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
294
295		if (rc < 0)
296		return NULL;
297
298		FILE *f = popen(s, "r");
299		if (!f)
300		goto out;
301
302		memset(buf, '\0', sizeof (buf));
303		ret = fgets(buf, 1024, f);
304		pclose(f);
305
306		if (ret) {
307		ret += strlen(name) + 1;
308		ret[strlen(ret) - 1] = '\0';
309		}
310		dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
311		out:
312		free(s);
313		return ret;
314		}
315
316		static int sPopCount(const char *s, const char *c)
317		{
318		int ret = 0;
319		if (!s)
320		return -1;
321		for (int i = 0; s[i] != '\0'; i++)
322		for (int j = 0; c[j] != '\0'; j++)
323		if (s[i] == c[j])
324		ret++;
325		return ret;
326		}
327
328		static char *shellEscape(const char *s)
329		{
330		int l = strlen(s) + sPopCount(s, "'") * 2;
331
332		char *ret = calloc(l+1, sizeof (*ret));
333		if (!ret)
334		return NULL;
335		for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
336		if (s[i] == '\'')
337		ret[j++] = '\\';
338		ret[j] = s[i];
339		}
340		return ret;
341		}
342
343		static void unquote(char *s)
344		{
345		int l = strlen(s);
346
347		if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
348		memmove(s, s+1, l-2);
349		s[l-2] = '\0';
350		}
351		}
352
353		static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
354		{
355		char *s = NULL;
356		int rc = 0;
357		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
358
359		unquote(value);
360		value = shellEscape(value);
361		if (!value)
362		return -1;
363
364		rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
365		free(value);
366		if (rc <0)
367		return -1;
368
369		dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
370		rc = system(s);
371		free(s);
372		return rc;
373		}
374
375		/* this is a gigantic hack to avoid clobbering grub2 variables... */
376		static int is_special_grub2_variable(const char *name)
377		{
378		if (!strcmp(name,"\"${next_entry}\""))
379		return 1;
380		if (!strcmp(name,"\"${prev_saved_entry}\""))
381		return 1;
382		return 0;
383		}
384
385	int sizeOfSingleLine(struct singleLine * line) {	int sizeOfSingleLine(struct singleLine * line) {
386	int count = 0;	int count = 0;
387
#	Line 271  static int isquote(char q)	Line 411  static int isquote(char q)
411	return 0;	return 0;
412	}	}
413
414		static int iskernel(enum lineType_e type) {
415		return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
416		}
417
418		static int isinitrd(enum lineType_e type) {
419		return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
420		}
421
422	char *grub2ExtractTitle(struct singleLine * line) {	char *grub2ExtractTitle(struct singleLine * line) {
423	char * current;	char * current;
424	char * current_indent;	char * current_indent;
#	Line 328  char *grub2ExtractTitle(struct singleLin	Line 476  char *grub2ExtractTitle(struct singleLin
476
477	struct configFileInfo grub2ConfigType = {	struct configFileInfo grub2ConfigType = {
478	.findConfig = grub2FindConfig,	.findConfig = grub2FindConfig,
479		.getEnv = grub2GetEnv,
480		.setEnv = grub2SetEnv,
481	.keywords = grub2Keywords,	.keywords = grub2Keywords,
482	.defaultIsIndex = 1,	.defaultIsIndex = 1,
483	.defaultSupportSaved = 1,	.defaultSupportSaved = 1,
#	Line 432  struct keywordTypes extlinuxKeywords[] =	Line 582  struct keywordTypes extlinuxKeywords[] =
582	{ "initrd",    LT_INITRD,      ' ', ',' },	{ "initrd",    LT_INITRD,      ' ', ',' },
583	{ "append",    LT_KERNELARGS,  ' ' },	{ "append",    LT_KERNELARGS,  ' ' },
584	{ "prompt",     LT_UNKNOWN,     ' ' },	{ "prompt",     LT_UNKNOWN,     ' ' },
585		{ "fdt",        LT_DEVTREE,     ' ' },
586	{ NULL,    0, 0 },	{ NULL,    0, 0 },
587	};	};
588	int useextlinuxmenu;	int useextlinuxmenu;
#	Line 482  struct configFileInfo ziplConfigType = {	Line 633  struct configFileInfo ziplConfigType = {
633	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
634	.defaultConfig = "/boot/extlinux/extlinux.conf",	.defaultConfig = "/boot/extlinux/extlinux.conf",
635	.keywords = extlinuxKeywords,	.keywords = extlinuxKeywords,
636		.caseInsensitive = 1,
637	.entryStart = LT_TITLE,	.entryStart = LT_TITLE,
638	.needsBootPrefix = 1,	.needsBootPrefix = 1,
639	.maxTitleLength = 255,	.maxTitleLength = 255,
640	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
641		.defaultIsUnquoted = 1,
642	};	};
643
644	struct grubConfig {	struct grubConfig {
#	Line 506  struct singleEntry * findEntryByIndex(st	Line 659  struct singleEntry * findEntryByIndex(st
659	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
660	const char * path, const char * prefix,	const char * path, const char * prefix,
661	int * index);	int * index);
662		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
663		int * index);
664	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
665	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
666	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 570  static char * sdupprintf(const char *for	Line 725  static char * sdupprintf(const char *for
725	return buf;	return buf;
726	}	}
727
728		static enum lineType_e preferredLineType(enum lineType_e type,
729		struct configFileInfo *cfi) {
730		if (isEfi && cfi == &grub2ConfigType) {
731		switch (type) {
732		case LT_KERNEL:
733		return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
734		case LT_INITRD:
735		return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
736		default:
737		return type;
738		}
739		#if defined(__i386__) || defined(__x86_64__)
740		} else if (cfi == &grub2ConfigType) {
741		switch (type) {
742		case LT_KERNEL:
743		return LT_KERNEL_16;
744		case LT_INITRD:
745		return LT_INITRD_16;
746		default:
747		return type;
748		}
749		#endif
750		}
751		return type;
752		}
753
754	static struct keywordTypes * getKeywordByType(enum lineType_e type,	static struct keywordTypes * getKeywordByType(enum lineType_e type,
755	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
756	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
#	Line 603  static char * getuuidbydev(char *device)	Line 784  static char * getuuidbydev(char *device)
784	static enum lineType_e getTypeByKeyword(char * keyword,	static enum lineType_e getTypeByKeyword(char * keyword,
785	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
786	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
787	if (!strcmp(keyword, kw->key))	if (cfi->caseInsensitive) {
788	return kw->type;	if (!strcasecmp(keyword, kw->key))
789		return kw->type;
790		} else {
791		if (!strcmp(keyword, kw->key))
792		return kw->type;
793		}
794	}	}
795	return LT_UNKNOWN;	return LT_UNKNOWN;
796	}	}
#	Line 643  static int isEntryStart(struct singleLin	Line 829  static int isEntryStart(struct singleLin
829	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
830	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct singleLine * line) {
831	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it (leaks a byte) */
832	char * title;	char * title = NULL;
833	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
834	title++;	title = strdup(line->elements[0].item);
835	*(title + strlen(title) - 1) = '\0';	title++;
836		*(title + strlen(title) - 1) = '\0';
837		} else if (line->type == LT_MENUENTRY)
838		title = strdup(line->elements[1].item);
839		else
840		return NULL;
841	return title;	return title;
842	}	}
843
#	Line 904  static int getNextLine(char ** bufPtr, s	Line 1095  static int getNextLine(char ** bufPtr, s
1095	return 0;	return 0;
1096	}	}
1097
1098		static int isnumber(const char *s)
1099		{
1100		int i;
1101		for (i = 0; s[i] != '\0'; i++)
1102		if (s[i] < '0' || s[i] > '9')
1103		return 0;
1104		return i;
1105		}
1106
1107	static struct grubConfig * readConfig(const char * inName,	static struct grubConfig * readConfig(const char * inName,
1108	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
1109	int in;	int in;
#	Line 918  static struct grubConfig * readConfig(co	Line 1118  static struct grubConfig * readConfig(co
1118	int len;	int len;
1119	char * buf;	char * buf;
1120
1121	if (!strcmp(inName, "-")) {	if (inName == NULL) {
1122		printf("Could not find bootloader configuration\n");
1123		exit(1);
1124		} else if (!strcmp(inName, "-")) {
1125	in = 0;	in = 0;
1126	} else {	} else {
1127	if ((in = open(inName, O_RDONLY)) < 0) {	if ((in = open(inName, O_RDONLY)) < 0) {
#	Line 985  static struct grubConfig * readConfig(co	Line 1188  static struct grubConfig * readConfig(co
1188	dbgPrintf("\n");	dbgPrintf("\n");
1189	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1190	if (kwType && line->numElements == 3 &&	if (kwType && line->numElements == 3 &&
1191	!strcmp(line->elements[1].item, kwType->key)) {	!strcmp(line->elements[1].item, kwType->key) &&
1192		!is_special_grub2_variable(line->elements[2].item)) {
1193	dbgPrintf("Line sets default config\n");	dbgPrintf("Line sets default config\n");
1194	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1195	defaultLine = line;	defaultLine = line;
1196	}	}
	} else if (line->type == LT_DEFAULT && line->numElements == 2) {
	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
	defaultLine = line;
1197
1198	} else if (line->type == LT_KERNEL) {	} else if (iskernel(line->type)) {
1199	/* if by some freak chance this is multiboot and the "module"	/* if by some freak chance this is multiboot and the "module"
1200	* lines came earlier in the template, make sure to use LT_HYPER	* lines came earlier in the template, make sure to use LT_HYPER
1201	* instead of LT_KERNEL now	* instead of LT_KERNEL now
1202	*/	*/
1203	if (entry->multiboot)	if (entry && entry->multiboot)
1204	line->type = LT_HYPER;	line->type = LT_HYPER;
1205
1206	} else if (line->type == LT_MBMODULE) {	} else if (line->type == LT_MBMODULE) {
#	Line 1011  static struct grubConfig * readConfig(co	Line 1212  static struct grubConfig * readConfig(co
1212	for (struct singleLine *l = entry->lines; l; l = l->next) {	for (struct singleLine *l = entry->lines; l; l = l->next) {
1213	if (l->type == LT_HYPER)	if (l->type == LT_HYPER)
1214	break;	break;
1215	else if (l->type == LT_KERNEL) {	else if (iskernel(l->type)) {
1216	l->type = LT_HYPER;	l->type = LT_HYPER;
1217	break;	break;
1218	}	}
#	Line 1025  static struct grubConfig * readConfig(co	Line 1226  static struct grubConfig * readConfig(co
1226	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1227	if (*end) cfg->fallbackImage = -1;	if (*end) cfg->fallbackImage = -1;
1228
1229	} else if (line->type == LT_TITLE && line->numElements > 1) {	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1230	/* make the title a single argument (undoing our parsing) */	(line->type == LT_TITLE && line->numElements > 1)) {
1231		/* make the title/default a single argument (undoing our parsing) */
1232	len = 0;	len = 0;
1233	for (int i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1234	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
#	Line 1133  static struct grubConfig * readConfig(co	Line 1335  static struct grubConfig * readConfig(co
1335	}	}
1336	}	}
1337
1338		if (line->type == LT_DEFAULT && line->numElements == 2) {
1339		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1340		defaultLine = line;
1341		}
1342
1343	/* If we find a generic config option which should live at the	/* If we find a generic config option which should live at the
1344	top of the file, move it there. Old versions of grubby were	top of the file, move it there. Old versions of grubby were
1345	probably responsible for putting new images in the wrong	probably responsible for putting new images in the wrong
#	Line 1190  static struct grubConfig * readConfig(co	Line 1397  static struct grubConfig * readConfig(co
1397	if (defaultLine->numElements > 2 &&	if (defaultLine->numElements > 2 &&
1398	cfi->defaultSupportSaved &&	cfi->defaultSupportSaved &&
1399	!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {	!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1400	cfg->defaultImage = DEFAULT_SAVED_GRUB2;	cfg->cfi->defaultIsSaved = 1;
1401		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1402		if (cfg->cfi->getEnv) {
1403		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1404		if (defTitle) {
1405		int index = 0;
1406		if (isnumber(defTitle)) {
1407		index = atoi(defTitle);
1408		entry = findEntryByIndex(cfg, index);
1409		} else {
1410		entry = findEntryByTitle(cfg, defTitle, &index);
1411		}
1412		if (entry)
1413		cfg->defaultImage = index;
1414		}
1415		}
1416	} else if (cfi->defaultIsVariable) {	} else if (cfi->defaultIsVariable) {
1417	char *value = defaultLine->elements[2].item;	char *value = defaultLine->elements[2].item;
1418	while (*value && (*value == '"' || *value == '\'' ||	while (*value && (*value == '"' || *value == '\'' ||
#	Line 1231  static struct grubConfig * readConfig(co	Line 1453  static struct grubConfig * readConfig(co
1453	cfg->defaultImage = -1;	cfg->defaultImage = -1;
1454	}	}
1455	}	}
1456		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1457		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1458		if (defTitle) {
1459		int index = 0;
1460		if (isnumber(defTitle)) {
1461		index = atoi(defTitle);
1462		entry = findEntryByIndex(cfg, index);
1463		} else {
1464		entry = findEntryByTitle(cfg, defTitle, &index);
1465		}
1466		if (entry)
1467		cfg->defaultImage = index;
1468		}
1469	} else {	} else {
1470	cfg->defaultImage = 0;	cfg->defaultImage = 0;
1471	}	}
#	Line 1248  static void writeDefault(FILE * out, cha	Line 1483  static void writeDefault(FILE * out, cha
1483
1484	if (cfg->defaultImage == DEFAULT_SAVED)	if (cfg->defaultImage == DEFAULT_SAVED)
1485	fprintf(out, "%sdefault%ssaved\n", indent, separator);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1486	else if (cfg->defaultImage == DEFAULT_SAVED_GRUB2)	else if (cfg->cfi->defaultIsSaved) {
1487	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1488	else if (cfg->defaultImage > -1) {	if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1489		char *title;
1490		entry = findEntryByIndex(cfg, cfg->defaultImage);
1491		line = getLineByType(LT_MENUENTRY, entry->lines);
1492		if (!line)
1493		line = getLineByType(LT_TITLE, entry->lines);
1494		if (line) {
1495		title = extractTitle(line);
1496		if (title)
1497		cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1498		}
1499		}
1500		} else if (cfg->defaultImage > -1) {
1501	if (cfg->cfi->defaultIsIndex) {	if (cfg->cfi->defaultIsIndex) {
1502	if (cfg->cfi->defaultIsVariable) {	if (cfg->cfi->defaultIsVariable) {
1503	fprintf(out, "%sset default=\"%d\"\n", indent,	fprintf(out, "%sset default=\"%d\"\n", indent,
#	Line 1310  static int writeConfig(struct grubConfig	Line 1557  static int writeConfig(struct grubConfig
1557
1558	/* most likely the symlink is relative, so change our	/* most likely the symlink is relative, so change our
1559	directory to the dir of the symlink */	directory to the dir of the symlink */
1560	rc = chdir(dirname(outName));	char *dir = strdupa(outName);
1561		rc = chdir(dirname(dir));
1562	do {	do {
1563	buf = alloca(len + 1);	buf = alloca(len + 1);
1564	rc = readlink(basename(outName), buf, len);	rc = readlink(basename(outName), buf, len);
#	Line 1352  static int writeConfig(struct grubConfig	Line 1600  static int writeConfig(struct grubConfig
1600	while (line) {	while (line) {
1601	if (line->type == LT_SET_VARIABLE && defaultKw &&	if (line->type == LT_SET_VARIABLE && defaultKw &&
1602	line->numElements == 3 &&	line->numElements == 3 &&
1603	!strcmp(line->elements[1].item, defaultKw->key)) {	!strcmp(line->elements[1].item, defaultKw->key) &&
1604		!is_special_grub2_variable(line->elements[2].item)) {
1605	writeDefault(out, line->indent, line->elements[0].indent, cfg);	writeDefault(out, line->indent, line->elements[0].indent, cfg);
1606	needs &= ~MAIN_DEFAULT;	needs &= ~MAIN_DEFAULT;
1607	} else if (line->type == LT_DEFAULT) {	} else if (line->type == LT_DEFAULT) {
#	Line 1497  static char *findDiskForRoot()	Line 1746  static char *findDiskForRoot()
1746	return NULL;	return NULL;
1747	}	}
1748
1749	void printEntry(struct singleEntry * entry) {	void printEntry(struct singleEntry * entry, FILE *f) {
1750	int i;	int i;
1751	struct singleLine * line;	struct singleLine * line;
1752
1753	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
1754	fprintf(stderr, "DBG: %s", line->indent);	log_message(f, "DBG: %s", line->indent);
1755	for (i = 0; i < line->numElements; i++) {	for (i = 0; i < line->numElements; i++) {
1756	/* Need to handle this, because we strip the quotes from	/* Need to handle this, because we strip the quotes from
1757	* menuentry when read it. */	* menuentry when read it. */
1758	if (line->type == LT_MENUENTRY && i == 1) {	if (line->type == LT_MENUENTRY && i == 1) {
1759	if(!isquote(*line->elements[i].item))	if(!isquote(*line->elements[i].item))
1760	fprintf(stderr, "\'%s\'", line->elements[i].item);	log_message(f, "\'%s\'", line->elements[i].item);
1761	else	else
1762	fprintf(stderr, "%s", line->elements[i].item);	log_message(f, "%s", line->elements[i].item);
1763	fprintf(stderr, "%s", line->elements[i].indent);	log_message(f, "%s", line->elements[i].indent);
1764
1765	continue;	continue;
1766	}	}
1767
1768	fprintf(stderr, "%s%s",	log_message(f, "%s%s",
1769	line->elements[i].item, line->elements[i].indent);	line->elements[i].item, line->elements[i].indent);
1770	}	}
1771	fprintf(stderr, "\n");	log_message(f, "\n");
1772	}	}
1773	}	}
1774
1775	void notSuitablePrintf(struct singleEntry * entry, const char *fmt, ...)	void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1776	{	{
1777	va_list argp;	static int once;
1778		va_list argp, argq;
1779
1780	if (!debug)	va_start(argp, fmt);
1781
1782		va_copy(argq, argp);
1783		if (!once) {
1784		log_time(NULL);
1785		log_message(NULL, "command line: %s\n", saved_command_line);
1786		}
1787		log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1788		log_vmessage(NULL, fmt, argq);
1789
1790		printEntry(entry, NULL);
1791		va_end(argq);
1792
1793		if (!debug) {
1794		once = 1;
1795		va_end(argp);
1796	return;	return;
1797		}
1798
1799	va_start(argp, fmt);	if (okay) {
1800		va_end(argp);
1801		return;
1802		}
1803
1804		if (!once)
1805		log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1806		once = 1;
1807	fprintf(stderr, "DBG: Image entry failed: ");	fprintf(stderr, "DBG: Image entry failed: ");
1808	vfprintf(stderr, fmt, argp);	vfprintf(stderr, fmt, argp);
1809	printEntry(entry);	printEntry(entry, stderr);
1810	va_end(argp);	va_end(argp);
1811	}	}
1812
#	Line 1560  int suitableImage(struct singleEntry * e	Line 1833  int suitableImage(struct singleEntry * e
1833	char * rootdev;	char * rootdev;
1834
1835	if (skipRemoved && entry->skip) {	if (skipRemoved && entry->skip) {
1836	notSuitablePrintf(entry, "marked to skip\n");	notSuitablePrintf(entry, 0, "marked to skip\n");
1837	return 0;	return 0;
1838	}	}
1839
1840	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1841	if (!line) {	if (!line) {
1842	notSuitablePrintf(entry, "no line found\n");	notSuitablePrintf(entry, 0, "no line found\n");
1843	return 0;	return 0;
1844	}	}
1845	if (line->numElements < 2) {	if (line->numElements < 2) {
1846	notSuitablePrintf(entry, "line has only %d elements\n",	notSuitablePrintf(entry, 0, "line has only %d elements\n",
1847	line->numElements);	line->numElements);
1848	return 0;	return 0;
1849	}	}
1850
1851	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	if (flags & GRUBBY_BADIMAGE_OKAY) {
1852		notSuitablePrintf(entry, 1, "\n");
1853		return 1;
1854		}
1855
1856	fullName = alloca(strlen(bootPrefix) +	fullName = alloca(strlen(bootPrefix) +
1857	strlen(line->elements[1].item) + 1);	strlen(line->elements[1].item) + 1);
#	Line 1586  int suitableImage(struct singleEntry * e	Line 1862  int suitableImage(struct singleEntry * e
1862	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1863	line->elements[1].item + rootspec_offset);	line->elements[1].item + rootspec_offset);
1864	if (access(fullName, R_OK)) {	if (access(fullName, R_OK)) {
1865	notSuitablePrintf(entry, "access to %s failed\n", fullName);	notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1866	return 0;	return 0;
1867	}	}
1868	for (i = 2; i < line->numElements; i++)	for (i = 2; i < line->numElements; i++)
#	Line 1607  int suitableImage(struct singleEntry * e	Line 1883  int suitableImage(struct singleEntry * e
1883
1884	/* failed to find one */	/* failed to find one */
1885	if (!line) {	if (!line) {
1886	notSuitablePrintf(entry, "no line found\n");	notSuitablePrintf(entry, 0, "no line found\n");
1887	return 0;	return 0;
1888	}	}
1889
#	Line 1616  int suitableImage(struct singleEntry * e	Line 1892  int suitableImage(struct singleEntry * e
1892	if (i < line->numElements)	if (i < line->numElements)
1893	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1894	else {	else {
1895	notSuitablePrintf(entry, "no root= entry found\n");	notSuitablePrintf(entry, 0, "no root= entry found\n");
1896	/* it failed too...  can't find root= */	/* it failed too...  can't find root= */
1897	return 0;	return 0;
1898	}	}
#	Line 1625  int suitableImage(struct singleEntry * e	Line 1901  int suitableImage(struct singleEntry * e
1901
1902	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1903	if (!getpathbyspec(dev)) {	if (!getpathbyspec(dev)) {
1904	notSuitablePrintf(entry, "can't find blkid entry for %s\n", dev);	notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1905	return 0;	return 0;
1906	} else	} else
1907	dev = getpathbyspec(dev);	dev = getpathbyspec(dev);
1908
1909	rootdev = findDiskForRoot();	rootdev = findDiskForRoot();
1910	if (!rootdev) {	if (!rootdev) {
1911	notSuitablePrintf(entry, "can't find root device\n");	notSuitablePrintf(entry, 0, "can't find root device\n");
1912	return 0;	return 0;
1913	}	}
1914
1915	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1916	notSuitablePrintf(entry, "uuid missing: rootdev %s, dev %s\n",	notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1917	getuuidbydev(rootdev), getuuidbydev(dev));	getuuidbydev(rootdev), getuuidbydev(dev));
1918	free(rootdev);	free(rootdev);
1919	return 0;	return 0;
1920	}	}
1921
1922	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1923	notSuitablePrintf(entry, "uuid mismatch: rootdev %s, dev %s\n",	notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1924	getuuidbydev(rootdev), getuuidbydev(dev));	getuuidbydev(rootdev), getuuidbydev(dev));
1925	free(rootdev);	free(rootdev);
1926	return 0;	return 0;
1927	}	}
1928
1929	free(rootdev);	free(rootdev);
1930		notSuitablePrintf(entry, 1, "\n");
1931
1932	return 1;	return 1;
1933	}	}
#	Line 1684  struct singleEntry * findEntryByPath(str	Line 1961  struct singleEntry * findEntryByPath(str
1961	}	}
1962
1963	indexVars[i + 1] = -1;	indexVars[i + 1] = -1;
1964
1965	i = 0;	i = 0;
1966	if (index) {	if (index) {
1967	while (i < *index) i++;	while (i < *index) {
1968	if (indexVars[i] == -1) return NULL;	i++;
1969		if (indexVars[i] == -1) return NULL;
1970		}
1971	}	}
1972
1973	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
1974	if (!entry) return NULL;	if (!entry) return NULL;
1975
1976	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1977	if (!line) return NULL;	if (!line) return NULL;
1978
1979	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1743  struct singleEntry * findEntryByPath(str	Line 2022  struct singleEntry * findEntryByPath(str
2022
2023	/* check all the lines matching checkType */	/* check all the lines matching checkType */
2024	for (line = entry->lines; line; line = line->next) {	for (line = entry->lines; line; line = line->next) {
2025	line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?	enum lineType_e ct = checkType;
2026	LT_KERNEL|LT_MBMODULE|LT_HYPER :	if (entry->multiboot && checkType == LT_KERNEL)
2027	checkType, line);	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2028	if (!line) break;  /* not found in this entry */	else if (checkType & LT_KERNEL)
2029		ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2030		line = getLineByType(ct, line);
2031		if (!line)
2032		break;  /* not found in this entry */
2033
2034	if (line && line->type != LT_MENUENTRY &&	if (line && line->type != LT_MENUENTRY &&
2035	line->numElements >= 2) {	line->numElements >= 2) {
#	Line 1765  struct singleEntry * findEntryByPath(str	Line 2048  struct singleEntry * findEntryByPath(str
2048	* non-Linux boot entries (could find netbsd etc, though, which is	* non-Linux boot entries (could find netbsd etc, though, which is
2049	* unfortunate)	* unfortunate)
2050	*/	*/
2051	if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2052	break; /* found 'im! */	break; /* found 'im! */
2053	}	}
2054
#	Line 1775  struct singleEntry * findEntryByPath(str	Line 2058  struct singleEntry * findEntryByPath(str
2058	return entry;	return entry;
2059	}	}
2060
2061		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2062		int * index) {
2063		struct singleEntry * entry;
2064		struct singleLine * line;
2065		int i;
2066		char * newtitle;
2067
2068		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2069		if (index && i < *index)
2070		continue;
2071		line = getLineByType(LT_TITLE, entry->lines);
2072		if (!line)
2073		line = getLineByType(LT_MENUENTRY, entry->lines);
2074		if (!line)
2075		continue;
2076		newtitle = grub2ExtractTitle(line);
2077		if (!newtitle)
2078		continue;
2079		if (!strcmp(title, newtitle))
2080		break;
2081		}
2082
2083		if (!entry)
2084		return NULL;
2085
2086		if (index)
2087		*index = i;
2088		return entry;
2089		}
2090
2091	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
2092	struct singleEntry * entry;	struct singleEntry * entry;
2093
#	Line 1797  struct singleEntry * findTemplate(struct	Line 2110  struct singleEntry * findTemplate(struct
2110	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2111	int index;	int index;
2112
2113	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2114		if (cfg->cfi->getEnv) {
2115		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2116		if (defTitle) {
2117		int index = 0;
2118		if (isnumber(defTitle)) {
2119		index = atoi(defTitle);
2120		entry = findEntryByIndex(cfg, index);
2121		} else {
2122		entry = findEntryByTitle(cfg, defTitle, &index);
2123		}
2124		if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2125		cfg->defaultImage = index;
2126		if (indexPtr)
2127		*indexPtr = index;
2128		return entry;
2129		}
2130		}
2131		}
2132		} else if (cfg->defaultImage > -1) {
2133	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2134	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2135	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1867  void markRemovedImage(struct grubConfig	Line 2199  void markRemovedImage(struct grubConfig
2199
2200	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2201	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2202	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2203	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2204	int i, j;	int i, j;
2205
2206	if (newIsDefault) {	if (newIsDefault) {
2207	config->defaultImage = 0;	config->defaultImage = 0;
2208	return;	return;
2209		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2210		if (findEntryByIndex(config, index))
2211		config->defaultImage = index;
2212		else
2213		config->defaultImage = -1;
2214		return;
2215	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2216	i = 0;	i = 0;
2217	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1945  void displayEntry(struct singleEntry * e	Line 2283  void displayEntry(struct singleEntry * e
2283	struct singleLine * line;	struct singleLine * line;
2284	char * root = NULL;	char * root = NULL;
2285	int i;	int i;
2286		int j;
2287
2288	printf("index=%d\n", index);	printf("index=%d\n", index);
2289
2290	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2291	if (!line) {	if (!line) {
2292	printf("non linux entry\n");	printf("non linux entry\n");
2293	return;	return;
#	Line 2013  void displayEntry(struct singleEntry * e	Line 2352  void displayEntry(struct singleEntry * e
2352	printf("root=%s\n", s);	printf("root=%s\n", s);
2353	}	}
2354
2355	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2356
2357	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
2358	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
#	Line 2032  void displayEntry(struct singleEntry * e	Line 2371  void displayEntry(struct singleEntry * e
2371	} else {	} else {
2372	char * title;	char * title;
2373	line = getLineByType(LT_MENUENTRY, entry->lines);	line = getLineByType(LT_MENUENTRY, entry->lines);
2374	title = grub2ExtractTitle(line);	if (line) {
2375	if (title)	title = grub2ExtractTitle(line);
2376	printf("title=%s\n", title);	if (title)
2377		printf("title=%s\n", title);
2378		}
2379		}
2380
2381		for (j = 0, line = entry->lines; line; line = line->next) {
2382		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2383		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2384		printf("mbmodule%d=", j);
2385		else
2386		printf("mbmodule%d=%s", j, prefix);
2387
2388		for (i = 1; i < line->numElements; i++)
2389		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2390		printf("\n");
2391		j++;
2392		}
2393	}	}
2394	}	}
2395
#	Line 2350  void dumpSysconfigGrub(void) {	Line 2705  void dumpSysconfigGrub(void) {
2705	char * boot = NULL;	char * boot = NULL;
2706	int lba;	int lba;
2707
2708	if (!isSuseSystem()) {	if (isSuseSystem()) {
2709	if (parseSysconfigGrub(&lba, &boot)) {	if (parseSuseGrubConf(&lba, &boot)) {
2710	free(boot);	free(boot);
2711	return;	return;
2712	}	}
2713	} else {	} else {
2714	if (parseSuseGrubConf(&lba, &boot)) {	if (parseSysconfigGrub(&lba, &boot)) {
2715	free(boot);	free(boot);
2716	return;	return;
2717	}	}
#	Line 2414  struct singleLine * addLineTmpl(struct s	Line 2769  struct singleLine * addLineTmpl(struct s
2769	{	{
2770	struct singleLine * newLine = lineDup(tmplLine);	struct singleLine * newLine = lineDup(tmplLine);
2771
2772		if (isEfi && cfi == &grub2ConfigType) {
2773		enum lineType_e old = newLine->type;
2774		newLine->type = preferredLineType(newLine->type, cfi);
2775		if (old != newLine->type)
2776		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2777		}
2778
2779	if (val) {	if (val) {
2780	/* override the inherited value with our own.	/* override the inherited value with our own.
2781	* This is a little weak because it only applies to elements[1]	* This is a little weak because it only applies to elements[1]
#	Line 2423  struct singleLine * addLineTmpl(struct s	Line 2785  struct singleLine * addLineTmpl(struct s
2785	insertElement(newLine, val, 1, cfi);	insertElement(newLine, val, 1, cfi);
2786
2787	/* but try to keep the rootspec from the template... sigh */	/* but try to keep the rootspec from the template... sigh */
2788	if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD)) {	if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI|LT_KERNEL_16|LT_INITRD_16)) {
2789	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2790	if (rootspec != NULL) {	if (rootspec != NULL) {
2791	free(newLine->elements[1].item);	free(newLine->elements[1].item);
#	Line 2460  struct singleLine *  addLine(struct sing	Line 2822  struct singleLine *  addLine(struct sing
2822	/* NB: This function shouldn't allocate items on the heap, rather on the	/* NB: This function shouldn't allocate items on the heap, rather on the
2823	* stack since it calls addLineTmpl which will make copies.	* stack since it calls addLineTmpl which will make copies.
2824	*/	*/
2825	if (type == LT_TITLE && cfi->titleBracketed) {	if (type == LT_TITLE && cfi->titleBracketed) {
2826	/* we're doing a bracketed title (zipl) */	/* we're doing a bracketed title (zipl) */
2827	tmpl.type = type;	tmpl.type = type;
#	Line 2794  int updateActualImage(struct grubConfig	Line 3155  int updateActualImage(struct grubConfig
3155	firstElement = 2;	firstElement = 2;
3156
3157	} else {	} else {
3158	line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3159	if (!line) {	if (!line) {
3160	/* no LT_KERNEL or LT_MBMODULE in this entry? */	/* no LT_KERNEL or LT_MBMODULE in this entry? */
3161	continue;	continue;
#	Line 2950  int updateImage(struct grubConfig * cfg,	Line 3311  int updateImage(struct grubConfig * cfg,
3311	return rc;	return rc;
3312	}	}
3313
3314		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3315		const char * image, const char * prefix, const char * initrd,
3316		const char * title) {
3317		struct singleEntry * entry;
3318		struct singleLine * line, * kernelLine, *endLine = NULL;
3319		int index = 0;
3320
3321		if (!image) return 0;
3322
3323		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3324		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3325		if (!kernelLine) continue;
3326
3327		/* if title is supplied, the entry's title must match it. */
3328		if (title) {
3329		char *linetitle;
3330
3331		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3332		if (!line)
3333		continue;
3334
3335		linetitle = extractTitle(line);
3336		if (!linetitle)
3337		continue;
3338		if (strcmp(title, linetitle)) {
3339		free(linetitle);
3340		continue;
3341		}
3342		free(linetitle);
3343		}
3344
3345		if (prefix) {
3346		int prefixLen = strlen(prefix);
3347		if (!strncmp(initrd, prefix, prefixLen))
3348		initrd += prefixLen;
3349		}
3350		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3351		if (endLine)
3352		removeLine(entry, endLine);
3353		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3354		kernelLine->indent, initrd);
3355		if (!line)
3356		return 1;
3357		if (endLine) {
3358		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3359		if (!line)
3360		return 1;
3361		}
3362
3363		break;
3364		}
3365
3366		return 0;
3367		}
3368
3369	int updateInitrd(struct grubConfig * cfg, const char * image,	int updateInitrd(struct grubConfig * cfg, const char * image,
3370	const char * prefix, const char * initrd) {	const char * prefix, const char * initrd, const char * title) {
3371	struct singleEntry * entry;	struct singleEntry * entry;
3372	struct singleLine * line, * kernelLine, *endLine = NULL;	struct singleLine * line, * kernelLine, *endLine = NULL;
3373	int index = 0;	int index = 0;
#	Line 2959  int updateInitrd(struct grubConfig * cfg	Line 3375  int updateInitrd(struct grubConfig * cfg
3375	if (!image) return 0;	if (!image) return 0;
3376
3377	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3378	kernelLine = getLineByType(LT_KERNEL, entry->lines);	kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3379	if (!kernelLine) continue;	if (!kernelLine) continue;
3380
3381	line = getLineByType(LT_INITRD, entry->lines);	/* if title is supplied, the entry's title must match it. */
3382		if (title) {
3383		char *linetitle;
3384
3385		line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
3386		if (!line)
3387		continue;
3388
3389		linetitle = extractTitle(line);
3390		if (!linetitle)
3391		continue;
3392		if (strcmp(title, linetitle)) {
3393		free(linetitle);
3394		continue;
3395		}
3396		free(linetitle);
3397		}
3398
3399		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3400	if (line)	if (line)
3401	removeLine(entry, line);	removeLine(entry, line);
3402	if (prefix) {	if (prefix) {
#	Line 2973  int updateInitrd(struct grubConfig * cfg	Line 3407  int updateInitrd(struct grubConfig * cfg
3407	endLine = getLineByType(LT_ENTRY_END, entry->lines);	endLine = getLineByType(LT_ENTRY_END, entry->lines);
3408	if (endLine)	if (endLine)
3409	removeLine(entry, endLine);	removeLine(entry, endLine);
3410	line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);	enum lineType_e lt;
3411		switch(kernelLine->type) {
3412		case LT_KERNEL:
3413		lt = LT_INITRD;
3414		break;
3415		case LT_KERNEL_EFI:
3416		lt = LT_INITRD_EFI;
3417		break;
3418		case LT_KERNEL_16:
3419		lt = LT_INITRD_16;
3420		break;
3421		default:
3422		lt = preferredLineType(LT_INITRD, cfg->cfi);
3423		}
3424		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3425	if (!line)	if (!line)
3426	return 1;	return 1;
3427	if (endLine) {	if (endLine) {
#	Line 3179  int checkForGrub(struct grubConfig * con	Line 3627  int checkForGrub(struct grubConfig * con
3627	int fd;	int fd;
3628	unsigned char bootSect[512];	unsigned char bootSect[512];
3629	char * boot;	char * boot;
3630	int onSuse;	int onSuse = isSuseSystem();
3631
3632
3633	onSuse = isSuseSystem();	if (onSuse) {
3634	if (!onSuse) {	if (parseSuseGrubConf(NULL, &boot))
3635	if (parseSysconfigGrub(NULL, &boot)) return 0;	return 0;
3636	} else {	} else {
3637	if (parseSuseGrubConf(NULL, &boot)) return 0;	if (parseSysconfigGrub(NULL, &boot))
3638		return 0;
3639	}	}
3640
3641	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
#	Line 3205  int checkForGrub(struct grubConfig * con	Line 3655  int checkForGrub(struct grubConfig * con
3655	}	}
3656	close(fd);	close(fd);
3657
3658	if (!onSuse)	/* The more elaborate checks do not work on SuSE. The checks done
3659	return checkDeviceBootloader(boot, bootSect);	* seem to be reasonble (at least for now), so just return success
3660	else	*/
3661	/*	if (onSuse)
	* The more elaborate checks do not work on SuSE. The checks done
	* seem to be reasonble (at least for now), so just return success
	*/
3662	return 2;	return 2;
3663
3664		return checkDeviceBootloader(boot, bootSect);
3665	}	}
3666
3667	int checkForExtLinux(struct grubConfig * config) {	int checkForExtLinux(struct grubConfig * config) {
#	Line 3245  int checkForExtLinux(struct grubConfig *	Line 3694  int checkForExtLinux(struct grubConfig *
3694	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3695	}	}
3696
3697		int checkForYaboot(struct grubConfig * config) {
3698		/*
3699		* This is a simplistic check that we consider good enough for own puporses
3700		*
3701		* If we were to properly check if yaboot is *installed* we'd need to:
3702		* 1) get the system boot device (LT_BOOT)
3703		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3704		*    the content on the boot device
3705		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3706		* 4) check again if binary and boot device contents match
3707		*/
3708		if (!access("/etc/yaboot.conf", R_OK))
3709		return 2;
3710
3711		return 1;
3712		}
3713
3714		int checkForElilo(struct grubConfig * config) {
3715		if (!access("/etc/elilo.conf", R_OK))
3716		return 2;
3717
3718		return 1;
3719		}
3720
3721	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3722	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3723
#	Line 3307  int addNewKernel(struct grubConfig * con	Line 3780  int addNewKernel(struct grubConfig * con
3780	const char * newKernelPath, const char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3781	const char * newKernelArgs, const char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3782	const char ** extraInitrds, int extraInitrdCount,	const char ** extraInitrds, int extraInitrdCount,
3783	const char * newMBKernel, const char * newMBKernelArgs) {	const char * newMBKernel, const char * newMBKernelArgs,
3784		const char * newDevTreePath) {
3785	struct singleEntry * new;	struct singleEntry * new;
3786	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3787	int needs;	int needs;
#	Line 3348  int addNewKernel(struct grubConfig * con	Line 3822  int addNewKernel(struct grubConfig * con
3822	needs |= NEED_MB;	needs |= NEED_MB;
3823	new->multiboot = 1;	new->multiboot = 1;
3824	}	}
3825		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3826		needs |= NEED_DEVTREE;
3827
3828	if (template) {	if (template) {
3829	for (masterLine = template->lines;	for (masterLine = template->lines;
#	Line 3361  int addNewKernel(struct grubConfig * con	Line 3837  int addNewKernel(struct grubConfig * con
3837	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3838	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3839
3840	if (tmplLine->type == LT_KERNEL &&	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3841	if (!template->multiboot && (needs & NEED_MB)) {	if (!template->multiboot && (needs & NEED_MB)) {
3842	/* it's not a multiboot template and this is the kernel	/* it's not a multiboot template and this is the kernel
3843	* line.  Try to be intelligent about inserting the	* line.  Try to be intelligent about inserting the
#	Line 3439  int addNewKernel(struct grubConfig * con	Line 3914  int addNewKernel(struct grubConfig * con
3914	/* template is multi but new is not,	/* template is multi but new is not,
3915	* insert the kernel in the first module slot	* insert the kernel in the first module slot
3916	*/	*/
3917	tmplLine->type = LT_KERNEL;	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3918	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3919	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3920	strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3921		config->cfi)->key);
3922	newLine = addLineTmpl(new, tmplLine, newLine,	newLine = addLineTmpl(new, tmplLine, newLine,
3923	newKernelPath + strlen(prefix), config->cfi);	newKernelPath + strlen(prefix),
3924		config->cfi);
3925	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
3926	} else if (needs & NEED_INITRD) {	} else if (needs & NEED_INITRD) {
3927	char *initrdVal;	char *initrdVal;
3928	/* template is multi but new is not,	/* template is multi but new is not,
3929	* insert the initrd in the second module slot	* insert the initrd in the second module slot
3930	*/	*/
3931	tmplLine->type = LT_INITRD;	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3932	free(tmplLine->elements[0].item);	free(tmplLine->elements[0].item);
3933	tmplLine->elements[0].item =	tmplLine->elements[0].item =
3934	strdup(getKeywordByType(LT_INITRD, config->cfi)->key);	strdup(getKeywordByType(tmplLine->type,
3935		config->cfi)->key);
3936	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3937	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3938	free(initrdVal);	free(initrdVal);
3939	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
3940	}	}
3941
3942	} else if (tmplLine->type == LT_INITRD &&	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	tmplLine->numElements >= 2) {
3943	if (needs & NEED_INITRD &&	if (needs & NEED_INITRD &&
3944	new->multiboot && !template->multiboot &&	new->multiboot && !template->multiboot &&
3945	config->cfi->mbInitRdIsModule) {	config->cfi->mbInitRdIsModule) {
#	Line 3516  int addNewKernel(struct grubConfig * con	Line 3993  int addNewKernel(struct grubConfig * con
3993	static const char *prefix = "'Loading ";	static const char *prefix = "'Loading ";
3994	if (tmplLine->numElements > 1 &&	if (tmplLine->numElements > 1 &&
3995	strstr(tmplLine->elements[1].item, prefix) &&	strstr(tmplLine->elements[1].item, prefix) &&
3996	masterLine->next && masterLine->next->type == LT_KERNEL) {	masterLine->next &&
3997		iskernel(masterLine->next->type)) {
3998	char *newTitle = malloc(strlen(prefix) +	char *newTitle = malloc(strlen(prefix) +
3999	strlen(newKernelTitle) + 2);	strlen(newKernelTitle) + 2);
4000
#	Line 3531  int addNewKernel(struct grubConfig * con	Line 4009  int addNewKernel(struct grubConfig * con
4009	newLine = addLineTmpl(new, tmplLine, newLine, NULL,	newLine = addLineTmpl(new, tmplLine, newLine, NULL,
4010	config->cfi);	config->cfi);
4011	}	}
4012		} else if (tmplLine->type == LT_DEVTREE &&
4013		tmplLine->numElements == 2 && newDevTreePath) {
4014		newLine = addLineTmpl(new, tmplLine, newLine,
4015		newDevTreePath + strlen(prefix),
4016		config->cfi);
4017		needs &= ~NEED_DEVTREE;
4018		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
4019		const char *ndtp = newDevTreePath;
4020		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
4021		ndtp += strlen(prefix);
4022		newLine = addLine(new, config->cfi, LT_DEVTREE,
4023		config->secondaryIndent,
4024		ndtp);
4025		needs &= ~NEED_DEVTREE;
4026		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
4027	} else {	} else {
4028	/* pass through other lines from the template */	/* pass through other lines from the template */
4029	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
#	Line 3543  int addNewKernel(struct grubConfig * con	Line 4036  int addNewKernel(struct grubConfig * con
4036	*/	*/
4037	switch (config->cfi->entryStart) {	switch (config->cfi->entryStart) {
4038	case LT_KERNEL:	case LT_KERNEL:
4039		case LT_KERNEL_EFI:
4040		case LT_KERNEL_16:
4041	if (new->multiboot && config->cfi->mbHyperFirst) {	if (new->multiboot && config->cfi->mbHyperFirst) {
4042	/* fall through to LT_HYPER */	/* fall through to LT_HYPER */
4043	} else {	} else {
4044	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi,
4045		preferredLineType(LT_KERNEL, config->cfi),
4046	config->primaryIndent,	config->primaryIndent,
4047	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4048	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3603  int addNewKernel(struct grubConfig * con	Line 4099  int addNewKernel(struct grubConfig * con
4099	}	}
4100	}	}
4101
4102		struct singleLine *endLine = NULL;
4103		endLine = getLineByType(LT_ENTRY_END, new->lines);
4104		if (endLine) {
4105		removeLine(new, endLine);
4106		needs |= NEED_END;
4107		}
4108
4109	/* add the remainder of the lines, i.e. those that either	/* add the remainder of the lines, i.e. those that either
4110	* weren't present in the template, or in the case of no template,	* weren't present in the template, or in the case of no template,
4111	* all the lines following the entryStart.	* all the lines following the entryStart.
#	Line 3622  int addNewKernel(struct grubConfig * con	Line 4125  int addNewKernel(struct grubConfig * con
4125	if (needs & NEED_KERNEL) {	if (needs & NEED_KERNEL) {
4126	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4127	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4128	config->cfi)) ?	config->cfi))
4129	LT_MBMODULE : LT_KERNEL,	? LT_MBMODULE
4130		: preferredLineType(LT_KERNEL, config->cfi),
4131	config->secondaryIndent,	config->secondaryIndent,
4132	newKernelPath + strlen(prefix));	newKernelPath + strlen(prefix));
4133	needs &= ~NEED_KERNEL;	needs &= ~NEED_KERNEL;
#	Line 3639  int addNewKernel(struct grubConfig * con	Line 4143  int addNewKernel(struct grubConfig * con
4143	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4144	newLine = addLine(new, config->cfi,	newLine = addLine(new, config->cfi,
4145	(new->multiboot && getKeywordByType(LT_MBMODULE,	(new->multiboot && getKeywordByType(LT_MBMODULE,
4146	config->cfi)) ?	config->cfi))
4147	LT_MBMODULE : LT_INITRD,	? LT_MBMODULE
4148		: preferredLineType(LT_INITRD, config->cfi),
4149	config->secondaryIndent,	config->secondaryIndent,
4150	initrdVal);	initrdVal);
4151	free(initrdVal);	free(initrdVal);
4152	needs &= ~NEED_INITRD;	needs &= ~NEED_INITRD;
4153	}	}
4154		if (needs & NEED_DEVTREE) {
4155		newLine = addLine(new, config->cfi, LT_DEVTREE,
4156		config->secondaryIndent,
4157		newDevTreePath);
4158		needs &= ~NEED_DEVTREE;
4159		}
4160
4161		/* NEEDS_END must be last on bootloaders that need it... */
4162	if (needs & NEED_END) {	if (needs & NEED_END) {
4163	newLine = addLine(new, config->cfi, LT_ENTRY_END,	newLine = addLine(new, config->cfi, LT_ENTRY_END,
4164	config->secondaryIndent, NULL);	config->secondaryIndent, NULL);
#	Line 3672  static void traceback(int signum)	Line 4185  static void traceback(int signum)
4185	memset(array, '\0', sizeof (array));	memset(array, '\0', sizeof (array));
4186	size = backtrace(array, 40);	size = backtrace(array, 40);
4187
4188	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",	fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4189	(unsigned long)size);	(unsigned long)size);
4190	backtrace_symbols_fd(array, size, STDERR_FILENO);	backtrace_symbols_fd(array, size, STDERR_FILENO);
4191	exit(1);	exit(1);
#	Line 3697  int main(int argc, const char ** argv) {	Line 4210  int main(int argc, const char ** argv) {
4210	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4211	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4212	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4213	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4214	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4215	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4216	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 3707  int main(int argc, const char ** argv) {	Line 4220  int main(int argc, const char ** argv) {
4220	char * removeArgs = NULL;	char * removeArgs = NULL;
4221	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4222	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4223		char * envPath = NULL;
4224	const char * chptr = NULL;	const char * chptr = NULL;
4225	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4226	struct grubConfig * config;	struct grubConfig * config;
#	Line 3715  int main(int argc, const char ** argv) {	Line 4229  int main(int argc, const char ** argv) {
4229	int displayDefault = 0;	int displayDefault = 0;
4230	int displayDefaultIndex = 0;	int displayDefaultIndex = 0;
4231	int displayDefaultTitle = 0;	int displayDefaultTitle = 0;
4232		int defaultIndex = -1;
4233	struct poptOption options[] = {	struct poptOption options[] = {
4234	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4235	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 3732  int main(int argc, const char ** argv) {	Line 4247  int main(int argc, const char ** argv) {
4247	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4248	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4249	_("bootfs") },	_("bootfs") },
4250	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4251	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4252	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4253	#endif	#endif
4254	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4255	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
#	Line 3753  int main(int argc, const char ** argv) {	Line 4268  int main(int argc, const char ** argv) {
4268	_("display the index of the default kernel") },	_("display the index of the default kernel") },
4269	{ "default-title", 0, 0, &displayDefaultTitle, 0,	{ "default-title", 0, 0, &displayDefaultTitle, 0,
4270	_("display the title of the default kernel") },	_("display the title of the default kernel") },
4271		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4272		_("device tree file for new stanza"), _("dtb-path") },
4273	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4274	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4275		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4276		_("force grub2 stanzas to use efi") },
4277		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4278		_("path for environment data"),
4279		_("path") },
4280	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4281	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4282	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
#	Line 3767  int main(int argc, const char ** argv) {	Line 4289  int main(int argc, const char ** argv) {
4289	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4290	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4291	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4292	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4293	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4294	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4295	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 3787  int main(int argc, const char ** argv) {	Line 4309  int main(int argc, const char ** argv) {
4309	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4310	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4311	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4312		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4313		_("make the given entry index the default entry"),
4314		_("entry-index") },
4315	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4316	_("configure silo bootloader") },	_("configure silo bootloader") },
4317	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 3808  int main(int argc, const char ** argv) {	Line 4333  int main(int argc, const char ** argv) {
4333
4334	signal(SIGSEGV, traceback);	signal(SIGSEGV, traceback);
4335
4336		int i = 0;
4337		for (int j = 1; j < argc; j++)
4338		i += strlen(argv[j]) + 1;
4339		saved_command_line = malloc(i);
4340		if (!saved_command_line) {
4341		fprintf(stderr, "grubby: %m\n");
4342		exit(1);
4343		}
4344		saved_command_line[0] = '\0';
4345		for (int j = 1; j < argc; j++) {
4346		strcat(saved_command_line, argv[j]);
4347		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4348		}
4349
4350	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4351	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4352
#	Line 3851  int main(int argc, const char ** argv) {	Line 4390  int main(int argc, const char ** argv) {
4390	return 1;	return 1;
4391	} else if (configureGrub2) {	} else if (configureGrub2) {
4392	cfi = &grub2ConfigType;	cfi = &grub2ConfigType;
4393		if (envPath)
4394		cfi->envFile = envPath;
4395	} else if (configureLilo) {	} else if (configureLilo) {
4396	cfi = &liloConfigType;	cfi = &liloConfigType;
4397	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 3894  int main(int argc, const char ** argv) {	Line 4435  int main(int argc, const char ** argv) {
4435	grubConfig = cfi->defaultConfig;	grubConfig = cfi->defaultConfig;
4436	}	}
4437
4438	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4439	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4440	defaultKernel || displayDefaultIndex || displayDefaultTitle)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4441		(defaultIndex >= 0))) {
4442	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4443	"specified option"));	"specified option"));
4444	return 1;	return 1;
4445	}	}
4446
4447	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4448	removeKernelPath)) {	removeKernelPath)) {
4449	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4450	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 3912  int main(int argc, const char ** argv) {	Line 4454  int main(int argc, const char ** argv) {
4454	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4455	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4456	return 1;	return 1;
4457	} else if (!newKernelPath && (newKernelTitle  || copyDefault ||	} else if (!newKernelPath && (copyDefault ||
4458	(newKernelInitrd && !updateKernelPath)||	(newKernelInitrd && !updateKernelPath)||
4459	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4460	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
#	Line 3938  int main(int argc, const char ** argv) {	Line 4480  int main(int argc, const char ** argv) {
4480	makeDefault = 1;	makeDefault = 1;
4481	defaultKernel = NULL;	defaultKernel = NULL;
4482	}	}
4483		else if (defaultKernel && (defaultIndex >= 0)) {
4484		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4485		"may not be used together\n"));
4486		return 1;
4487		}
4488
4489	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4490	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
#	Line 3946  int main(int argc, const char ** argv) {	Line 4493  int main(int argc, const char ** argv) {
4493	}	}
4494
4495	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4496	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4497	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4498		&& (defaultIndex == -1)) {
4499	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4500	return 1;	return 1;
4501	}	}
#	Line 3974  int main(int argc, const char ** argv) {	Line 4522  int main(int argc, const char ** argv) {
4522	}	}
4523
4524	if (bootloaderProbe) {	if (bootloaderProbe) {
4525	int lrc = 0, grc = 0, gr2c = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4526	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4527
4528	const char *grub2config = grub2FindConfig(&grub2ConfigType);	const char *grub2config = grub2FindConfig(&grub2ConfigType);
4529	if (grub2config) {	if (grub2config) {
#	Line 4003  int main(int argc, const char ** argv) {	Line 4551  int main(int argc, const char ** argv) {
4551	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4552	}	}
4553
4554		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4555		econfig = readConfig(eliloConfigType.defaultConfig,
4556		&eliloConfigType);
4557		if (!econfig)
4558		erc = 1;
4559		else
4560		erc = checkForElilo(econfig);
4561		}
4562
4563	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4564	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4565	if (!lconfig)	if (!lconfig)
4566	erc = 1;	extrc = 1;
4567	else	else
4568	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4569	}	}
4570
4571	if (lrc == 1 || grc == 1 || gr2c == 1) return 1;
4572		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4573		yconfig = readConfig(yabootConfigType.defaultConfig,
4574		&yabootConfigType);
4575		if (!yconfig)
4576		yrc = 1;
4577		else
4578		yrc = checkForYaboot(yconfig);
4579		}
4580
4581		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4582		erc == 1)
4583		return 1;
4584
4585	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4586	if (gr2c == 2) printf("grub2\n");	if (gr2c == 2) printf("grub2\n");
4587	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4588	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4589		if (yrc == 2) printf("yaboot\n");
4590		if (erc == 2) printf("elilo\n");
4591
4592	return 0;	return 0;
4593	}	}
4594
4595		if (grubConfig == NULL) {
4596		printf("Could not find bootloader configuration file.\n");
4597		exit(1);
4598		}
4599
4600	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4601	if (!config) return 1;	if (!config) return 1;
4602
#	Line 4030  int main(int argc, const char ** argv) {	Line 4606  int main(int argc, const char ** argv) {
4606	char * rootspec;	char * rootspec;
4607
4608	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4609		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4610		cfi->defaultIsSaved)
4611		config->defaultImage = 0;
4612	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4613	if (!entry) return 0;	if (!entry) return 0;
4614	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4615
4616	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4617	if (!line) return 0;	if (!line) return 0;
4618
4619	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 4048  int main(int argc, const char ** argv) {	Line 4627  int main(int argc, const char ** argv) {
4627	struct singleEntry * entry;	struct singleEntry * entry;
4628
4629	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4630		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4631		cfi->defaultIsSaved)
4632		config->defaultImage = 0;
4633	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4634	if (!entry) return 0;	if (!entry) return 0;
4635
#	Line 4070  int main(int argc, const char ** argv) {	Line 4652  int main(int argc, const char ** argv) {
4652
4653	} else if (displayDefaultIndex) {	} else if (displayDefaultIndex) {
4654	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4655		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4656		cfi->defaultIsSaved)
4657		config->defaultImage = 0;
4658	printf("%i\n", config->defaultImage);	printf("%i\n", config->defaultImage);
4659		return 0;
4660
4661	} else if (kernelInfo)	} else if (kernelInfo)
4662	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
#	Line 4083  int main(int argc, const char ** argv) {	Line 4669  int main(int argc, const char ** argv) {
4669	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4670	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4671	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4672	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4673	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4674	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4675	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4676	if (updateKernelPath && newKernelInitrd) {	if (updateKernelPath && newKernelInitrd) {
4677	if (updateInitrd(config, updateKernelPath, bootPrefix,	if (newMBKernel) {
4678	newKernelInitrd)) return 1;	if (addMBInitrd(config, newMBKernel, updateKernelPath,
4679		bootPrefix, newKernelInitrd,
4680		newKernelTitle))
4681		return 1;
4682		} else {
4683		if (updateInitrd(config, updateKernelPath, bootPrefix,
4684		newKernelInitrd, newKernelTitle))
4685		return 1;
4686		}
4687	}	}
4688	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4689	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4690	(const char **)extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4691	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4692
4693
4694	if (numEntries(config) == 0) {	if (numEntries(config) == 0) {

---

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

Legend: Removed from v.1850   changed lines   Added in v.2971