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

Parent Directory | Revision Log | Patch

	revision 1846 by niro, Mon Jul 2 13:00:11 2012 UTC	revision 2977 by niro, Thu Jun 30 10:24:27 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		{ "fdtdir",     LT_DEVTREE,     ' ' },
587	{ NULL,    0, 0 },	{ NULL,    0, 0 },
588	};	};
589	int useextlinuxmenu;	int useextlinuxmenu;
#	Line 482  struct configFileInfo ziplConfigType = {	Line 634  struct configFileInfo ziplConfigType = {
634	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
635	.defaultConfig = "/boot/extlinux/extlinux.conf",	.defaultConfig = "/boot/extlinux/extlinux.conf",
636	.keywords = extlinuxKeywords,	.keywords = extlinuxKeywords,
637		.caseInsensitive = 1,
638	.entryStart = LT_TITLE,	.entryStart = LT_TITLE,
639	.needsBootPrefix = 1,	.needsBootPrefix = 1,
640	.maxTitleLength = 255,	.maxTitleLength = 255,
641	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
642		.defaultIsUnquoted = 1,
643	};	};
644
645	struct grubConfig {	struct grubConfig {
#	Line 506  struct singleEntry * findEntryByIndex(st	Line 660  struct singleEntry * findEntryByIndex(st
660	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
661	const char * path, const char * prefix,	const char * path, const char * prefix,
662	int * index);	int * index);
663		struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
664		int * index);
665	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
666	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
667	struct singleLine * lineDup(struct singleLine * line);	struct singleLine * lineDup(struct singleLine * line);
#	Line 570  static char * sdupprintf(const char *for	Line 726  static char * sdupprintf(const char *for
726	return buf;	return buf;
727	}	}
728
729		static enum lineType_e preferredLineType(enum lineType_e type,
730		struct configFileInfo *cfi) {
731		if (isEfi && cfi == &grub2ConfigType) {
732		switch (type) {
733		case LT_KERNEL:
734		return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
735		case LT_INITRD:
736		return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
737		default:
738		return type;
739		}
740		#if defined(__i386__) || defined(__x86_64__)
741		} else if (cfi == &grub2ConfigType) {
742		switch (type) {
743		case LT_KERNEL:
744		return LT_KERNEL_16;
745		case LT_INITRD:
746		return LT_INITRD_16;
747		default:
748		return type;
749		}
750		#endif
751		}
752		return type;
753		}
754
755	static struct keywordTypes * getKeywordByType(enum lineType_e type,	static struct keywordTypes * getKeywordByType(enum lineType_e type,
756	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
757	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 785  static char * getuuidbydev(char *device)
785	static enum lineType_e getTypeByKeyword(char * keyword,	static enum lineType_e getTypeByKeyword(char * keyword,
786	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
787	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
788	if (!strcmp(keyword, kw->key))	if (cfi->caseInsensitive) {
789	return kw->type;	if (!strcasecmp(keyword, kw->key))
790		return kw->type;
791		} else {
792		if (!strcmp(keyword, kw->key))
793		return kw->type;
794		}
795	}	}
796	return LT_UNKNOWN;	return LT_UNKNOWN;
797	}	}
#	Line 642  static int isEntryStart(struct singleLin	Line 829  static int isEntryStart(struct singleLin
829
830	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
831	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct singleLine * line) {
832	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it */
833	char * title;	char * title = NULL;
834	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
835	title++;	title = strdup(line->elements[0].item + 1);
836	*(title + strlen(title) - 1) = '\0';	*(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;
2294	}	}
2295
2296	printf("kernel=%s%s\n", prefix, line->elements[1].item);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2297		printf("kernel=%s\n", line->elements[1].item);
2298		else
2299		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2300
2301	if (line->numElements >= 3) {	if (line->numElements >= 3) {
2302	printf("args=\"");	printf("args=\"");
#	Line 2010  void displayEntry(struct singleEntry * e	Line 2352  void displayEntry(struct singleEntry * e
2352	printf("root=%s\n", s);	printf("root=%s\n", s);
2353	}	}
2354
2355	line = getLineByType(LT_INITRD, entry->lines);	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
2356
2357	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
2358	printf("initrd=%s", prefix);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2359		printf("initrd=");
2360		else
2361		printf("initrd=%s", prefix);
2362
2363	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
2364	printf("%s%s", line->elements[i].item, line->elements[i].indent);	printf("%s%s", line->elements[i].item, line->elements[i].indent);
2365	printf("\n");	printf("\n");
#	Line 2025  void displayEntry(struct singleEntry * e	Line 2371  void displayEntry(struct singleEntry * e
2371	} else {	} else {
2372	char * title;	char * title;
2373	line = getLineByType(LT_MENUENTRY, entry->lines);	line = getLineByType(LT_MENUENTRY, entry->lines);
2374	title = grub2ExtractTitle(line);	if (line) {
2375	if (title)	title = grub2ExtractTitle(line);
2376	printf("title=%s\n", title);	if (title)
2377		printf("title=%s\n", title);
2378		}
2379		}
2380
2381		for (j = 0, line = entry->lines; line; line = line->next) {
2382		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2383		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2384		printf("mbmodule%d=", j);
2385		else
2386		printf("mbmodule%d=%s", j, prefix);
2387
2388		for (i = 1; i < line->numElements; i++)
2389		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2390		printf("\n");
2391		j++;
2392		}
2393		}
2394		}
2395
2396		int isSuseSystem(void) {
2397		const char * path;
2398		const static char default_path[] = "/etc/SuSE-release";
2399
2400		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2401		path = default_path;
2402
2403		if (!access(path, R_OK))
2404		return 1;
2405		return 0;
2406		}
2407
2408		int isSuseGrubConf(const char * path) {
2409		FILE * grubConf;
2410		char * line = NULL;
2411		size_t len = 0, res = 0;
2412
2413		grubConf = fopen(path, "r");
2414		if (!grubConf) {
2415		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2416		return 0;
2417		}
2418
2419		while ((res = getline(&line, &len, grubConf)) != -1) {
2420		if (!strncmp(line, "setup", 5)) {
2421		fclose(grubConf);
2422		free(line);
2423		return 1;
2424		}
2425		}
2426
2427		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2428		path);
2429
2430		fclose(grubConf);
2431		free(line);
2432		return 0;
2433		}
2434
2435		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2436		FILE * grubConf;
2437		char * line = NULL;
2438		size_t res = 0, len = 0;
2439
2440		if (!path) return 1;
2441		if (!lbaPtr) return 1;
2442
2443		grubConf = fopen(path, "r");
2444		if (!grubConf) return 1;
2445
2446		while ((res = getline(&line, &len, grubConf)) != -1) {
2447		if (line[res - 1] == '\n')
2448		line[res - 1] = '\0';
2449		else if (len > res)
2450		line[res] = '\0';
2451		else {
2452		line = realloc(line, res + 1);
2453		line[res] = '\0';
2454		}
2455
2456		if (!strncmp(line, "setup", 5)) {
2457		if (strstr(line, "--force-lba")) {
2458		*lbaPtr = 1;
2459		} else {
2460		*lbaPtr = 0;
2461		}
2462		dbgPrintf("lba: %i\n", *lbaPtr);
2463		break;
2464		}
2465		}
2466
2467		free(line);
2468		fclose(grubConf);
2469		return 0;
2470		}
2471
2472		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2473		FILE * grubConf;
2474		char * line = NULL;
2475		size_t res = 0, len = 0;
2476		char * lastParamPtr = NULL;
2477		char * secLastParamPtr = NULL;
2478		char installDeviceNumber = '\0';
2479		char * bounds = NULL;
2480
2481		if (!path) return 1;
2482		if (!devicePtr) return 1;
2483
2484		grubConf = fopen(path, "r");
2485		if (!grubConf) return 1;
2486
2487		while ((res = getline(&line, &len, grubConf)) != -1) {
2488		if (strncmp(line, "setup", 5))
2489		continue;
2490
2491		if (line[res - 1] == '\n')
2492		line[res - 1] = '\0';
2493		else if (len > res)
2494		line[res] = '\0';
2495		else {
2496		line = realloc(line, res + 1);
2497		line[res] = '\0';
2498		}
2499
2500		lastParamPtr = bounds = line + res;
2501
2502		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2503		while (!isspace(*lastParamPtr))
2504		lastParamPtr--;
2505		lastParamPtr++;
2506
2507		secLastParamPtr = lastParamPtr - 2;
2508		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2509
2510		if (lastParamPtr + 3 > bounds) {
2511		dbgPrintf("lastParamPtr going over boundary");
2512		fclose(grubConf);
2513		free(line);
2514		return 1;
2515		}
2516		if (!strncmp(lastParamPtr, "(hd", 3))
2517		lastParamPtr += 3;
2518		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2519
2520		/*
2521		* Second last parameter will decide wether last parameter is
2522		* an IMAGE_DEVICE or INSTALL_DEVICE
2523		*/
2524		while (!isspace(*secLastParamPtr))
2525		secLastParamPtr--;
2526		secLastParamPtr++;
2527
2528		if (secLastParamPtr + 3 > bounds) {
2529		dbgPrintf("secLastParamPtr going over boundary");
2530		fclose(grubConf);
2531		free(line);
2532		return 1;
2533		}
2534		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2535		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2536		secLastParamPtr += 3;
2537		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2538		installDeviceNumber = *secLastParamPtr;
2539		} else {
2540		installDeviceNumber = *lastParamPtr;
2541		}
2542
2543		*devicePtr = malloc(6);
2544		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2545		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2546		fclose(grubConf);
2547		free(line);
2548		return 0;
2549		}
2550
2551		free(line);
2552		fclose(grubConf);
2553		return 1;
2554		}
2555
2556		int grubGetBootFromDeviceMap(const char * device,
2557		char ** bootPtr) {
2558		FILE * deviceMap;
2559		char * line = NULL;
2560		size_t res = 0, len = 0;
2561		char * devicePtr;
2562		char * bounds = NULL;
2563		const char * path;
2564		const static char default_path[] = "/boot/grub/device.map";
2565
2566		if (!device) return 1;
2567		if (!bootPtr) return 1;
2568
2569		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2570		path = default_path;
2571
2572		dbgPrintf("opening grub device.map file from: %s\n", path);
2573		deviceMap = fopen(path, "r");
2574		if (!deviceMap)
2575		return 1;
2576
2577		while ((res = getline(&line, &len, deviceMap)) != -1) {
2578		if (!strncmp(line, "#", 1))
2579		continue;
2580
2581		if (line[res - 1] == '\n')
2582		line[res - 1] = '\0';
2583		else if (len > res)
2584		line[res] = '\0';
2585		else {
2586		line = realloc(line, res + 1);
2587		line[res] = '\0';
2588		}
2589
2590		devicePtr = line;
2591		bounds = line + res;
2592
2593		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2594		devicePtr++;
2595		dbgPrintf("device: %s\n", devicePtr);
2596
2597		if (!strncmp(devicePtr, device, strlen(device))) {
2598		devicePtr += strlen(device);
2599		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2600		devicePtr++;
2601
2602		*bootPtr = strdup(devicePtr);
2603		break;
2604		}
2605	}	}
2606
2607		free(line);
2608		fclose(deviceMap);
2609		return 0;
2610		}
2611
2612		int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2613		char * grubDevice;
2614
2615		if (suseGrubConfGetInstallDevice(path, &grubDevice))
2616		dbgPrintf("error looking for grub installation device\n");
2617		else
2618		dbgPrintf("grubby installation device: %s\n", grubDevice);
2619
2620		if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2621		dbgPrintf("error looking for grub boot device\n");
2622		else
2623		dbgPrintf("grubby boot device: %s\n", *bootPtr);
2624
2625		free(grubDevice);
2626		return 0;
2627		}
2628
2629		int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2630		/*
2631		* This SuSE grub configuration file at this location is not your average
2632		* grub configuration file, but instead the grub commands used to setup
2633		* grub on that system.
2634		*/
2635		const char * path;
2636		const static char default_path[] = "/etc/grub.conf";
2637
2638		if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2639		path = default_path;
2640
2641		if (!isSuseGrubConf(path)) return 1;
2642
2643		if (lbaPtr) {
2644		*lbaPtr = 0;
2645		if (suseGrubConfGetLba(path, lbaPtr))
2646		return 1;
2647		}
2648
2649		if (bootPtr) {
2650		*bootPtr = NULL;
2651		suseGrubConfGetBoot(path, bootPtr);
2652		}
2653
2654		return 0;
2655	}	}
2656
2657	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
#	Line 2079  int parseSysconfigGrub(int * lbaPtr, cha	Line 2702  int parseSysconfigGrub(int * lbaPtr, cha
2702	}	}
2703
2704	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2705	char * boot;	char * boot = NULL;
2706	int lba;	int lba;
2707
2708	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2709	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2710	if (boot) printf("boot=%s\n", boot);	free(boot);
2711		return;
2712		}
2713		} else {
2714		if (parseSysconfigGrub(&lba, &boot)) {
2715		free(boot);
2716		return;
2717		}
2718		}
2719
2720		if (lba) printf("lba\n");
2721		if (boot) {
2722		printf("boot=%s\n", boot);
2723		free(boot);
2724	}	}
2725	}	}
2726
#	Line 2133  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 2142  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 2179  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 2513  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 2669  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 2678  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 2692  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 2898  int checkForGrub(struct grubConfig * con	Line 3627  int checkForGrub(struct grubConfig * con
3627	int fd;	int fd;
3628	unsigned char bootSect[512];	unsigned char bootSect[512];
3629	char * boot;	char * boot;
3630		int onSuse = isSuseSystem();
3631
3632	if (parseSysconfigGrub(NULL, &boot))
3633	return 0;	if (onSuse) {
3634		if (parseSuseGrubConf(NULL, &boot))
3635		return 0;
3636		} else {
3637		if (parseSysconfigGrub(NULL, &boot))
3638		return 0;
3639		}
3640
3641	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3642	if (!boot)	if (!boot)
#	Line 2919  int checkForGrub(struct grubConfig * con	Line 3655  int checkForGrub(struct grubConfig * con
3655	}	}
3656	close(fd);	close(fd);
3657
3658		/* The more elaborate checks do not work on SuSE. The checks done
3659		* seem to be reasonble (at least for now), so just return success
3660		*/
3661		if (onSuse)
3662		return 2;
3663
3664	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3665	}	}
3666
#	Line 2952  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 3014  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 3055  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 3068  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 3146  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 3223  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 3238  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 3250  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 3310  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 3329  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 3346  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 3379  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 3404  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 3414  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 3422  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 3439  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 3460  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		{ "devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4274		_("device tree directory for new stanza"), _("dtb-path") },
4275	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4276	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4277		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4278		_("force grub2 stanzas to use efi") },
4279		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4280		_("path for environment data"),
4281		_("path") },
4282	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4283	_("configure extlinux bootloader (from syslinux)") },	_("configure extlinux bootloader (from syslinux)") },
4284	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
#	Line 3474  int main(int argc, const char ** argv) {	Line 4291  int main(int argc, const char ** argv) {
4291	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4292	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4293	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4294	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4295	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4296	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4297	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 3494  int main(int argc, const char ** argv) {	Line 4311  int main(int argc, const char ** argv) {
4311	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4312	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4313	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4314		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4315		_("make the given entry index the default entry"),
4316		_("entry-index") },
4317	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4318	_("configure silo bootloader") },	_("configure silo bootloader") },
4319	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 3515  int main(int argc, const char ** argv) {	Line 4335  int main(int argc, const char ** argv) {
4335
4336	signal(SIGSEGV, traceback);	signal(SIGSEGV, traceback);
4337
4338		int i = 0;
4339		for (int j = 1; j < argc; j++)
4340		i += strlen(argv[j]) + 1;
4341		saved_command_line = malloc(i);
4342		if (!saved_command_line) {
4343		fprintf(stderr, "grubby: %m\n");
4344		exit(1);
4345		}
4346		saved_command_line[0] = '\0';
4347		for (int j = 1; j < argc; j++) {
4348		strcat(saved_command_line, argv[j]);
4349		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4350		}
4351
4352	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4353	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4354
#	Line 3558  int main(int argc, const char ** argv) {	Line 4392  int main(int argc, const char ** argv) {
4392	return 1;	return 1;
4393	} else if (configureGrub2) {	} else if (configureGrub2) {
4394	cfi = &grub2ConfigType;	cfi = &grub2ConfigType;
4395		if (envPath)
4396		cfi->envFile = envPath;
4397	} else if (configureLilo) {	} else if (configureLilo) {
4398	cfi = &liloConfigType;	cfi = &liloConfigType;
4399	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 3601  int main(int argc, const char ** argv) {	Line 4437  int main(int argc, const char ** argv) {
4437	grubConfig = cfi->defaultConfig;	grubConfig = cfi->defaultConfig;
4438	}	}
4439
4440	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4441	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4442	defaultKernel || displayDefaultIndex || displayDefaultTitle)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4443		(defaultIndex >= 0))) {
4444	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4445	"specified option"));	"specified option"));
4446	return 1;	return 1;
4447	}	}
4448
4449	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4450	removeKernelPath)) {	removeKernelPath)) {
4451	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4452	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 3619  int main(int argc, const char ** argv) {	Line 4456  int main(int argc, const char ** argv) {
4456	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4457	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4458	return 1;	return 1;
4459	} else if (!newKernelPath && (newKernelTitle  || copyDefault ||	} else if (!newKernelPath && (copyDefault ||
4460	(newKernelInitrd && !updateKernelPath)||	(newKernelInitrd && !updateKernelPath)||
4461	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4462	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
#	Line 3645  int main(int argc, const char ** argv) {	Line 4482  int main(int argc, const char ** argv) {
4482	makeDefault = 1;	makeDefault = 1;
4483	defaultKernel = NULL;	defaultKernel = NULL;
4484	}	}
4485		else if (defaultKernel && (defaultIndex >= 0)) {
4486		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4487		"may not be used together\n"));
4488		return 1;
4489		}
4490
4491	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4492	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
#	Line 3653  int main(int argc, const char ** argv) {	Line 4495  int main(int argc, const char ** argv) {
4495	}	}
4496
4497	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4498	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4499	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4500		&& (defaultIndex == -1)) {
4501	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4502	return 1;	return 1;
4503	}	}
#	Line 3681  int main(int argc, const char ** argv) {	Line 4524  int main(int argc, const char ** argv) {
4524	}	}
4525
4526	if (bootloaderProbe) {	if (bootloaderProbe) {
4527	int lrc = 0, grc = 0, gr2c = 0, erc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4528	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4529
4530	const char *grub2config = grub2FindConfig(&grub2ConfigType);	const char *grub2config = grub2FindConfig(&grub2ConfigType);
4531	if (grub2config) {	if (grub2config) {
#	Line 3710  int main(int argc, const char ** argv) {	Line 4553  int main(int argc, const char ** argv) {
4553	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4554	}	}
4555
4556		if (!access(eliloConfigType.defaultConfig, F_OK)) {
4557		econfig = readConfig(eliloConfigType.defaultConfig,
4558		&eliloConfigType);
4559		if (!econfig)
4560		erc = 1;
4561		else
4562		erc = checkForElilo(econfig);
4563		}
4564
4565	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4566	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4567	if (!lconfig)	if (!lconfig)
4568	erc = 1;	extrc = 1;
4569	else	else
4570	erc = checkForExtLinux(lconfig);	extrc = checkForExtLinux(lconfig);
4571	}	}
4572
4573	if (lrc == 1 || grc == 1 || gr2c == 1) return 1;
4574		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4575		yconfig = readConfig(yabootConfigType.defaultConfig,
4576		&yabootConfigType);
4577		if (!yconfig)
4578		yrc = 1;
4579		else
4580		yrc = checkForYaboot(yconfig);
4581		}
4582
4583		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4584		erc == 1)
4585		return 1;
4586
4587	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4588	if (gr2c == 2) printf("grub2\n");	if (gr2c == 2) printf("grub2\n");
4589	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4590	if (erc == 2) printf("extlinux\n");	if (extrc == 2) printf("extlinux\n");
4591		if (yrc == 2) printf("yaboot\n");
4592		if (erc == 2) printf("elilo\n");
4593
4594	return 0;	return 0;
4595	}	}
4596
4597		if (grubConfig == NULL) {
4598		printf("Could not find bootloader configuration file.\n");
4599		exit(1);
4600		}
4601
4602	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4603	if (!config) return 1;	if (!config) return 1;
4604
#	Line 3737  int main(int argc, const char ** argv) {	Line 4608  int main(int argc, const char ** argv) {
4608	char * rootspec;	char * rootspec;
4609
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	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4615	if (!entry) return 0;	if (!entry) return 0;
4616	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4617
4618	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
4619	if (!line) return 0;	if (!line) return 0;
4620
4621	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 3755  int main(int argc, const char ** argv) {	Line 4629  int main(int argc, const char ** argv) {
4629	struct singleEntry * entry;	struct singleEntry * entry;
4630
4631	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4632		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4633		cfi->defaultIsSaved)
4634		config->defaultImage = 0;
4635	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4636	if (!entry) return 0;	if (!entry) return 0;
4637
#	Line 3777  int main(int argc, const char ** argv) {	Line 4654  int main(int argc, const char ** argv) {
4654
4655	} else if (displayDefaultIndex) {	} else if (displayDefaultIndex) {
4656	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4657		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4658		cfi->defaultIsSaved)
4659		config->defaultImage = 0;
4660	printf("%i\n", config->defaultImage);	printf("%i\n", config->defaultImage);
4661		return 0;
4662
4663	} else if (kernelInfo)	} else if (kernelInfo)
4664	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
#	Line 3790  int main(int argc, const char ** argv) {	Line 4671  int main(int argc, const char ** argv) {
4671	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4672	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4673	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4674	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4675	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4676	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4677	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4678	if (updateKernelPath && newKernelInitrd) {	if (updateKernelPath && newKernelInitrd) {
4679	if (updateInitrd(config, updateKernelPath, bootPrefix,	if (newMBKernel) {
4680	newKernelInitrd)) return 1;	if (addMBInitrd(config, newMBKernel, updateKernelPath,
4681		bootPrefix, newKernelInitrd,
4682		newKernelTitle))
4683		return 1;
4684		} else {
4685		if (updateInitrd(config, updateKernelPath, bootPrefix,
4686		newKernelInitrd, newKernelTitle))
4687		return 1;
4688		}
4689	}	}
4690	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4691	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4692	(const char **)extraInitrds, extraInitrdCount,	(const char **)extraInitrds, extraInitrdCount,
4693	newMBKernel, newMBKernelArgs)) return 1;	newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4694
4695
4696	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.1846   changed lines   Added in v.2977