Diff of /trunk/grubby/grubby.c

Parent Directory | Revision Log | Patch

	revision 2052 by niro, Wed Feb 20 14:00:54 2013 UTC	revision 3002 by niro, Tue Jun 27 14:11:58 2017 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 46	Line 48
48	#define dbgPrintf(format, args...)	#define dbgPrintf(format, args...)
49	#endif	#endif
50
51	int debug = 0; /* Currently just for template debugging */	int debug = 0; /* Currently just for template debugging */
52
53	#define _(A) (A)	#define _(A) (A)
54
#	Line 58  int debug = 0; /* Currently just for tem	Line 60  int debug = 0; /* Currently just for tem
60
61	int isEfi = 0;	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;
74	char * indent;	char *indent;
75	};	};
76
77	enum lineType_e {	enum lineType_e {
78	LT_WHITESPACE   = 1 << 0,	LT_WHITESPACE = 1 << 0,
79	LT_TITLE        = 1 << 1,	LT_TITLE = 1 << 1,
80	LT_KERNEL       = 1 << 2,	LT_KERNEL = 1 << 2,
81	LT_INITRD       = 1 << 3,	LT_INITRD = 1 << 3,
82	LT_HYPER        = 1 << 4,	LT_HYPER = 1 << 4,
83	LT_DEFAULT      = 1 << 5,	LT_DEFAULT = 1 << 5,
84	LT_MBMODULE     = 1 << 6,	LT_MBMODULE = 1 << 6,
85	LT_ROOT         = 1 << 7,	LT_ROOT = 1 << 7,
86	LT_FALLBACK     = 1 << 8,	LT_FALLBACK = 1 << 8,
87	LT_KERNELARGS   = 1 << 9,	LT_KERNELARGS = 1 << 9,
88	LT_BOOT         = 1 << 10,	LT_BOOT = 1 << 10,
89	LT_BOOTROOT     = 1 << 11,	LT_BOOTROOT = 1 << 11,
90	LT_LBA          = 1 << 12,	LT_LBA = 1 << 12,
91	LT_OTHER        = 1 << 13,	LT_OTHER = 1 << 13,
92	LT_GENERIC      = 1 << 14,	LT_GENERIC = 1 << 14,
93	LT_ECHO    = 1 << 16,	LT_ECHO = 1 << 16,
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_KERNEL_EFI   = 1 << 20,	LT_KERNEL_EFI = 1 << 20,
98	LT_INITRD_EFI   = 1 << 21,	LT_INITRD_EFI = 1 << 21,
99	LT_UNKNOWN      = 1 << 22,	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 {
106	char * indent;	char *indent;
107	int numElements;	int numElements;
108	struct lineElement * elements;	struct lineElement *elements;
109	struct singleLine * next;	struct singleLine *next;
110	enum lineType_e type;	enum lineType_e type;
111	};	};
112
113	struct singleEntry {	struct singleEntry {
114	struct singleLine * lines;	struct singleLine *lines;
115	int skip;	int skip;
116	int multiboot;	int multiboot;
117	struct singleEntry * next;	struct singleEntry *next;
118	};	};
119
120	#define GRUBBY_BADIMAGE_OKAY (1 << 0)	#define GRUBBY_BADIMAGE_OKAY (1 << 0)
#	Line 115  struct singleEntry {	Line 128  struct singleEntry {
128	#define NEED_ARGS    (1 << 3)	#define NEED_ARGS    (1 << 3)
129	#define NEED_MB      (1 << 4)	#define NEED_MB      (1 << 4)
130	#define NEED_END     (1 << 5)	#define NEED_END     (1 << 5)
131		#define NEED_DEVTREE (1 << 6)
132
133	#define MAIN_DEFAULT    (1 << 0)	#define MAIN_DEFAULT    (1 << 0)
134	#define DEFAULT_SAVED       -2	#define DEFAULT_SAVED       -2
135	#define DEFAULT_SAVED_GRUB2 -3	#define DEFAULT_SAVED_GRUB2 -3
136
137	struct keywordTypes {	struct keywordTypes {
138	char * key;	char *key;
139	enum lineType_e type;	enum lineType_e type;
140	char nextChar;	char nextChar;
141	char separatorChar;	char separatorChar;
142	};	};
143
144	struct configFileInfo;	struct configFileInfo;
145
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	struct keywordTypes * keywords;	getEnvFunc getEnv;
157	int defaultIsIndex;	setEnvFunc setEnv;
158	int defaultIsVariable;	struct keywordTypes *keywords;
159	int defaultSupportSaved;	int caseInsensitive;
160	enum lineType_e entryStart;	int defaultIsIndex;
161	enum lineType_e entryEnd;	int defaultIsVariable;
162	int needsBootPrefix;	int defaultSupportSaved;
163	int argsInQuotes;	int defaultIsSaved;
164	int maxTitleLength;	int defaultIsUnquoted;
165	int titleBracketed;	enum lineType_e entryStart;
166	int titlePosition;	enum lineType_e entryEnd;
167	int mbHyperFirst;	int needsBootPrefix;
168	int mbInitRdIsModule;	int argsInQuotes;
169	int mbConcatArgs;	int maxTitleLength;
170	int mbAllowExtraInitRds;	int titleBracketed;
171		int titlePosition;
172		int mbHyperFirst;
173		int mbInitRdIsModule;
174		int mbConcatArgs;
175		int mbAllowExtraInitRds;
176		char *envFile;
177	};	};
178
179	struct keywordTypes grubKeywords[] = {	struct keywordTypes grubKeywords[] = {
180	{ "title",    LT_TITLE,    ' ' },	{"title", LT_TITLE, ' '},
181	{ "root",    LT_BOOTROOT,    ' ' },	{"root", LT_BOOTROOT, ' '},
182	{ "default",    LT_DEFAULT,    ' ' },	{"default", LT_DEFAULT, ' '},
183	{ "fallback",   LT_FALLBACK,    ' ' },	{"fallback", LT_FALLBACK, ' '},
184	{ "kernel",    LT_KERNEL,    ' ' },	{"kernel", LT_KERNEL, ' '},
185	{ "initrd",    LT_INITRD,    ' ', ' ' },	{"initrd", LT_INITRD, ' ', ' '},
186	{ "module",     LT_MBMODULE,    ' ' },	{"module", LT_MBMODULE, ' '},
187	{ "kernel",     LT_HYPER,       ' ' },	{"kernel", LT_HYPER, ' '},
188	{ NULL,    0, 0 },	{NULL, 0, 0},
189	};	};
190
191	const char *grubFindConfig(struct configFileInfo *cfi) {	const char *grubFindConfig(struct configFileInfo *cfi)
192	static const char *configFiles[] = {	{
193	"/boot/grub/grub.conf",	static const char *configFiles[] = {
194	"/boot/grub/menu.lst",	"/boot/grub/grub.conf",
195	"/etc/grub.conf",	"/boot/grub/menu.lst",
196	NULL	"/etc/grub.conf",
197	};	NULL
198	static int i = -1;	};
199		static int i = -1;
200	if (i == -1) {
201	for (i = 0; configFiles[i] != NULL; i++) {	if (i == -1) {
202	dbgPrintf("Checking \"%s\": ", configFiles[i]);	for (i = 0; configFiles[i] != NULL; i++) {
203	if (!access(configFiles[i], R_OK)) {	dbgPrintf("Checking \"%s\": ", configFiles[i]);
204	dbgPrintf("found\n");	if (!access(configFiles[i], R_OK)) {
205	return configFiles[i];	dbgPrintf("found\n");
206	}	return configFiles[i];
207	dbgPrintf("not found\n");	}
208		dbgPrintf("not found\n");
209		}
210	}	}
211	}	return configFiles[i];
	return configFiles[i];
212	}	}
213
214	struct configFileInfo grubConfigType = {	struct configFileInfo grubConfigType = {
215	.findConfig = grubFindConfig,	.findConfig = grubFindConfig,
216	.keywords = grubKeywords,	.keywords = grubKeywords,
217	.defaultIsIndex = 1,	.defaultIsIndex = 1,
218	.defaultSupportSaved = 1,	.defaultSupportSaved = 1,
219	.entryStart = LT_TITLE,	.entryStart = LT_TITLE,
220	.needsBootPrefix = 1,	.needsBootPrefix = 1,
221	.mbHyperFirst = 1,	.mbHyperFirst = 1,
222	.mbInitRdIsModule = 1,	.mbInitRdIsModule = 1,
223	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
224		.titlePosition = 1,
225	};	};
226
227	struct keywordTypes grub2Keywords[] = {	struct keywordTypes grub2Keywords[] = {
228	{ "menuentry",  LT_MENUENTRY,   ' ' },	{"menuentry", LT_MENUENTRY, ' '},
229	{ "}",          LT_ENTRY_END,   ' ' },	{"}", LT_ENTRY_END, ' '},
230	{ "echo",       LT_ECHO,        ' ' },	{"echo", LT_ECHO, ' '},
231	{ "set",        LT_SET_VARIABLE,' ', '=' },	{"set", LT_SET_VARIABLE, ' ', '='},
232	{ "root",       LT_BOOTROOT,    ' ' },	{"root", LT_BOOTROOT, ' '},
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,  ' ' },	{"linuxefi", LT_KERNEL_EFI, ' '},
237	{ "initrd",     LT_INITRD,      ' ', ' ' },	{"linux16", LT_KERNEL_16, ' '},
238	{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },	{"initrd", LT_INITRD, ' ', ' '},
239	{ "module",     LT_MBMODULE,    ' ' },	{"initrdefi", LT_INITRD_EFI, ' ', ' '},
240	{ "kernel",     LT_HYPER,       ' ' },	{"initrd16", LT_INITRD_16, ' ', ' '},
241	{ NULL, 0, 0 },	{"module", LT_MBMODULE, ' '},
242		{"kernel", LT_HYPER, ' '},
243		{"devicetree", LT_DEVTREE, ' '},
244		{NULL, 0, 0},
245	};	};
246
247	const char *grub2FindConfig(struct configFileInfo *cfi) {	const char *grub2FindConfig(struct configFileInfo *cfi)
248	static const char *configFiles[] = {	{
249	"/boot/grub/grub-efi.cfg",	static const char *configFiles[] = {
250	"/boot/grub/grub.cfg",	"/boot/grub/grub-efi.cfg",
251	NULL	"/boot/grub/grub.cfg",
252	};	"/etc/grub2-efi.cfg",
253	static int i = -1;	"/etc/grub2.cfg",
254	static const char *grub_cfg = "/boot/grub/grub.cfg";	"/boot/grub2/grub.cfg",
255		"/boot/grub2-efi/grub.cfg",
256	if (i == -1) {	NULL
257	for (i = 0; configFiles[i] != NULL; i++) {	};
258	dbgPrintf("Checking \"%s\": ", configFiles[i]);	static int i = -1;
259	if (!access(configFiles[i], R_OK)) {	static const char *grub_cfg = "/boot/grub/grub.cfg";
260		int rc = -1;
261
262		if (i == -1) {
263		for (i = 0; configFiles[i] != NULL; i++) {
264		dbgPrintf("Checking \"%s\": ", configFiles[i]);
265		if ((rc = access(configFiles[i], R_OK))) {
266		if (errno == EACCES) {
267		printf
268		("Unable to access bootloader configuration file "
269		"\"%s\": %m\n", configFiles[i]);
270		exit(1);
271		}
272		continue;
273		} else {
274		dbgPrintf("found\n");
275		return configFiles[i];
276		}
277		}
278		}
279
280		/* Ubuntu renames grub2 to grub, so check for the grub.d directory
281		* that isn't in grub1, and if it exists, return the config file path
282		* that they use. */
283		if (configFiles[i] == NULL && !access("/etc/grub.d/", R_OK)) {
284	dbgPrintf("found\n");	dbgPrintf("found\n");
285	return configFiles[i];	return grub_cfg;
286	}	}
287
288		dbgPrintf("not found\n");
289		return configFiles[i];
290		}
291
292		/* kind of hacky.  It'll give the first 1024 bytes, ish. */
293		static char *grub2GetEnv(struct configFileInfo *info, char *name)
294		{
295		static char buf[1025];
296		char *s = NULL;
297		char *ret = NULL;
298		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
299		int rc =
300		asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
301
302		if (rc < 0)
303		return NULL;
304
305		FILE *f = popen(s, "r");
306		if (!f)
307		goto out;
308
309		memset(buf, '\0', sizeof(buf));
310		ret = fgets(buf, 1024, f);
311		pclose(f);
312
313		if (ret) {
314		ret += strlen(name) + 1;
315		ret[strlen(ret) - 1] = '\0';
316		}
317		dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
318		out:
319		free(s);
320		return ret;
321		}
322
323		static int sPopCount(const char *s, const char *c)
324		{
325		int ret = 0;
326		if (!s)
327		return -1;
328		for (int i = 0; s[i] != '\0'; i++)
329		for (int j = 0; c[j] != '\0'; j++)
330		if (s[i] == c[j])
331		ret++;
332		return ret;
333		}
334
335		static char *shellEscape(const char *s)
336		{
337		int l = strlen(s) + sPopCount(s, "'") * 2;
338
339		char *ret = calloc(l + 1, sizeof(*ret));
340		if (!ret)
341		return NULL;
342		for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
343		if (s[i] == '\'')
344		ret[j++] = '\\';
345		ret[j] = s[i];
346		}
347		return ret;
348		}
349
350		static void unquote(char *s)
351		{
352		int l = strlen(s);
353
354		if ((s[l - 1] == '\'' && s[0] == '\'')
355		|| (s[l - 1] == '"' && s[0] == '"')) {
356		memmove(s, s + 1, l - 2);
357		s[l - 2] = '\0';
358	}	}
359	}	}
360
361	/* Ubuntu renames grub2 to grub, so check for the grub.d directory	static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
362	* that isn't in grub1, and if it exists, return the config file path	{
363	* that they use. */	char *s = NULL;
364	if (configFiles[i] == NULL && !access("/etc/grub.d/", R_OK)) {	int rc = 0;
365	dbgPrintf("found\n");	char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
366	return grub_cfg;
367	}	unquote(value);
368		value = shellEscape(value);
369		if (!value)
370		return -1;
371
372		rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
373		free(value);
374		if (rc < 0)
375		return -1;
376
377		dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
378		rc = system(s);
379		free(s);
380		return rc;
381		}
382
383	dbgPrintf("not found\n");	/* this is a gigantic hack to avoid clobbering grub2 variables... */
384	return configFiles[i];	static int is_special_grub2_variable(const char *name)
385		{
386		if (!strcmp(name, "\"${next_entry}\""))
387		return 1;
388		if (!strcmp(name, "\"${prev_saved_entry}\""))
389		return 1;
390		return 0;
391	}	}
392
393	int sizeOfSingleLine(struct singleLine * line) {	int sizeOfSingleLine(struct singleLine *line)
394	int count = 0;	{
395		int count = 0;
396
397	for (int i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
398	int indentSize = 0;	int indentSize = 0;
399
400	count = count + strlen(line->elements[i].item);	count = count + strlen(line->elements[i].item);
401
402	indentSize = strlen(line->elements[i].indent);	indentSize = strlen(line->elements[i].indent);
403	if (indentSize > 0)	if (indentSize > 0)
404	count = count + indentSize;	count = count + indentSize;
405	else	else
406	/* be extra safe and add room for whitespaces */	/* be extra safe and add room for whitespaces */
407	count = count + 1;	count = count + 1;
408	}	}
409
410	/* room for trailing terminator */	/* room for trailing terminator */
411	count = count + 1;	count = count + 1;
412
413	return count;	return count;
414	}	}
415
416	static int isquote(char q)	static int isquote(char q)
417	{	{
418	if (q == '\'' || q == '\"')	if (q == '\'' || q == '\"')
419	return 1;	return 1;
420	return 0;	return 0;
421		}
422
423		static int iskernel(enum lineType_e type)
424		{
425		return (type == LT_KERNEL || type == LT_KERNEL_EFI
426		|| type == LT_KERNEL_16);
427	}	}
428
429	static int iskernel(enum lineType_e type) {	static int isinitrd(enum lineType_e type)
430	return (type == LT_KERNEL || type == LT_KERNEL_EFI);	{
431		return (type == LT_INITRD || type == LT_INITRD_EFI
432		|| type == LT_INITRD_16);
433	}	}
434
435	static int isinitrd(enum lineType_e type) {	char *grub2ExtractTitle(struct singleLine *line)
436	return (type == LT_INITRD || type == LT_INITRD_EFI);	{
437	}	char *current;
438		char *current_indent;
439	char *grub2ExtractTitle(struct singleLine * line) {	int current_len;
440	char * current;	int current_indent_len;
441	char * current_indent;	int i;
442	int current_len;
443	int current_indent_len;	/* bail out if line does not start with menuentry */
444	int i;	if (strcmp(line->elements[0].item, "menuentry"))
445		return NULL;
446	/* bail out if line does not start with menuentry */
447	if (strcmp(line->elements[0].item, "menuentry"))	i = 1;
	return NULL;
	i = 1;
	current = line->elements[i].item;
	current_len = strlen(current);
	/* if second word is quoted, strip the quotes and return single word */
	if (isquote(*current) && isquote(current[current_len - 1])) {
	char *tmp;
	tmp = strdup(current);
	*(tmp + current_len - 1) = '\0';
	return ++tmp;
	}
	/* if no quotes, return second word verbatim */
	if (!isquote(*current))
	return current;
	/* second element start with a quote, so we have to find the element
	* whose last character is also quote (assuming it's the closing one) */
	int resultMaxSize;
	char * result;
	resultMaxSize = sizeOfSingleLine(line);
	result = malloc(resultMaxSize);
	snprintf(result, resultMaxSize, "%s", ++current);
	i++;
	for (; i < line->numElements; ++i) {
448	current = line->elements[i].item;	current = line->elements[i].item;
449	current_len = strlen(current);	current_len = strlen(current);
	current_indent = line->elements[i].indent;
	current_indent_len = strlen(current_indent);
450
451	strncat(result, current_indent, current_indent_len);	/* if second word is quoted, strip the quotes and return single word */
452	if (!isquote(current[current_len-1])) {	if (isquote(*current) && isquote(current[current_len - 1])) {
453	strncat(result, current, current_len);	char *tmp;
454	} else {
455	strncat(result, current, current_len - 1);	tmp = strdup(current + 1);
456	break;	if (!tmp)
457		return NULL;
458		tmp[strlen(tmp) - 1] = '\0';
459		return tmp;
460		}
461
462		/* if no quotes, return second word verbatim */
463		if (!isquote(*current))
464		return current;
465
466		/* second element start with a quote, so we have to find the element
467		* whose last character is also quote (assuming it's the closing one) */
468		int resultMaxSize;
469		char *result;
470		/* need to ensure that ' does not match " as we search */
471		char quote_char = *current;
472
473		resultMaxSize = sizeOfSingleLine(line);
474		result = malloc(resultMaxSize);
475		snprintf(result, resultMaxSize, "%s", ++current);
476
477		i++;
478		for (; i < line->numElements; ++i) {
479		current = line->elements[i].item;
480		current_len = strlen(current);
481		current_indent = line->elements[i].indent;
482		current_indent_len = strlen(current_indent);
483
484		strncat(result, current_indent, current_indent_len);
485		if (current[current_len - 1] != quote_char) {
486		strncat(result, current, current_len);
487		} else {
488		strncat(result, current, current_len - 1);
489		break;
490		}
491	}	}
492	}	return result;
	return result;
493	}	}
494
495	struct configFileInfo grub2ConfigType = {	struct configFileInfo grub2ConfigType = {
496	.findConfig = grub2FindConfig,	.findConfig = grub2FindConfig,
497	.keywords = grub2Keywords,	.getEnv = grub2GetEnv,
498	.defaultIsIndex = 1,	.setEnv = grub2SetEnv,
499	.defaultSupportSaved = 1,	.keywords = grub2Keywords,
500	.defaultIsVariable = 1,	.defaultIsIndex = 1,
501	.entryStart = LT_MENUENTRY,	.defaultSupportSaved = 1,
502	.entryEnd = LT_ENTRY_END,	.defaultIsVariable = 1,
503	.titlePosition = 1,	.entryStart = LT_MENUENTRY,
504	.needsBootPrefix = 1,	.entryEnd = LT_ENTRY_END,
505	.mbHyperFirst = 1,	.titlePosition = 1,
506	.mbInitRdIsModule = 1,	.needsBootPrefix = 1,
507	.mbAllowExtraInitRds = 1,	.mbHyperFirst = 1,
508		.mbInitRdIsModule = 1,
509		.mbAllowExtraInitRds = 1,
510	};	};
511
512	struct keywordTypes yabootKeywords[] = {	struct keywordTypes yabootKeywords[] = {
513	{ "label",    LT_TITLE,    '=' },	{"label", LT_TITLE, '='},
514	{ "root",    LT_ROOT,    '=' },	{"root", LT_ROOT, '='},
515	{ "default",    LT_DEFAULT,    '=' },	{"default", LT_DEFAULT, '='},
516	{ "image",    LT_KERNEL,    '=' },	{"image", LT_KERNEL, '='},
517	{ "bsd",    LT_GENERIC,    '=' },	{"bsd", LT_GENERIC, '='},
518	{ "macos",    LT_GENERIC,    '=' },	{"macos", LT_GENERIC, '='},
519	{ "macosx",    LT_GENERIC,    '=' },	{"macosx", LT_GENERIC, '='},
520	{ "magicboot",  LT_GENERIC,    '=' },	{"magicboot", LT_GENERIC, '='},
521	{ "darwin",    LT_GENERIC,    '=' },	{"darwin", LT_GENERIC, '='},
522	{ "timeout",    LT_GENERIC,    '=' },	{"timeout", LT_GENERIC, '='},
523	{ "install",    LT_GENERIC,    '=' },	{"install", LT_GENERIC, '='},
524	{ "fstype",    LT_GENERIC,    '=' },	{"fstype", LT_GENERIC, '='},
525	{ "hfstype",    LT_GENERIC,    '=' },	{"hfstype", LT_GENERIC, '='},
526	{ "delay",    LT_GENERIC,    '=' },	{"delay", LT_GENERIC, '='},
527	{ "defaultos",  LT_GENERIC,     '=' },	{"defaultos", LT_GENERIC, '='},
528	{ "init-message", LT_GENERIC,   '=' },	{"init-message", LT_GENERIC, '='},
529	{ "enablecdboot", LT_GENERIC,   ' ' },	{"enablecdboot", LT_GENERIC, ' '},
530	{ "enableofboot", LT_GENERIC,   ' ' },	{"enableofboot", LT_GENERIC, ' '},
531	{ "enablenetboot", LT_GENERIC,  ' ' },	{"enablenetboot", LT_GENERIC, ' '},
532	{ "nonvram",    LT_GENERIC,    ' ' },	{"nonvram", LT_GENERIC, ' '},
533	{ "hide",    LT_GENERIC,    ' ' },	{"hide", LT_GENERIC, ' '},
534	{ "protect",    LT_GENERIC,    ' ' },	{"protect", LT_GENERIC, ' '},
535	{ "nobless",    LT_GENERIC,    ' ' },	{"nobless", LT_GENERIC, ' '},
536	{ "nonvram",    LT_GENERIC,    ' ' },	{"nonvram", LT_GENERIC, ' '},
537	{ "brokenosx",  LT_GENERIC,    ' ' },	{"brokenosx", LT_GENERIC, ' '},
538	{ "usemount",   LT_GENERIC,    ' ' },	{"usemount", LT_GENERIC, ' '},
539	{ "mntpoint",   LT_GENERIC,    '=' },	{"mntpoint", LT_GENERIC, '='},
540	{ "partition",  LT_GENERIC,    '=' },	{"partition", LT_GENERIC, '='},
541	{ "device",    LT_GENERIC,    '=' },	{"device", LT_GENERIC, '='},
542	{ "fstype",    LT_GENERIC,    '=' },	{"fstype", LT_GENERIC, '='},
543	{ "initrd",    LT_INITRD,    '=', ';' },	{"initrd", LT_INITRD, '=', ';'},
544	{ "append",    LT_KERNELARGS,  '=' },	{"append", LT_KERNELARGS, '='},
545	{ "boot",    LT_BOOT,    '=' },	{"boot", LT_BOOT, '='},
546	{ "lba",    LT_LBA,    ' ' },	{"lba", LT_LBA, ' '},
547	{ NULL,    0, 0 },	{NULL, 0, 0},
548	};	};
549
550	struct keywordTypes liloKeywords[] = {	struct keywordTypes liloKeywords[] = {
551	{ "label",    LT_TITLE,    '=' },	{"label", LT_TITLE, '='},
552	{ "root",    LT_ROOT,    '=' },	{"root", LT_ROOT, '='},
553	{ "default",    LT_DEFAULT,    '=' },	{"default", LT_DEFAULT, '='},
554	{ "image",    LT_KERNEL,    '=' },	{"image", LT_KERNEL, '='},
555	{ "other",    LT_OTHER,    '=' },	{"other", LT_OTHER, '='},
556	{ "initrd",    LT_INITRD,    '=' },	{"initrd", LT_INITRD, '='},
557	{ "append",    LT_KERNELARGS,  '=' },	{"append", LT_KERNELARGS, '='},
558	{ "boot",    LT_BOOT,    '=' },	{"boot", LT_BOOT, '='},
559	{ "lba",    LT_LBA,    ' ' },	{"lba", LT_LBA, ' '},
560	{ NULL,    0, 0 },	{NULL, 0, 0},
561	};	};
562
563	struct keywordTypes eliloKeywords[] = {	struct keywordTypes eliloKeywords[] = {
564	{ "label",    LT_TITLE,    '=' },	{"label", LT_TITLE, '='},
565	{ "root",    LT_ROOT,    '=' },	{"root", LT_ROOT, '='},
566	{ "default",    LT_DEFAULT,    '=' },	{"default", LT_DEFAULT, '='},
567	{ "image",    LT_KERNEL,    '=' },	{"image", LT_KERNEL, '='},
568	{ "initrd",    LT_INITRD,    '=' },	{"initrd", LT_INITRD, '='},
569	{ "append",    LT_KERNELARGS,  '=' },	{"append", LT_KERNELARGS, '='},
570	{ "vmm",    LT_HYPER,       '=' },	{"vmm", LT_HYPER, '='},
571	{ NULL,    0, 0 },	{NULL, 0, 0},
572	};	};
573
574	struct keywordTypes siloKeywords[] = {	struct keywordTypes siloKeywords[] = {
575	{ "label",    LT_TITLE,    '=' },	{"label", LT_TITLE, '='},
576	{ "root",    LT_ROOT,    '=' },	{"root", LT_ROOT, '='},
577	{ "default",    LT_DEFAULT,    '=' },	{"default", LT_DEFAULT, '='},
578	{ "image",    LT_KERNEL,    '=' },	{"image", LT_KERNEL, '='},
579	{ "other",    LT_OTHER,    '=' },	{"other", LT_OTHER, '='},
580	{ "initrd",    LT_INITRD,    '=' },	{"initrd", LT_INITRD, '='},
581	{ "append",    LT_KERNELARGS,  '=' },	{"append", LT_KERNELARGS, '='},
582	{ "boot",    LT_BOOT,    '=' },	{"boot", LT_BOOT, '='},
583	{ NULL,    0, 0 },	{NULL, 0, 0},
584	};	};
585
586	struct keywordTypes ziplKeywords[] = {	struct keywordTypes ziplKeywords[] = {
587	{ "target",     LT_BOOTROOT,    '=' },	{"target", LT_BOOTROOT, '='},
588	{ "image",      LT_KERNEL,      '=' },	{"image", LT_KERNEL, '='},
589	{ "ramdisk",    LT_INITRD,      '=' },	{"ramdisk", LT_INITRD, '='},
590	{ "parameters", LT_KERNELARGS,  '=' },	{"parameters", LT_KERNELARGS, '='},
591	{ "default",    LT_DEFAULT,     '=' },	{"default", LT_DEFAULT, '='},
592	{ NULL,         0, 0 },	{NULL, 0, 0},
593	};	};
594
595	struct keywordTypes extlinuxKeywords[] = {	struct keywordTypes extlinuxKeywords[] = {
596	{ "label",    LT_TITLE,    ' ' },	{"label", LT_TITLE, ' '},
597	{ "root",    LT_ROOT,    ' ' },	{"root", LT_ROOT, ' '},
598	{ "default",    LT_DEFAULT,    ' ' },	{"default", LT_DEFAULT, ' '},
599	{ "kernel",    LT_KERNEL,    ' ' },	{"kernel", LT_KERNEL, ' '},
600	{ "initrd",    LT_INITRD,      ' ', ',' },	{"initrd", LT_INITRD, ' ', ','},
601	{ "append",    LT_KERNELARGS,  ' ' },	{"append", LT_KERNELARGS, ' '},
602	{ "prompt",     LT_UNKNOWN,     ' ' },	{"prompt", LT_UNKNOWN, ' '},
603	{ NULL,    0, 0 },	{"fdt", LT_DEVTREE, ' '},
604		{"fdtdir", LT_DEVTREE, ' '},
605		{NULL, 0, 0},
606	};	};
607
608	int useextlinuxmenu;	int useextlinuxmenu;
609	struct configFileInfo eliloConfigType = {	struct configFileInfo eliloConfigType = {
610	.defaultConfig = "/boot/efi/EFI/redhat/elilo.conf",	.defaultConfig = "/boot/efi/EFI/redhat/elilo.conf",
611	.keywords = eliloKeywords,	.keywords = eliloKeywords,
612	.entryStart = LT_KERNEL,	.entryStart = LT_KERNEL,
613	.needsBootPrefix = 1,	.needsBootPrefix = 1,
614	.argsInQuotes = 1,	.argsInQuotes = 1,
615	.mbConcatArgs = 1,	.mbConcatArgs = 1,
616		.titlePosition = 1,
617	};	};
618
619	struct configFileInfo liloConfigType = {	struct configFileInfo liloConfigType = {
620	.defaultConfig = "/etc/lilo.conf",	.defaultConfig = "/etc/lilo.conf",
621	.keywords = liloKeywords,	.keywords = liloKeywords,
622	.entryStart = LT_KERNEL,	.entryStart = LT_KERNEL,
623	.argsInQuotes = 1,	.argsInQuotes = 1,
624	.maxTitleLength = 15,	.maxTitleLength = 15,
625		.titlePosition = 1,
626	};	};
627
628	struct configFileInfo yabootConfigType = {	struct configFileInfo yabootConfigType = {
629	.defaultConfig = "/etc/yaboot.conf",	.defaultConfig = "/etc/yaboot.conf",
630	.keywords = yabootKeywords,	.keywords = yabootKeywords,
631	.entryStart = LT_KERNEL,	.entryStart = LT_KERNEL,
632	.needsBootPrefix = 1,	.needsBootPrefix = 1,
633	.argsInQuotes = 1,	.argsInQuotes = 1,
634	.maxTitleLength = 15,	.maxTitleLength = 15,
635	.mbAllowExtraInitRds = 1,	.mbAllowExtraInitRds = 1,
636		.titlePosition = 1,
637	};	};
638
639	struct configFileInfo siloConfigType = {	struct configFileInfo siloConfigType = {
640	.defaultConfig = "/etc/silo.conf",	.defaultConfig = "/etc/silo.conf",
641	.keywords = siloKeywords,	.keywords = siloKeywords,
642	.entryStart = LT_KERNEL,	.entryStart = LT_KERNEL,
643	.needsBootPrefix = 1,	.needsBootPrefix = 1,
644	.argsInQuotes = 1,	.argsInQuotes = 1,
645	.maxTitleLength = 15,	.maxTitleLength = 15,
646		.titlePosition = 1,
647	};	};
648
649	struct configFileInfo ziplConfigType = {	struct configFileInfo ziplConfigType = {
650	.defaultConfig = "/etc/zipl.conf",	.defaultConfig = "/etc/zipl.conf",
651	.keywords = ziplKeywords,	.keywords = ziplKeywords,
652	.entryStart = LT_TITLE,	.entryStart = LT_TITLE,
653	.argsInQuotes = 1,	.argsInQuotes = 1,
654	.titleBracketed = 1,	.titleBracketed = 1,
655	};	};
656
657	struct configFileInfo extlinuxConfigType = {	struct configFileInfo extlinuxConfigType = {
658	.defaultConfig = "/boot/extlinux/extlinux.conf",	.defaultConfig = "/boot/extlinux/extlinux.conf",
659	.keywords = extlinuxKeywords,	.keywords = extlinuxKeywords,
660	.entryStart = LT_TITLE,	.caseInsensitive = 1,
661	.needsBootPrefix = 1,	.entryStart = LT_TITLE,
662	.maxTitleLength = 255,	.needsBootPrefix = 1,
663	.mbAllowExtraInitRds = 1,	.maxTitleLength = 255,
664		.mbAllowExtraInitRds = 1,
665		.defaultIsUnquoted = 1,
666		.titlePosition = 1,
667	};	};
668
669	struct grubConfig {	struct grubConfig {
670	struct singleLine * theLines;	struct singleLine *theLines;
671	struct singleEntry * entries;	struct singleEntry *entries;
672	char * primaryIndent;	char *primaryIndent;
673	char * secondaryIndent;	char *secondaryIndent;
674	int defaultImage;    /* -1 if none specified -- this value is	int defaultImage; /* -1 if none specified -- this value is
675	* written out, overriding original */	* written out, overriding original */
676	int fallbackImage;    /* just like defaultImage */	int fallbackImage; /* just like defaultImage */
677	int flags;	int flags;
678	struct configFileInfo * cfi;	struct configFileInfo *cfi;
679	};	};
680
681	blkid_cache blkid;	blkid_cache blkid;
682
683	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index);	struct singleEntry *findEntryByIndex(struct grubConfig *cfg, int index);
684	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry *findEntryByPath(struct grubConfig *cfg,
685	const char * path, const char * prefix,	const char *path, const char *prefix,
686	int * index);	int *index);
687	static int readFile(int fd, char ** bufPtr);	struct singleEntry *findEntryByTitle(struct grubConfig *cfg, char *title,
688	static void lineInit(struct singleLine * line);	int *index);
689	struct singleLine * lineDup(struct singleLine * line);	static int readFile(int fd, char **bufPtr);
690	static void lineFree(struct singleLine * line);	static void lineInit(struct singleLine *line);
691	static int lineWrite(FILE * out, struct singleLine * line,	struct singleLine *lineDup(struct singleLine *line);
692	struct configFileInfo * cfi);	static void lineFree(struct singleLine *line);
693	static int getNextLine(char ** bufPtr, struct singleLine * line,	static int lineWrite(FILE * out, struct singleLine *line,
694	struct configFileInfo * cfi);	struct configFileInfo *cfi);
695	static char * getRootSpecifier(char * str);	static int getNextLine(char **bufPtr, struct singleLine *line,
696	static void requote(struct singleLine *line, struct configFileInfo * cfi);	struct configFileInfo *cfi);
697	static void insertElement(struct singleLine * line,	static char *getRootSpecifier(char *str);
698	const char * item, int insertHere,	static void requote(struct singleLine *line, struct configFileInfo *cfi);
699	struct configFileInfo * cfi);	static void insertElement(struct singleLine *line,
700	static void removeElement(struct singleLine * line, int removeHere);	const char *item, int insertHere,
701	static struct keywordTypes * getKeywordByType(enum lineType_e type,	struct configFileInfo *cfi);
702	struct configFileInfo * cfi);	static void removeElement(struct singleLine *line, int removeHere);
703	static enum lineType_e getTypeByKeyword(char * keyword,	static struct keywordTypes *getKeywordByType(enum lineType_e type,
704	struct configFileInfo * cfi);	struct configFileInfo *cfi);
705	static struct singleLine * getLineByType(enum lineType_e type,	static enum lineType_e getTypeByKeyword(char *keyword,
706	struct singleLine * line);	struct configFileInfo *cfi);
707	static int checkForExtLinux(struct grubConfig * config);	static struct singleLine *getLineByType(enum lineType_e type,
708	struct singleLine * addLineTmpl(struct singleEntry * entry,	struct singleLine *line);
709	struct singleLine * tmplLine,	static int checkForExtLinux(struct grubConfig *config);
710	struct singleLine * prevLine,	struct singleLine *addLineTmpl(struct singleEntry *entry,
711	const char * val,	struct singleLine *tmplLine,
712	struct configFileInfo * cfi);	struct singleLine *prevLine,
713	struct singleLine *  addLine(struct singleEntry * entry,	const char *val, struct configFileInfo *cfi);
714	struct configFileInfo * cfi,	struct singleLine *addLine(struct singleEntry *entry,
715	enum lineType_e type, char * defaultIndent,	struct configFileInfo *cfi,
716	const char * val);	enum lineType_e type, char *defaultIndent,
717		const char *val);
718
719	static char * sdupprintf(const char *format, ...)	static char *sdupprintf(const char *format, ...)
720	#ifdef __GNUC__	#ifdef __GNUC__
721	__attribute__ ((format (printf, 1, 2)));	__attribute__ ((format(printf, 1, 2)));
722	#else	#else
723	;	;
724	#endif	#endif
725
726	static char * sdupprintf(const char *format, ...) {	static char *sdupprintf(const char *format, ...)
727	char *buf = NULL;	{
728	char c;	char *buf = NULL;
729	va_list args;	char c;
730	size_t size = 0;	va_list args;
731	va_start(args, format);	size_t size = 0;
732		va_start(args, format);
733	/* XXX requires C99 vsnprintf behavior */
734	size = vsnprintf(&c, 1, format, args) + 1;	/* XXX requires C99 vsnprintf behavior */
735	if (size == -1) {	size = vsnprintf(&c, 1, format, args) + 1;
736	printf("ERROR: vsnprintf behavior is not C99\n");	if (size == -1) {
737	abort();	printf("ERROR: vsnprintf behavior is not C99\n");
738	}	abort();
739		}
740
741	va_end(args);	va_end(args);
742	va_start(args, format);	va_start(args, format);
743
744	buf = malloc(size);	buf = malloc(size);
745	if (buf == NULL)	if (buf == NULL)
746	return NULL;	return NULL;
747	vsnprintf(buf, size, format, args);	vsnprintf(buf, size, format, args);
748	va_end (args);	va_end(args);
749
750	return buf;	return buf;
751	}	}
752
753	static enum lineType_e preferredLineType(enum lineType_e type,	static enum lineType_e preferredLineType(enum lineType_e type,
754	struct configFileInfo *cfi) {	struct configFileInfo *cfi)
755	if (isEfi && cfi == &grub2ConfigType) {	{
756	switch (type) {	if (isEfi && cfi == &grub2ConfigType) {
757	case LT_KERNEL:	switch (type) {
758	return LT_KERNEL_EFI;	case LT_KERNEL:
759	case LT_INITRD:	return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
760	return LT_INITRD_EFI;	case LT_INITRD:
761	default:	return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
762	return type;	default:
763	}	return type;
764	}	}
765	return type;	#if defined(__i386__) || defined(__x86_64__)
766	}	} else if (cfi == &grub2ConfigType) {
767		switch (type) {
768	static struct keywordTypes * getKeywordByType(enum lineType_e type,	case LT_KERNEL:
769	struct configFileInfo * cfi) {	return LT_KERNEL_16;
770	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {	case LT_INITRD:
771	if (kw->type == type)	return LT_INITRD_16;
772	return kw;	default:
773	}	return type;
774	return NULL;	}
775	}	#endif
776		}
777	static char *getKeyByType(enum lineType_e type, struct configFileInfo * cfi) {	return type;
	struct keywordTypes *kt = getKeywordByType(type, cfi);
	if (kt)
	return kt->key;
	return "unknown";
	}
	static char * getpathbyspec(char *device) {
	if (!blkid)
	blkid_get_cache(&blkid, NULL);
	return blkid_get_devname(blkid, device, NULL);
	}
	static char * getuuidbydev(char *device) {
	if (!blkid)
	blkid_get_cache(&blkid, NULL);
	return blkid_get_tag_value(blkid, "UUID", device);
	}
	static enum lineType_e getTypeByKeyword(char * keyword,
	struct configFileInfo * cfi) {
	for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
	if (!strcmp(keyword, kw->key))
	return kw->type;
	}
	return LT_UNKNOWN;
	}
	static struct singleLine * getLineByType(enum lineType_e type,
	struct singleLine * line) {
	dbgPrintf("getLineByType(%d): ", type);
	for (; line; line = line->next) {
	dbgPrintf("%d:%s ", line->type,
	line->numElements ? line->elements[0].item : "(empty)");
	if (line->type & type) break;
	}
	dbgPrintf(line ? "\n" : " (failed)\n");
	return line;
	}
	static int isBracketedTitle(struct singleLine * line) {
	if (line->numElements == 1 && *line->elements[0].item == '[') {
	int len = strlen(line->elements[0].item);
	if (*(line->elements[0].item + len - 1) == ']') {
	/* FIXME: this is a hack... */
	if (strcmp(line->elements[0].item, "[defaultboot]")) {
	return 1;
	}
	}
	}
	return 0;
	}
	static int isEntryStart(struct singleLine * line,
	struct configFileInfo * cfi) {
	return line->type == cfi->entryStart || line->type == LT_OTHER ||
	(cfi->titleBracketed && isBracketedTitle(line));
778	}	}
779
780	/* extract the title from within brackets (for zipl) */	static struct keywordTypes *getKeywordByType(enum lineType_e type,
781	static char * extractTitle(struct singleLine * line) {	struct configFileInfo *cfi)
782	/* bracketed title... let's extract it (leaks a byte) */	{
783	char * title;	for (struct keywordTypes * kw = cfi->keywords; kw->key; kw++) {
784	title = strdup(line->elements[0].item);	if (kw->type == type)
785	title++;	return kw;
786	*(title + strlen(title) - 1) = '\0';	}
787	return title;	return NULL;
	}
	static int readFile(int fd, char ** bufPtr) {
	int alloced = 0, size = 0, i = 0;
	char * buf = NULL;
	do {
	size += i;
	if ((size + 1024) > alloced) {
	alloced += 4096;
	buf = realloc(buf, alloced + 1);
	}
	} while ((i = read(fd, buf + size, 1024)) > 0);
	if (i < 0) {
	fprintf(stderr, _("error reading input: %s\n"), strerror(errno));
	free(buf);
	return 1;
	}
	buf = realloc(buf, size + 2);
	if (size == 0)
	buf[size++] = '\n';
	else
	if (buf[size - 1] != '\n')
	buf[size++] = '\n';
	buf[size] = '\0';
	*bufPtr = buf;
	return 0;
788	}	}
789
790	static void lineInit(struct singleLine * line) {	static char *getKeyByType(enum lineType_e type, struct configFileInfo *cfi)
791	line->indent = NULL;	{
792	line->elements = NULL;	struct keywordTypes *kt = getKeywordByType(type, cfi);
793	line->numElements = 0;	if (kt)
794	line->next = NULL;	return kt->key;
795		return "unknown";
796	}	}
797
798	struct singleLine * lineDup(struct singleLine * line) {	static char *getpathbyspec(char *device)
799	struct singleLine * newLine = malloc(sizeof(*newLine));	{
800		if (!blkid)
801		blkid_get_cache(&blkid, NULL);
802
803	newLine->indent = strdup(line->indent);	return blkid_get_devname(blkid, device, NULL);
804	newLine->next = NULL;	}
	newLine->type = line->type;
	newLine->numElements = line->numElements;
	newLine->elements = malloc(sizeof(*newLine->elements) *
	newLine->numElements);
805
806	for (int i = 0; i < newLine->numElements; i++) {	static char *getuuidbydev(char *device)
807	newLine->elements[i].indent = strdup(line->elements[i].indent);	{
808	newLine->elements[i].item = strdup(line->elements[i].item);	if (!blkid)
809	}	blkid_get_cache(&blkid, NULL);
810
811	return newLine;	return blkid_get_tag_value(blkid, "UUID", device);
812	}	}
813
814	static void lineFree(struct singleLine * line) {	static enum lineType_e getTypeByKeyword(char *keyword,
815	if (line->indent) free(line->indent);	struct configFileInfo *cfi)
816		{
817		for (struct keywordTypes * kw = cfi->keywords; kw->key; kw++) {
818		if (cfi->caseInsensitive) {
819		if (!strcasecmp(keyword, kw->key))
820		return kw->type;
821		} else {
822		if (!strcmp(keyword, kw->key))
823		return kw->type;
824		}
825		}
826		return LT_UNKNOWN;
827		}
828
829	for (int i = 0; i < line->numElements; i++) {	static struct singleLine *getLineByType(enum lineType_e type,
830	free(line->elements[i].item);	struct singleLine *line)
831	free(line->elements[i].indent);	{
832	}	dbgPrintf("getLineByType(%d): ", type);
833		for (; line; line = line->next) {
834		dbgPrintf("%d:%s ", line->type,
835		line->numElements ? line->elements[0].
836		item : "(empty)");
837		if (line->type & type)
838		break;
839		}
840		dbgPrintf(line ? "\n" : " (failed)\n");
841		return line;
842		}
843
844	if (line->elements) free(line->elements);	static int isBracketedTitle(struct singleLine *line)
845	lineInit(line);	{
846		if (line->numElements == 1 && *line->elements[0].item == '[') {
847		int len = strlen(line->elements[0].item);
848		if (*(line->elements[0].item + len - 1) == ']') {
849		/* FIXME: this is a hack... */
850		if (strcmp(line->elements[0].item, "[defaultboot]")) {
851		return 1;
852		}
853		}
854		}
855		return 0;
856	}	}
857
858	static int lineWrite(FILE * out, struct singleLine * line,	static int isEntryStart(struct singleLine *line, struct configFileInfo *cfi)
859	struct configFileInfo * cfi) {	{
860	if (fprintf(out, "%s", line->indent) == -1) return -1;	return line->type == cfi->entryStart || line->type == LT_OTHER ||
861		(cfi->titleBracketed && isBracketedTitle(line));
862		}
863
864	for (int i = 0; i < line->numElements; i++) {	/* extract the title from within brackets (for zipl) */
865	/* Need to handle this, because we strip the quotes from	static char *extractTitle(struct grubConfig *cfg, struct singleLine *line)
866	* menuentry when read it. */	{
867	if (line->type == LT_MENUENTRY && i == 1) {	/* bracketed title... let's extract it */
868	if(!isquote(*line->elements[i].item))	char *title = NULL;
869	fprintf(out, "\'%s\'", line->elements[i].item);	if (line->type == LT_TITLE) {
870	else	char *tmp = line->elements[cfg->cfi->titlePosition].item;
871	fprintf(out, "%s", line->elements[i].item);	if (cfg->cfi->titleBracketed) {
872	fprintf(out, "%s", line->elements[i].indent);	tmp++;
873		title = strdup(tmp);
874		*(title + strlen(title) - 1) = '\0';
875		} else {
876		title = strdup(tmp);
877		}
878		} else if (line->type == LT_MENUENTRY)
879		title = strdup(line->elements[1].item);
880		else
881		return NULL;
882		return title;
883		}
884
885	continue;	static int readFile(int fd, char **bufPtr)
886	}	{
887		int alloced = 0, size = 0, i = 0;
888		char *buf = NULL;
889
890	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)	do {
891	if (fputc('"', out) == EOF) return -1;	size += i;
892		if ((size + 1024) > alloced) {
893		alloced += 4096;
894		buf = realloc(buf, alloced + 1);
895		}
896		} while ((i = read(fd, buf + size, 1024)) > 0);
897
898	if (fprintf(out, "%s", line->elements[i].item) == -1) return -1;	if (i < 0) {
899	if (i < line->numElements - 1)	fprintf(stderr, _("error reading input: %s\n"),
900	if (fprintf(out, "%s", line->elements[i].indent) == -1) return -1;	strerror(errno));
901	}	free(buf);
902		return 1;
903		}
904
905	if (line->type == LT_KERNELARGS && cfi->argsInQuotes)	buf = realloc(buf, size + 2);
906	if (fputc('"', out) == EOF) return -1;	if (size == 0)
907		buf[size++] = '\n';
908		else if (buf[size - 1] != '\n')
909		buf[size++] = '\n';
910		buf[size] = '\0';
911
912	if (fprintf(out, "\n") == -1) return -1;	*bufPtr = buf;
913
914	return 0;	return 0;
915	}	}
916
917	/* we've guaranteed that the buffer ends w/ \n\0 */	static void lineInit(struct singleLine *line)
918	static int getNextLine(char ** bufPtr, struct singleLine * line,	{
919	struct configFileInfo * cfi) {	line->indent = NULL;
920	char * end;	line->elements = NULL;
921	char * start = *bufPtr;	line->numElements = 0;
922	char * chptr;	line->next = NULL;
923	int elementsAlloced = 0;	}
	struct lineElement * element;
	int first = 1;
924
925	lineFree(line);	struct singleLine *lineDup(struct singleLine *line)
926		{
927		struct singleLine *newLine = malloc(sizeof(*newLine));
928
929	end = strchr(start, '\n');	newLine->indent = strdup(line->indent);
930	*end = '\0';	newLine->next = NULL;
931	*bufPtr = end + 1;	newLine->type = line->type;
932		newLine->numElements = line->numElements;
933		newLine->elements = malloc(sizeof(*newLine->elements) *
934		newLine->numElements);
935
936	for (chptr = start; *chptr && isspace(*chptr); chptr++) ;	for (int i = 0; i < newLine->numElements; i++) {
937		newLine->elements[i].indent = strdup(line->elements[i].indent);
938		newLine->elements[i].item = strdup(line->elements[i].item);
939		}
940
941	line->indent = strndup(start, chptr - start);	return newLine;
942	start = chptr;	}
943
944	while (start < end) {	static void lineFree(struct singleLine *line)
945	/* we know !isspace(*start) */	{
946		if (line->indent)
947		free(line->indent);
948
949	if (elementsAlloced == line->numElements) {	for (int i = 0; i < line->numElements; i++) {
950	elementsAlloced += 5;	free(line->elements[i].item);
951	line->elements = realloc(line->elements,	free(line->elements[i].indent);
	sizeof(*line->elements) * elementsAlloced);
952	}	}
953
954	element = line->elements + line->numElements;	if (line->elements)
955		free(line->elements);
956		lineInit(line);
957		}
958
959	chptr = start;	static int lineWrite(FILE * out, struct singleLine *line,
960	while (*chptr && !isspace(*chptr)) {	struct configFileInfo *cfi)
961	if (first && *chptr == '=') break;	{
962	chptr++;	if (fprintf(out, "%s", line->indent) == -1)
963	}	return -1;
	element->item = strndup(start, chptr - start);
	start = chptr;
964
965	/* lilo actually accepts the pathological case of append = " foo " */	for (int i = 0; i < line->numElements; i++) {
966	if (*start == '=')	/* Need to handle this, because we strip the quotes from
967	chptr = start + 1;	* menuentry when read it. */
968	else	if (line->type == LT_MENUENTRY && i == 1) {
969	chptr = start;	if (!isquote(*line->elements[i].item)) {
970		int substring = 0;
971	do {	/* If the line contains nested quotes, we did
972	for (; *chptr && isspace(*chptr); chptr++);	* not strip the "interna" quotes and we must
973	if (*chptr == '=')	* use the right quotes again when writing
974	chptr = chptr + 1;	* the updated file. */
975	} while (isspace(*chptr));	for (int j = i; j < line->numElements; j++) {
976		if (strchr(line->elements[i].item, '\'')
977		!= NULL) {
978		substring = 1;
979		fprintf(out, "\"%s\"",
980		line->elements[i].item);
981		break;
982		}
983		}
984		if (!substring)
985		fprintf(out, "\'%s\'",
986		line->elements[i].item);
987		} else {
988		fprintf(out, "%s", line->elements[i].item);
989		}
990		fprintf(out, "%s", line->elements[i].indent);
991
992	element->indent = strndup(start, chptr - start);	continue;
993	start = chptr;	}
994
995	line->numElements++;	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
996	first = 0;	if (fputc('"', out) == EOF)
997	}	return -1;
998
999		if (fprintf(out, "%s", line->elements[i].item) == -1)
1000		return -1;
1001		if (i < line->numElements - 1)
1002		if (fprintf(out, "%s", line->elements[i].indent) == -1)
1003		return -1;
1004		}
1005
1006		if (line->type == LT_KERNELARGS && cfi->argsInQuotes)
1007		if (fputc('"', out) == EOF)
1008		return -1;
1009
1010	if (!line->numElements)	if (fprintf(out, "\n") == -1)
1011	line->type = LT_WHITESPACE;	return -1;
	else {
	line->type = getTypeByKeyword(line->elements[0].item, cfi);
	if (line->type == LT_UNKNOWN) {
	/* zipl does [title] instead of something reasonable like all
	* the other boot loaders.  kind of ugly */
	if (cfi->titleBracketed && isBracketedTitle(line)) {
	line->type = LT_TITLE;
	}
	/* this is awkward, but we need to be able to handle keywords
	that begin with a # (specifically for #boot in grub.conf),
	but still make comments lines with no elements (everything
	stored in the indent */
	if (*line->elements[0].item == '#') {
	char * fullLine;
	int len;
	len = strlen(line->indent);
	for (int i = 0; i < line->numElements; i++)
	len += strlen(line->elements[i].item) +
	strlen(line->elements[i].indent);
1012
1013	fullLine = malloc(len + 1);	return 0;
1014	strcpy(fullLine, line->indent);	}
	free(line->indent);
	line->indent = fullLine;
1015
1016	for (int i = 0; i < line->numElements; i++) {	/* we've guaranteed that the buffer ends w/ \n\0 */
1017	strcat(fullLine, line->elements[i].item);	static int getNextLine(char **bufPtr, struct singleLine *line,
1018	strcat(fullLine, line->elements[i].indent);	struct configFileInfo *cfi)
1019	free(line->elements[i].item);	{
1020	free(line->elements[i].indent);	char *end;
1021	}	char *start = *bufPtr;
1022		char *chptr;
1023		int elementsAlloced = 0;
1024		struct lineElement *element;
1025		int first = 1;
1026
1027	line->type = LT_WHITESPACE;	lineFree(line);
	line->numElements = 0;
	}
	} else {
	struct keywordTypes *kw;
1028
1029	kw = getKeywordByType(line->type, cfi);	end = strchr(start, '\n');
1030		*end = '\0';
1031		*bufPtr = end + 1;
1032
1033	/* space isn't the only separator, we need to split	for (chptr = start; *chptr && isspace(*chptr); chptr++) ;
	* elements up more
	*/
	if (!isspace(kw->separatorChar)) {
	char indent[2] = "";
	indent[0] = kw->separatorChar;
	for (int i = 1; i < line->numElements; i++) {
	char *p;
	int numNewElements;
	numNewElements = 0;
	p = line->elements[i].item;
	while (*p != '\0') {
	if (*p == kw->separatorChar)
	numNewElements++;
	p++;
	}
	if (line->numElements + numNewElements >= elementsAlloced) {
	elementsAlloced += numNewElements + 5;
	line->elements = realloc(line->elements,
	sizeof(*line->elements) * elementsAlloced);
	}
	for (int j = line->numElements; j > i; j--) {
	line->elements[j + numNewElements] = line->elements[j];
	}
	line->numElements += numNewElements;
1034
1035	p = line->elements[i].item;	line->indent = strndup(start, chptr - start);
1036	while (*p != '\0') {	start = chptr;
1037
1038	while (*p != kw->separatorChar && *p != '\0') p++;	while (start < end) {
1039	if (*p == '\0') {	/* we know !isspace(*start) */
	break;
	}
1040
1041	line->elements[i + 1].indent = line->elements[i].indent;	if (elementsAlloced == line->numElements) {
1042	line->elements[i].indent = strdup(indent);	elementsAlloced += 5;
1043	*p++ = '\0';	line->elements = realloc(line->elements,
1044	i++;	sizeof(*line->elements) *
1045	line->elements[i].item = strdup(p);	elementsAlloced);
	}
	}
1046	}	}
	}
	}
1047
1048	return 0;	element = line->elements + line->numElements;
	}
	static struct grubConfig * readConfig(const char * inName,
	struct configFileInfo * cfi) {
	int in;
	char * incoming = NULL, * head;
	int rc;
	int sawEntry = 0;
	int movedLine = 0;
	struct grubConfig * cfg;
	struct singleLine * last = NULL, * line, * defaultLine = NULL;
	char * end;
	struct singleEntry * entry = NULL;
	int len;
	char * buf;
	if (!strcmp(inName, "-")) {
	in = 0;
	} else {
	if ((in = open(inName, O_RDONLY)) < 0) {
	fprintf(stderr, _("error opening %s for read: %s\n"),
	inName, strerror(errno));
	return NULL;
	}
	}
	rc = readFile(in, &incoming);
	close(in);
	if (rc) return NULL;
	head = incoming;
	cfg = malloc(sizeof(*cfg));
	cfg->primaryIndent = strdup("");
	cfg->secondaryIndent = strdup("\t");
	cfg->flags = GRUB_CONFIG_NO_DEFAULT;
	cfg->cfi = cfi;
	cfg->theLines = NULL;
	cfg->entries = NULL;
	cfg->fallbackImage = 0;
	/* copy everything we have */
	while (*head) {
	line = malloc(sizeof(*line));
	lineInit(line);
	if (getNextLine(&head, line, cfi)) {
	free(line);
	/* XXX memory leak of everything in cfg */
	return NULL;
	}
	if (!sawEntry && line->numElements) {
	free(cfg->primaryIndent);
	cfg->primaryIndent = strdup(line->indent);
	} else if (line->numElements) {
	free(cfg->secondaryIndent);
	cfg->secondaryIndent = strdup(line->indent);
	}
	if (isEntryStart(line, cfi) || (cfg->entries && !sawEntry)) {
	sawEntry = 1;
	if (!entry) {
	cfg->entries = malloc(sizeof(*entry));
	entry = cfg->entries;
	} else {
	entry->next = malloc(sizeof(*entry));
	entry = entry->next;
	}
	entry->skip = 0;
	entry->multiboot = 0;
	entry->lines = NULL;
	entry->next = NULL;
	}
	if (line->type == LT_SET_VARIABLE) {
	dbgPrintf("found 'set' command (%d elements): ", line->numElements);
	dbgPrintf("%s", line->indent);
	for (int i = 0; i < line->numElements; i++)
	dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
	dbgPrintf("\n");
	struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
	if (kwType && line->numElements == 3 &&
	!strcmp(line->elements[1].item, kwType->key)) {
	dbgPrintf("Line sets default config\n");
	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
	defaultLine = line;
	}
	} else if (line->type == LT_DEFAULT && line->numElements == 2) {
	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
	defaultLine = line;
	} else if (iskernel(line->type)) {
	/* if by some freak chance this is multiboot and the "module"
	* lines came earlier in the template, make sure to use LT_HYPER
	* instead of LT_KERNEL now
	*/
	if (entry->multiboot)
	line->type = LT_HYPER;
	} else if (line->type == LT_MBMODULE) {
	/* go back and fix the LT_KERNEL line to indicate LT_HYPER
	* instead, now that we know this is a multiboot entry.
	* This only applies to grub, but that's the only place we
	* should find LT_MBMODULE lines anyway.
	*/
	for (struct singleLine *l = entry->lines; l; l = l->next) {
	if (l->type == LT_HYPER)
	break;
	else if (iskernel(l->type)) {
	l->type = LT_HYPER;
	break;
	}
	}
	entry->multiboot = 1;
	} else if (line->type == LT_HYPER) {
	entry->multiboot = 1;
	} else if (line->type == LT_FALLBACK && line->numElements == 2) {
	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
	if (*end) cfg->fallbackImage = -1;
	} else if (line->type == LT_TITLE && line->numElements > 1) {
	/* make the title a single argument (undoing our parsing) */
	len = 0;
	for (int i = 1; i < line->numElements; i++) {
	len += strlen(line->elements[i].item);
	len += strlen(line->elements[i].indent);
	}
	buf = malloc(len + 1);
	*buf = '\0';
1049
1050	for (int i = 1; i < line->numElements; i++) {	chptr = start;
1051	strcat(buf, line->elements[i].item);	while (*chptr && !isspace(*chptr)) {
1052	free(line->elements[i].item);	if (first && *chptr == '=')
1053		break;
1054		chptr++;
1055		}
1056		element->item = strndup(start, chptr - start);
1057		start = chptr;
1058
1059	if ((i + 1) != line->numElements) {	/* lilo actually accepts the pathological case of
1060	strcat(buf, line->elements[i].indent);	* append = " foo " */
1061	free(line->elements[i].indent);	if (*start == '=')
1062	}	chptr = start + 1;
	}
	line->elements[1].indent =
	line->elements[line->numElements - 1].indent;
	line->elements[1].item = buf;
	line->numElements = 2;
	} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
	/* let --remove-kernel="TITLE=what" work */
	len = 0;
	char *extras;
	char *title;
	for (int i = 1; i < line->numElements; i++) {
	len += strlen(line->elements[i].item);
	len += strlen(line->elements[i].indent);
	}
	buf = malloc(len + 1);
	*buf = '\0';
	/* allocate mem for extra flags. */
	extras = malloc(len + 1);
	*extras = '\0';
	/* get title. */
	for (int i = 0; i < line->numElements; i++) {
	if (!strcmp(line->elements[i].item, "menuentry"))
	continue;
	if (isquote(*line->elements[i].item))
	title = line->elements[i].item + 1;
1063	else	else
1064	title = line->elements[i].item;	chptr = start;
1065
1066	len = strlen(title);	do {
1067	if (isquote(title[len-1])) {	for (; *chptr && isspace(*chptr); chptr++) ;
1068	strncat(buf, title,len-1);	if (*chptr == '=')
1069	break;	chptr = chptr + 1;
1070	} else {	} while (isspace(*chptr));
	strcat(buf, title);
	strcat(buf, line->elements[i].indent);
	}
	}
1071
1072	/* get extras */	element->indent = strndup(start, chptr - start);
1073	int count = 0;	start = chptr;
1074	for (int i = 0; i < line->numElements; i++) {
1075	if (count >= 2) {	line->numElements++;
1076	strcat(extras, line->elements[i].item);	first = 0;
	strcat(extras, line->elements[i].indent);
	}
	if (!strcmp(line->elements[i].item, "menuentry"))
	continue;
	/* count ' or ", there should be two in menuentry line. */
	if (isquote(*line->elements[i].item))
	count++;
	len = strlen(line->elements[i].item);
	if (isquote(line->elements[i].item[len -1]))
	count++;
	/* ok, we get the final ' or ", others are extras. */
	}
	line->elements[1].indent =
	line->elements[line->numElements - 2].indent;
	line->elements[1].item = buf;
	line->elements[2].indent =
	line->elements[line->numElements - 2].indent;
	line->elements[2].item = extras;
	line->numElements = 3;
	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
	/* Strip off any " which may be present; they'll be put back
	on write. This is one of the few (the only?) places that grubby
	canonicalizes the output */
	if (line->numElements >= 2) {
	int last, len;
	if (isquote(*line->elements[1].item))
	memmove(line->elements[1].item, line->elements[1].item + 1,
	strlen(line->elements[1].item + 1) + 1);
	last = line->numElements - 1;
	len = strlen(line->elements[last].item) - 1;
	if (isquote(line->elements[last].item[len]))
	line->elements[last].item[len] = '\0';
	}
	}
	/* If we find a generic config option which should live at the
	top of the file, move it there. Old versions of grubby were
	probably responsible for putting new images in the wrong
	place in front of it anyway. */
	if (sawEntry && line->type == LT_GENERIC) {
	struct singleLine **l = &cfg->theLines;
	struct singleLine **last_nonws = &cfg->theLines;
	while (*l) {
	if ((*l)->type != LT_WHITESPACE)
	last_nonws = &((*l)->next);
	l = &((*l)->next);
	}
	line->next = *last_nonws;
	*last_nonws = line;
	movedLine = 1;
	continue; /* without setting 'last' */
	}
	/* If a second line of whitespace happens after a generic option
	which was moved, drop it. */
	if (movedLine && line->type == LT_WHITESPACE && last->type == LT_WHITESPACE) {
	lineFree(line);
	free(line);
	movedLine = 0;
	continue;
1077	}	}
	movedLine = 0;
1078
1079	if (sawEntry) {	if (!line->numElements)
1080	if (!entry->lines)	line->type = LT_WHITESPACE;
1081	entry->lines = line;	else {
1082	else	line->type = getTypeByKeyword(line->elements[0].item, cfi);
1083	last->next = line;	if (line->type == LT_UNKNOWN) {
1084	dbgPrintf("readConfig added %s to %p\n", getKeyByType(line->type, cfi), entry);	/* zipl does [title] instead of something reasonable
1085		* like all the other boot loaders.  kind of ugly */
1086	/* we could have seen this outside of an entry... if so, we	if (cfi->titleBracketed && isBracketedTitle(line)) {
1087	* ignore it like any other line we don't grok */	line->type = LT_TITLE;
1088	if (line->type == LT_ENTRY_END && sawEntry)	}
	sawEntry = 0;
	} else {
	if (!cfg->theLines)
	cfg->theLines = line;
	else
	last->next = line;
	dbgPrintf("readConfig added %s to cfg\n", getKeyByType(line->type, cfi));
	}
	last = line;
	}
	free(incoming);
	dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");
	if (defaultLine) {
	if (defaultLine->numElements > 2 &&
	cfi->defaultSupportSaved &&
	!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
	cfg->defaultImage = DEFAULT_SAVED_GRUB2;
	} else if (cfi->defaultIsVariable) {
	char *value = defaultLine->elements[2].item;
	while (*value && (*value == '"' || *value == '\'' ||
	*value == ' ' || *value == '\t'))
	value++;
	cfg->defaultImage = strtol(value, &end, 10);
	while (*end && (*end == '"' || *end == '\'' ||
	*end == ' ' || *end == '\t'))
	end++;
	if (*end) cfg->defaultImage = -1;
	} else if (cfi->defaultSupportSaved &&
	!strncmp(defaultLine->elements[1].item, "saved", 5)) {
	cfg->defaultImage = DEFAULT_SAVED;
	} else if (cfi->defaultIsIndex) {
	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
	if (*end) cfg->defaultImage = -1;
	} else if (defaultLine->numElements >= 2) {
	int i = 0;
	while ((entry = findEntryByIndex(cfg, i))) {
	for (line = entry->lines; line; line = line->next)
	if (line->type == LT_TITLE) break;
	if (!cfi->titleBracketed) {
	if (line && (line->numElements >= 2) &&
	!strcmp(defaultLine->elements[1].item,
	line->elements[1].item)) break;
	} else if (line) {
	if (!strcmp(defaultLine->elements[1].item,
	extractTitle(line))) break;
	}
	i++;
	entry = NULL;
	}
1089
1090	if (entry){	/* this is awkward, but we need to be able to handle
1091	cfg->defaultImage = i;	* keywords that begin with a # (specifically for
1092	}else{	* #boot in grub.conf), but still make comments lines
1093	cfg->defaultImage = -1;	* with no elements (everything stored in the indent
1094	}	*/
1095	}	if (*line->elements[0].item == '#') {
1096	} else {	char *fullLine;
1097	cfg->defaultImage = 0;	int len;
1098	}
1099		len = strlen(line->indent);
1100	return cfg;	for (int i = 0; i < line->numElements; i++)
1101	}	len += strlen(line->elements[i].item) +
1102		strlen(line->elements[i].indent);
1103	static void writeDefault(FILE * out, char * indent,
1104	char * separator, struct grubConfig * cfg) {	fullLine = malloc(len + 1);
1105	struct singleEntry * entry;	strcpy(fullLine, line->indent);
1106	struct singleLine * line;	free(line->indent);
1107	int i;	line->indent = fullLine;
1108
1109	if (!cfg->defaultImage && cfg->flags == GRUB_CONFIG_NO_DEFAULT) return;	for (int i = 0; i < line->numElements; i++) {
1110		strcat(fullLine,
1111	if (cfg->defaultImage == DEFAULT_SAVED)	line->elements[i].item);
1112	fprintf(out, "%sdefault%ssaved\n", indent, separator);	strcat(fullLine,
1113	else if (cfg->defaultImage == DEFAULT_SAVED_GRUB2)	line->elements[i].indent);
1114	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);	free(line->elements[i].item);
1115	else if (cfg->defaultImage > -1) {	free(line->elements[i].indent);
1116	if (cfg->cfi->defaultIsIndex) {	}
	if (cfg->cfi->defaultIsVariable) {
	fprintf(out, "%sset default=\"%d\"\n", indent,
	cfg->defaultImage);
	} else {
	fprintf(out, "%sdefault%s%d\n", indent, separator,
	cfg->defaultImage);
	}
	} else {
	int image = cfg->defaultImage;
1117
1118	entry = cfg->entries;	line->type = LT_WHITESPACE;
1119	while (entry && entry->skip) entry = entry->next;	line->numElements = 0;
1120		}
1121		} else {
1122		struct keywordTypes *kw;
1123
1124	i = 0;	kw = getKeywordByType(line->type, cfi);
	while (entry && i < image) {
	entry = entry->next;
1125
1126	while (entry && entry->skip) entry = entry->next;	/* space isn't the only separator, we need to split
1127	i++;	* elements up more
1128	}	*/
1129		if (!isspace(kw->separatorChar)) {
1130		char indent[2] = "";
1131		indent[0] = kw->separatorChar;
1132		for (int i = 1; i < line->numElements; i++) {
1133		char *p;
1134		int numNewElements;
1135
1136		numNewElements = 0;
1137		p = line->elements[i].item;
1138		while (*p != '\0') {
1139		if (*p == kw->separatorChar)
1140		numNewElements++;
1141		p++;
1142		}
1143		if (line->numElements +
1144		numNewElements >= elementsAlloced) {
1145		elementsAlloced +=
1146		numNewElements + 5;
1147		line->elements =
1148		realloc(line->elements,
1149		sizeof(*line->
1150		elements) *
1151		elementsAlloced);
1152		}
1153
1154	if (!entry) return;	for (int j = line->numElements; j > i;
1155		j--) {
1156		line->elements[j +
1157		numNewElements] =
1158		line->elements[j];
1159		}
1160		line->numElements += numNewElements;
1161
1162	line = getLineByType(LT_TITLE, entry->lines);	p = line->elements[i].item;
1163		while (*p != '\0') {
1164
1165	if (line && line->numElements >= 2)	while (*p != kw->separatorChar
1166	fprintf(out, "%sdefault%s%s\n", indent, separator,	&& *p != '\0')
1167	line->elements[1].item);	p++;
1168	else if (line && (line->numElements == 1) &&	if (*p == '\0') {
1169	cfg->cfi->titleBracketed) {	break;
1170	fprintf(out, "%sdefault%s%s\n", indent, separator,	}
1171	extractTitle(line));
1172	}	line->elements[i + 1].indent =
1173	}	line->elements[i].indent;
1174	}	line->elements[i].indent =
1175	}	strdup(indent);
1176		*p++ = '\0';
1177	static int writeConfig(struct grubConfig * cfg, char * outName,	i++;
1178	const char * prefix) {	line->elements[i].item =
1179	FILE * out;	strdup(p);
1180	struct singleLine * line;	}
1181	struct singleEntry * entry;	}
1182	char * tmpOutName;	}
1183	int needs = MAIN_DEFAULT;	}
1184	struct stat sb;	}
	int i;
	if (!strcmp(outName, "-")) {
	out = stdout;
	tmpOutName = NULL;
	} else {
	if (!lstat(outName, &sb) && S_ISLNK(sb.st_mode)) {
	char * buf;
	int len = 256;
	int rc;
	/* most likely the symlink is relative, so change our
	directory to the dir of the symlink */
	char *dir = strdupa(outName);
	rc = chdir(dirname(dir));
	do {
	buf = alloca(len + 1);
	rc = readlink(basename(outName), buf, len);
	if (rc == len) len += 256;
	} while (rc == len);
	if (rc < 0) {
	fprintf(stderr, _("grubby: error readlink link %s: %s\n"),
	outName, strerror(errno));
	return 1;
	}
	outName = buf;
	outName[rc] = '\0';
	}
	tmpOutName = alloca(strlen(outName) + 2);
	sprintf(tmpOutName, "%s-", outName);
	out = fopen(tmpOutName, "w");
	if (!out) {
	fprintf(stderr, _("grubby: error creating %s: %s\n"), tmpOutName,
	strerror(errno));
	return 1;
	}
	if (!stat(outName, &sb)) {
	if (chmod(tmpOutName, sb.st_mode & ~(S_IFMT))) {
	fprintf(stderr, _("grubby: error setting perms on %s: %s\n"),
	tmpOutName, strerror(errno));
	fclose(out);
	unlink(tmpOutName);
	return 1;
	}
	}
	}
	line = cfg->theLines;
	struct keywordTypes *defaultKw = getKeywordByType(LT_DEFAULT, cfg->cfi);
	while (line) {
	if (line->type == LT_SET_VARIABLE && defaultKw &&
	line->numElements == 3 &&
	!strcmp(line->elements[1].item, defaultKw->key)) {
	writeDefault(out, line->indent, line->elements[0].indent, cfg);
	needs &= ~MAIN_DEFAULT;
	} else if (line->type == LT_DEFAULT) {
	writeDefault(out, line->indent, line->elements[0].indent, cfg);
	needs &= ~MAIN_DEFAULT;
	} else if (line->type == LT_FALLBACK) {
	if (cfg->fallbackImage > -1)
	fprintf(out, "%s%s%s%d\n", line->indent,
	line->elements[0].item, line->elements[0].indent,
	cfg->fallbackImage);
	} else {
	if (lineWrite(out, line, cfg->cfi) == -1) {
	fprintf(stderr, _("grubby: error writing %s: %s\n"),
	tmpOutName, strerror(errno));
	fclose(out);
	unlink(tmpOutName);
	return 1;
	}
	}
	line = line->next;
	}
	if (needs & MAIN_DEFAULT) {
	writeDefault(out, cfg->primaryIndent, "=", cfg);
	needs &= ~MAIN_DEFAULT;
	}
	i = 0;
	while ((entry = findEntryByIndex(cfg, i++))) {
	if (entry->skip) continue;
1185
1186	line = entry->lines;	return 0;
	while (line) {
	if (lineWrite(out, line, cfg->cfi) == -1) {
	fprintf(stderr, _("grubby: error writing %s: %s\n"),
	tmpOutName, strerror(errno));
	fclose(out);
	unlink(tmpOutName);
	return 1;
	}
	line = line->next;
	}
	}
	if (tmpOutName) {
	if (rename(tmpOutName, outName)) {
	fprintf(stderr, _("grubby: error moving %s to %s: %s\n"),
	tmpOutName, outName, strerror(errno));
	unlink(outName);
	return 1;
	}
	}
	return 0;
	}
	static int numEntries(struct grubConfig *cfg) {
	int i = 0;
	struct singleEntry * entry;
	entry = cfg->entries;
	while (entry) {
	if (!entry->skip)
	i++;
	entry = entry->next;
	}
	return i;
1187	}	}
1188
1189	static char *findDiskForRoot()	static int isnumber(const char *s)
1190	{	{
1191	int fd;	int i;
1192	char buf[65536];	for (i = 0; s[i] != '\0'; i++)
1193	char *devname;	if (s[i] < '0' || s[i] > '9')
1194	char *chptr;	return 0;
1195	int rc;	return i;
	if ((fd = open(_PATH_MOUNTED, O_RDONLY)) < 0) {
	fprintf(stderr, "grubby: failed to open %s: %s\n",
	_PATH_MOUNTED, strerror(errno));
	return NULL;
	}
	rc = read(fd, buf, sizeof(buf) - 1);
	if (rc <= 0) {
	fprintf(stderr, "grubby: failed to read %s: %s\n",
	_PATH_MOUNTED, strerror(errno));
	close(fd);
	return NULL;
	}
	close(fd);
	buf[rc] = '\0';
	chptr = buf;
	char *foundanswer = NULL;
	while (chptr && chptr != buf+rc) {
	devname = chptr;
	/*
	* The first column of a mtab entry is the device, but if the entry is a
	* special device it won't start with /, so move on to the next line.
	*/
	if (*devname != '/') {
	chptr = strchr(chptr, '\n');
	if (chptr)
	chptr++;
	continue;
	}
	/* Seek to the next space */
	chptr = strchr(chptr, ' ');
	if (!chptr) {
	fprintf(stderr, "grubby: error parsing %s: %s\n",
	_PATH_MOUNTED, strerror(errno));
	return NULL;
	}
	/*
	* The second column of a mtab entry is the mount point, we are looking
	* for '/' obviously.
	*/
	if (*(++chptr) == '/' && *(++chptr) == ' ') {
	/* remember the last / entry in mtab */
	foundanswer = devname;
	}
	/* Next line */
	chptr = strchr(chptr, '\n');
	if (chptr)
	chptr++;
	}
	/* Return the last / entry found */
	if (foundanswer) {
	chptr = strchr(foundanswer, ' ');
	*chptr = '\0';
	return strdup(foundanswer);
	}
	return NULL;
	}
	void printEntry(struct singleEntry * entry) {
	int i;
	struct singleLine * line;
	for (line = entry->lines; line; line = line->next) {
	fprintf(stderr, "DBG: %s", line->indent);
	for (i = 0; i < line->numElements; i++) {
	/* Need to handle this, because we strip the quotes from
	* menuentry when read it. */
	if (line->type == LT_MENUENTRY && i == 1) {
	if(!isquote(*line->elements[i].item))
	fprintf(stderr, "\'%s\'", line->elements[i].item);
	else
	fprintf(stderr, "%s", line->elements[i].item);
	fprintf(stderr, "%s", line->elements[i].indent);
	continue;
	}
	fprintf(stderr, "%s%s",
	line->elements[i].item, line->elements[i].indent);
	}
	fprintf(stderr, "\n");
	}
	}
	void notSuitablePrintf(struct singleEntry * entry, const char *fmt, ...)
	{
	va_list argp;
	if (!debug)
	return;
	va_start(argp, fmt);
	fprintf(stderr, "DBG: Image entry failed: ");
	vfprintf(stderr, fmt, argp);
	printEntry(entry);
	va_end(argp);
1196	}	}
1197
1198	#define beginswith(s, c) ((s) && (s)[0] == (c))	static struct grubConfig *readConfig(const char *inName,
1199		struct configFileInfo *cfi)
	static int endswith(const char *s, char c)
1200	{	{
1201	int slen;	int in;
1202		char *incoming = NULL, *head;
1203		int rc;
1204		int sawEntry = 0;
1205		int movedLine = 0;
1206		struct grubConfig *cfg;
1207		struct singleLine *last = NULL, *line, *defaultLine = NULL;
1208		char *end;
1209		struct singleEntry *entry = NULL;
1210		int len;
1211		char *buf;
1212
1213		if (inName == NULL) {
1214		printf("Could not find bootloader configuration\n");
1215		exit(1);
1216		} else if (!strcmp(inName, "-")) {
1217		in = 0;
1218		} else {
1219		if ((in = open(inName, O_RDONLY)) < 0) {
1220		fprintf(stderr, _("error opening %s for read: %s\n"),
1221		inName, strerror(errno));
1222		return NULL;
1223		}
1224		}
1225
1226	if (!s || !s[0])	rc = readFile(in, &incoming);
1227	return 0;	close(in);
1228	slen = strlen(s) - 1;	if (rc)
1229		return NULL;
1230
1231		head = incoming;
1232		cfg = malloc(sizeof(*cfg));
1233		cfg->primaryIndent = strdup("");
1234		cfg->secondaryIndent = strdup("\t");
1235		cfg->flags = GRUB_CONFIG_NO_DEFAULT;
1236		cfg->cfi = cfi;
1237		cfg->theLines = NULL;
1238		cfg->entries = NULL;
1239		cfg->fallbackImage = 0;
1240
1241		/* copy everything we have */
1242		while (*head) {
1243		line = malloc(sizeof(*line));
1244		lineInit(line);
1245
1246		if (getNextLine(&head, line, cfi)) {
1247		free(line);
1248		/* XXX memory leak of everything in cfg */
1249		return NULL;
1250		}
1251
1252	return s[slen] == c;	if (!sawEntry && line->numElements) {
1253	}	free(cfg->primaryIndent);
1254		cfg->primaryIndent = strdup(line->indent);
1255		} else if (line->numElements) {
1256		free(cfg->secondaryIndent);
1257		cfg->secondaryIndent = strdup(line->indent);
1258		}
1259
1260	int suitableImage(struct singleEntry * entry, const char * bootPrefix,	if (isEntryStart(line, cfi) || (cfg->entries && !sawEntry)) {
1261	int skipRemoved, int flags) {	sawEntry = 1;
1262	struct singleLine * line;	if (!entry) {
1263	char * fullName;	cfg->entries = malloc(sizeof(*entry));
1264	int i;	entry = cfg->entries;
1265	char * dev;	} else {
1266	char * rootspec;	entry->next = malloc(sizeof(*entry));
1267	char * rootdev;	entry = entry->next;
1268		}
1269
1270	if (skipRemoved && entry->skip) {	entry->skip = 0;
1271	notSuitablePrintf(entry, "marked to skip\n");	entry->multiboot = 0;
1272	return 0;	entry->lines = NULL;
1273	}	entry->next = NULL;
1274		}
1275
1276	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);	if (line->type == LT_SET_VARIABLE) {
1277	if (!line) {	dbgPrintf("found 'set' command (%d elements): ",
1278	notSuitablePrintf(entry, "no line found\n");	line->numElements);
1279	return 0;	dbgPrintf("%s", line->indent);
1280	}	for (int i = 0; i < line->numElements; i++)
1281	if (line->numElements < 2) {	dbgPrintf("\"%s\"%s", line->elements[i].item,
1282	notSuitablePrintf(entry, "line has only %d elements\n",	line->elements[i].indent);
1283	line->numElements);	dbgPrintf("\n");
1284	return 0;	struct keywordTypes *kwType =
1285	}	getKeywordByType(LT_DEFAULT, cfi);
1286		if (kwType && line->numElements == 3
1287		&& !strcmp(line->elements[1].item, kwType->key)
1288		&& !is_special_grub2_variable(line->elements[2].
1289		item)) {
1290		dbgPrintf("Line sets default config\n");
1291		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1292		defaultLine = line;
1293		}
1294
1295	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	} else if (iskernel(line->type)) {
1296		/* if by some freak chance this is multiboot and the
1297		* "module" lines came earlier in the template, make
1298		* sure to use LT_HYPER instead of LT_KERNEL now
1299		*/
1300		if (entry && entry->multiboot)
1301		line->type = LT_HYPER;
1302
1303	fullName = alloca(strlen(bootPrefix) +	} else if (line->type == LT_MBMODULE) {
1304	strlen(line->elements[1].item) + 1);	/* go back and fix the LT_KERNEL line to indicate
1305	rootspec = getRootSpecifier(line->elements[1].item);	* LT_HYPER instead, now that we know this is a
1306	int rootspec_offset = rootspec ? strlen(rootspec) : 0;	* multiboot entry.  This only applies to grub, but
1307	int hasslash = endswith(bootPrefix, '/') ||	* that's the only place we should find LT_MBMODULE
1308	beginswith(line->elements[1].item + rootspec_offset, '/');	* lines anyway.
1309	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",	*/
1310	line->elements[1].item + rootspec_offset);	for (struct singleLine * l = entry->lines; l;
1311	if (access(fullName, R_OK)) {	l = l->next) {
1312	notSuitablePrintf(entry, "access to %s failed\n", fullName);	if (l->type == LT_HYPER)
1313	return 0;	break;
1314	}	else if (iskernel(l->type)) {
1315	for (i = 2; i < line->numElements; i++)	l->type = LT_HYPER;
1316	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	break;
1317	if (i < line->numElements) {	}
1318	dev = line->elements[i].item + 5;	}
1319	} else {	entry->multiboot = 1;
	/* look for a lilo style LT_ROOT line */
	line = getLineByType(LT_ROOT, entry->lines);
1320
1321	if (line && line->numElements >= 2) {	} else if (line->type == LT_HYPER) {
1322	dev = line->elements[1].item;	entry->multiboot = 1;
	} else {
	/* didn't succeed in finding a LT_ROOT, let's try LT_KERNELARGS.
	* grub+multiboot uses LT_MBMODULE for the args, so check that too.
	*/
	line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);
	/* failed to find one */
	if (!line) {
	notSuitablePrintf(entry, "no line found\n");
	return 0;
	}
1323
1324	for (i = 1; i < line->numElements; i++)	} else if (line->type == LT_FALLBACK && line->numElements == 2) {
1325	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	cfg->fallbackImage =
1326	if (i < line->numElements)	strtol(line->elements[1].item, &end, 10);
1327	dev = line->elements[i].item + 5;	if (*end)
1328	else {	cfg->fallbackImage = -1;
1329	notSuitablePrintf(entry, "no root= entry found\n");
1330	/* it failed too...  can't find root= */	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted)
1331	return 0;	|| (line->type == LT_TITLE
1332	}	&& line->numElements > 1)) {
1333	}	/* make the title/default a single argument (undoing
1334	}	* our parsing) */
1335		len = 0;
1336	dev = getpathbyspec(dev);	for (int i = 1; i < line->numElements; i++) {
1337	if (!getpathbyspec(dev)) {	len += strlen(line->elements[i].item);
1338	notSuitablePrintf(entry, "can't find blkid entry for %s\n", dev);	len += strlen(line->elements[i].indent);
1339	return 0;	}
1340	} else	buf = malloc(len + 1);
1341	dev = getpathbyspec(dev);	*buf = '\0';
1342
1343	rootdev = findDiskForRoot();	for (int i = 1; i < line->numElements; i++) {
1344	if (!rootdev) {	strcat(buf, line->elements[i].item);
1345	notSuitablePrintf(entry, "can't find root device\n");	free(line->elements[i].item);
1346	return 0;
1347	}	if ((i + 1) != line->numElements) {
1348		strcat(buf, line->elements[i].indent);
1349		free(line->elements[i].indent);
1350		}
1351		}
1352
1353	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {	line->elements[1].indent =
1354	notSuitablePrintf(entry, "uuid missing: rootdev %s, dev %s\n",	line->elements[line->numElements - 1].indent;
1355	getuuidbydev(rootdev), getuuidbydev(dev));	line->elements[1].item = buf;
1356	free(rootdev);	line->numElements = 2;
1357	return 0;	} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
1358	}	/* let --remove-kernel="TITLE=what" work */
1359		len = 0;
1360	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {	char *extras;
1361	notSuitablePrintf(entry, "uuid mismatch: rootdev %s, dev %s\n",	char *title;
1362	getuuidbydev(rootdev), getuuidbydev(dev));	/* initially unseen value */
1363	free(rootdev);	char quote_char = '\0';
1364	return 0;
1365	}	for (int i = 1; i < line->numElements; i++) {
1366		len += strlen(line->elements[i].item);
1367		len += strlen(line->elements[i].indent);
1368		}
1369		buf = malloc(len + 1);
1370		*buf = '\0';
1371
1372	free(rootdev);	/* allocate mem for extra flags. */
1373		extras = malloc(len + 1);
1374		*extras = '\0';
1375
1376		/* get title. */
1377		for (int i = 0; i < line->numElements; i++) {
1378		if (!strcmp
1379		(line->elements[i].item, "menuentry"))
1380		continue;
1381		if (isquote(*line->elements[i].item)
1382		&& quote_char == '\0') {
1383		/* ensure we properly pair off quotes */
1384		quote_char = *line->elements[i].item;
1385		title = line->elements[i].item + 1;
1386		} else {
1387		title = line->elements[i].item;
1388		}
1389
1390	return 1;	len = strlen(title);
1391	}	if (title[len - 1] == quote_char) {
1392		strncat(buf, title, len - 1);
1393		break;
1394		} else {
1395		strcat(buf, title);
1396		strcat(buf, line->elements[i].indent);
1397		}
1398		}
1399
1400	/* returns the first match on or after the one pointed to by index (if index	/* get extras */
1401	is not NULL) which is not marked as skip */	int count = 0;
1402	struct singleEntry * findEntryByPath(struct grubConfig * config,	quote_char = '\0';
1403	const char * kernel, const char * prefix,	for (int i = 0; i < line->numElements; i++) {
1404	int * index) {	if (count >= 2) {
1405	struct singleEntry * entry = NULL;	strcat(extras, line->elements[i].item);
1406	struct singleLine * line;	strcat(extras,
1407	int i;	line->elements[i].indent);
1408	char * chptr;	}
	char * rootspec = NULL;
	enum lineType_e checkType = LT_KERNEL;
1409
1410	if (isdigit(*kernel)) {	if (!strcmp
1411	int * indexVars = alloca(sizeof(*indexVars) * strlen(kernel));	(line->elements[i].item, "menuentry"))
1412		continue;
1413
1414		/* count ' or ", there should be two in menuentry line. */
1415		if (isquote(*line->elements[i].item)
1416		&& quote_char == '\0') {
1417		/* ensure we properly pair off quotes */
1418		quote_char = *line->elements[i].item;
1419		count++;
1420		}
1421
1422	i = 0;	len = strlen(line->elements[i].item);
	indexVars[i] = strtol(kernel, &chptr, 10);
	while (*chptr == ',') {
	i++;
	kernel = chptr + 1;
	indexVars[i] = strtol(kernel, &chptr, 10);
	}
1423
1424	if (*chptr) {	if (line->elements[i].item[len - 1] ==
1425	/* can't parse it, bail */	quote_char)
1426	return NULL;	count++;
	}
1427
1428	indexVars[i + 1] = -1;	/* ok, we get the final ' or ", others are extras. */
1429		}
1430	i = 0;	line->elements[1].indent =
1431	if (index) {	line->elements[line->numElements - 2].indent;
1432	while (i < *index) i++;	line->elements[1].item = buf;
1433	if (indexVars[i] == -1) return NULL;	line->elements[2].indent =
1434	}	line->elements[line->numElements - 2].indent;
1435		line->elements[2].item = extras;
1436		line->numElements = 3;
1437		} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
1438		/* Strip off any " which may be present; they'll be
1439		* put back on write. This is one of the few (the
1440		* only?) places that grubby canonicalizes the output
1441		*/
1442		if (line->numElements >= 2) {
1443		int last, len;
1444
1445	entry = findEntryByIndex(config, indexVars[i]);	if (isquote(*line->elements[1].item))
1446	if (!entry) return NULL;	memmove(line->elements[1].item,
1447		line->elements[1].item + 1,
1448		strlen(line->elements[1].item +
1449		1) + 1);
1450
1451		last = line->numElements - 1;
1452		len = strlen(line->elements[last].item) - 1;
1453		if (isquote(line->elements[last].item[len]))
1454		line->elements[last].item[len] = '\0';
1455		}
1456		}
1457
1458	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);	if (line->type == LT_DEFAULT && line->numElements == 2) {
1459	if (!line) return NULL;	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1460		defaultLine = line;
1461		}
1462
1463	if (index) *index = indexVars[i];	/* If we find a generic config option which should live at the
1464	return entry;	top of the file, move it there. Old versions of grubby were
1465	}	probably responsible for putting new images in the wrong
1466		place in front of it anyway. */
1467	if (!strcmp(kernel, "DEFAULT")) {	if (sawEntry && line->type == LT_GENERIC) {
1468	if (index && *index > config->defaultImage) {	struct singleLine **l = &cfg->theLines;
1469	entry = NULL;	struct singleLine **last_nonws = &cfg->theLines;
1470	} else {	while (*l) {
1471	entry = findEntryByIndex(config, config->defaultImage);	if ((*l)->type != LT_WHITESPACE)
1472	if (entry && entry->skip)	last_nonws = &((*l)->next);
1473	entry = NULL;	l = &((*l)->next);
1474	else if (index)	}
1475	*index = config->defaultImage;	line->next = *last_nonws;
1476	}	*last_nonws = line;
1477	} else if (!strcmp(kernel, "ALL")) {	movedLine = 1;
1478	if (index)	continue; /* without setting 'last' */
1479	i = *index;	}
	else
	i = 0;
1480
1481	while ((entry = findEntryByIndex(config, i))) {	/* If a second line of whitespace happens after a generic
1482	if (!entry->skip) break;	* option which was moved, drop it. */
1483	i++;	if (movedLine && line->type == LT_WHITESPACE
1484	}	&& last->type == LT_WHITESPACE) {
1485		lineFree(line);
1486		free(line);
1487		movedLine = 0;
1488		continue;
1489		}
1490		movedLine = 0;
1491
1492	if (entry && index)	if (sawEntry) {
1493	*index = i;	if (!entry->lines)
1494	} else {	entry->lines = line;
1495	if (index)	else
1496	i = *index;	last->next = line;
1497	else	dbgPrintf("readConfig added %s to %p\n",
1498	i = 0;	getKeyByType(line->type, cfi), entry);
1499
1500	if (!strncmp(kernel, "TITLE=", 6)) {	/* we could have seen this outside of an entry... if
1501	prefix = "";	* so, we ignore it like any other line we don't grok
1502	checkType = LT_TITLE|LT_MENUENTRY;	*/
1503	kernel += 6;	if (line->type == LT_ENTRY_END && sawEntry)
1504	}	sawEntry = 0;
1505		} else {
1506	for (entry = findEntryByIndex(config, i); entry; entry = entry->next, i++) {	if (!cfg->theLines)
1507	if (entry->skip) continue;	cfg->theLines = line;
1508		else
1509	dbgPrintf("findEntryByPath looking for %d %s in %p\n", checkType, kernel, entry);	last->next = line;
1510		dbgPrintf("readConfig added %s to cfg\n",
1511	/* check all the lines matching checkType */	getKeyByType(line->type, cfi));
	for (line = entry->lines; line; line = line->next) {
	enum lineType_e ct = checkType;
	if (entry->multiboot && checkType == LT_KERNEL)
	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER;
	else if (checkType & LT_KERNEL)
	ct = checkType | LT_KERNEL_EFI;
	line = getLineByType(ct, line);
	if (!line)
	break;  /* not found in this entry */
	if (line && line->type != LT_MENUENTRY &&
	line->numElements >= 2) {
	rootspec = getRootSpecifier(line->elements[1].item);
	if (!strcmp(line->elements[1].item +
	((rootspec != NULL) ? strlen(rootspec) : 0),
	kernel + strlen(prefix)))
	break;
1512	}	}
	if(line->type == LT_MENUENTRY &&
	!strcmp(line->elements[1].item, kernel))
	break;
	}
1513
1514	/* make sure this entry has a kernel identifier; this skips	last = line;
	* non-Linux boot entries (could find netbsd etc, though, which is
	* unfortunate)
	*/
	if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines))
	break; /* found 'im! */
1515	}	}
1516
1517	if (index) *index = i;	free(incoming);
	}
1518
1519	return entry;	dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");
1520	}	if (defaultLine) {
1521		if (defaultLine->numElements > 2 &&
1522	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {	cfi->defaultSupportSaved &&
1523	struct singleEntry * entry;	!strncmp(defaultLine->elements[2].item,
1524		"\"${saved_entry}\"", 16)) {
1525		cfg->cfi->defaultIsSaved = 1;
1526		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1527		if (cfg->cfi->getEnv) {
1528		char *defTitle =
1529		cfi->getEnv(cfg->cfi, "saved_entry");
1530		if (defTitle) {
1531		int index = 0;
1532		if (isnumber(defTitle)) {
1533		index = atoi(defTitle);
1534		entry =
1535		findEntryByIndex(cfg,
1536		index);
1537		} else {
1538		entry =
1539		findEntryByTitle(cfg,
1540		defTitle,
1541		&index);
1542		}
1543		if (entry)
1544		cfg->defaultImage = index;
1545		}
1546		}
1547		} else if (cfi->defaultIsVariable) {
1548		char *value = defaultLine->elements[2].item;
1549		while (*value && (*value == '"' || *value == '\'' ||
1550		*value == ' ' || *value == '\t'))
1551		value++;
1552		cfg->defaultImage = strtol(value, &end, 10);
1553		while (*end && (*end == '"' || *end == '\'' ||
1554		*end == ' ' || *end == '\t'))
1555		end++;
1556		if (*end)
1557		cfg->defaultImage = -1;
1558		} else if (cfi->defaultSupportSaved &&
1559		!strncmp(defaultLine->elements[1].item, "saved",
1560		5)) {
1561		cfg->defaultImage = DEFAULT_SAVED;
1562		} else if (cfi->defaultIsIndex) {
1563		cfg->defaultImage =
1564		strtol(defaultLine->elements[1].item, &end, 10);
1565		if (*end)
1566		cfg->defaultImage = -1;
1567		} else if (defaultLine->numElements >= 2) {
1568		int i = 0;
1569		while ((entry = findEntryByIndex(cfg, i))) {
1570		for (line = entry->lines; line;
1571		line = line->next)
1572		if (line->type == LT_TITLE)
1573		break;
1574
1575		if (!cfi->titleBracketed) {
1576		if (line && (line->numElements >= 2) &&
1577		!strcmp(defaultLine->elements[1].
1578		item,
1579		line->elements[1].item))
1580		break;
1581		} else if (line) {
1582		if (!strcmp
1583		(defaultLine->elements[1].item,
1584		extractTitle(cfg, line)))
1585		break;
1586		}
1587		i++;
1588		entry = NULL;
1589		}
1590
1591	entry = cfg->entries;	if (entry) {
1592	while (index && entry) {	cfg->defaultImage = i;
1593	entry = entry->next;	} else {
1594	index--;	cfg->defaultImage = -1;
1595	}	}
1596		}
1597		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1598		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1599		if (defTitle) {
1600		int index = 0;
1601		if (isnumber(defTitle)) {
1602		index = atoi(defTitle);
1603		entry = findEntryByIndex(cfg, index);
1604		} else {
1605		entry = findEntryByTitle(cfg, defTitle, &index);
1606		}
1607		if (entry)
1608		cfg->defaultImage = index;
1609		}
1610		} else {
1611		cfg->defaultImage = 0;
1612		}
1613
1614	return entry;	return cfg;
1615	}	}
1616
1617	/* Find a good template to use for the new kernel. An entry is	static void writeDefault(FILE * out, char *indent,
1618	* good if the kernel and mkinitrd exist (even if the entry	char *separator, struct grubConfig *cfg)
1619	* is going to be removed). Try and use the default entry, but	{
1620	* if that doesn't work just take the first. If we can't find one,	struct singleEntry *entry;
1621	* bail. */	struct singleLine *line;
1622	struct singleEntry * findTemplate(struct grubConfig * cfg, const char * prefix,	int i;
1623	int * indexPtr, int skipRemoved, int flags) {
1624	struct singleEntry * entry, * entry2;	if (!cfg->defaultImage && cfg->flags == GRUB_CONFIG_NO_DEFAULT)
1625	int index;	return;
1626
1627	if (cfg->defaultImage > -1) {	if (cfg->defaultImage == DEFAULT_SAVED)
1628	entry = findEntryByIndex(cfg, cfg->defaultImage);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1629	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	else if (cfg->cfi->defaultIsSaved) {
1630	if (indexPtr) *indexPtr = cfg->defaultImage;	fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1631	return entry;	if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1632	}	char *title;
1633	}	entry = findEntryByIndex(cfg, cfg->defaultImage);
1634		line = getLineByType(LT_MENUENTRY, entry->lines);
1635		if (!line)
1636		line = getLineByType(LT_TITLE, entry->lines);
1637		if (line) {
1638		title = extractTitle(cfg, line);
1639		if (title)
1640		cfg->cfi->setEnv(cfg->cfi,
1641		"saved_entry", title);
1642		}
1643		}
1644		} else if (cfg->defaultImage > -1) {
1645		if (cfg->cfi->defaultIsIndex) {
1646		if (cfg->cfi->defaultIsVariable) {
1647		fprintf(out, "%sset default=\"%d\"\n", indent,
1648		cfg->defaultImage);
1649		} else {
1650		fprintf(out, "%sdefault%s%d\n", indent,
1651		separator, cfg->defaultImage);
1652		}
1653		} else {
1654		int image = cfg->defaultImage;
1655
1656	index = 0;	entry = cfg->entries;
1657	while ((entry = findEntryByIndex(cfg, index))) {	while (entry && entry->skip)
1658	if (suitableImage(entry, prefix, skipRemoved, flags)) {	entry = entry->next;
1659	int j;
1660	for (j = 0; j < index; j++) {	i = 0;
1661	entry2 = findEntryByIndex(cfg, j);	while (entry && i < image) {
1662	if (entry2->skip) index--;	entry = entry->next;
	}
	if (indexPtr) *indexPtr = index;
1663
1664	return entry;	while (entry && entry->skip)
1665	}	entry = entry->next;
1666		i++;
1667		}
1668
1669	index++;	if (!entry)
1670	}	return;
1671
1672	fprintf(stderr, _("grubby fatal error: unable to find a suitable template\n"));	line = getLineByType(LT_TITLE, entry->lines);
1673
1674	return NULL;	if (line && line->numElements >= 2)
1675		fprintf(out, "%sdefault%s%s\n", indent,
1676		separator, line->elements[1].item);
1677		else if (line && (line->numElements == 1)
1678		&& cfg->cfi->titleBracketed) {
1679		char *title = extractTitle(cfg, line);
1680		if (title) {
1681		fprintf(out, "%sdefault%s%s\n", indent,
1682		separator, title);
1683		free(title);
1684		}
1685		}
1686		}
1687		}
1688	}	}
1689
1690	char * findBootPrefix(void) {	static int writeConfig(struct grubConfig *cfg, char *outName,
1691	struct stat sb, sb2;	const char *prefix)
1692		{
1693	stat("/", &sb);	FILE *out;
1694	#ifdef __ia64__	struct singleLine *line;
1695	stat("/boot/efi/EFI/redhat/", &sb2);	struct singleEntry *entry;
1696	#else	char *tmpOutName;
1697	stat("/boot", &sb2);	int needs = MAIN_DEFAULT;
1698	#endif	struct stat sb;
1699		int i;
1700
1701		if (!strcmp(outName, "-")) {
1702		out = stdout;
1703		tmpOutName = NULL;
1704		} else {
1705		if (!lstat(outName, &sb) && S_ISLNK(sb.st_mode)) {
1706		char *buf;
1707		int len = 256;
1708		int rc;
1709
1710		/* most likely the symlink is relative, so change our
1711		directory to the dir of the symlink */
1712		char *dir = strdupa(outName);
1713		rc = chdir(dirname(dir));
1714		do {
1715		buf = alloca(len + 1);
1716		rc = readlink(basename(outName), buf, len);
1717		if (rc == len)
1718		len += 256;
1719		} while (rc == len);
1720
1721		if (rc < 0) {
1722		fprintf(stderr,
1723		_
1724		("grubby: error readlink link %s: %s\n"),
1725		outName, strerror(errno));
1726		return 1;
1727		}
1728
1729	if (sb.st_dev == sb2.st_dev)	outName = buf;
1730	return strdup("");	outName[rc] = '\0';
1731		}
1732
1733	#ifdef __ia64__	tmpOutName = alloca(strlen(outName) + 2);
1734	return strdup("/boot/efi/EFI/redhat/");	sprintf(tmpOutName, "%s-", outName);
1735	#else	out = fopen(tmpOutName, "w");
1736	return strdup("/boot");	if (!out) {
1737	#endif	fprintf(stderr, _("grubby: error creating %s: %s\n"),
1738	}	tmpOutName, strerror(errno));
1739		return 1;
1740		}
1741
1742	void markRemovedImage(struct grubConfig * cfg, const char * image,	if (!stat(outName, &sb)) {
1743	const char * prefix) {	if (chmod(tmpOutName, sb.st_mode & ~(S_IFMT))) {
1744	struct singleEntry * entry;	fprintf(stderr,
1745		_
1746	if (!image)	("grubby: error setting perms on %s: %s\n"),
1747	return;	tmpOutName, strerror(errno));
1748		fclose(out);
1749	/* check and see if we're removing the default image */	unlink(tmpOutName);
1750	if (isdigit(*image)) {	return 1;
1751	entry = findEntryByPath(cfg, image, prefix, NULL);	}
1752	if(entry)	}
	entry->skip = 1;
	return;
	}
	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
	entry->skip = 1;
	}
	void setDefaultImage(struct grubConfig * config, int hasNew,
	const char * defaultKernelPath, int newIsDefault,
	const char * prefix, int flags, int index) {
	struct singleEntry * entry, * entry2, * newDefault;
	int i, j;
	if (newIsDefault) {
	config->defaultImage = 0;
	return;
	} else if ((index >= 0) && config->cfi->defaultIsIndex) {
	if (findEntryByIndex(config, index))
	config->defaultImage = index;
	else
	config->defaultImage = -1;
	return;
	} else if (defaultKernelPath) {
	i = 0;
	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
	config->defaultImage = i;
	} else {
	config->defaultImage = -1;
	return;
1753	}	}
	}
	/* defaultImage now points to what we'd like to use, but before any order
	changes */
	if ((config->defaultImage == DEFAULT_SAVED) ||
	(config->defaultImage == DEFAULT_SAVED_GRUB2))
	/* default is set to saved, we don't want to change it */
	return;
	if (config->defaultImage > -1)
	entry = findEntryByIndex(config, config->defaultImage);
	else
	entry = NULL;
1754
1755	if (entry && !entry->skip) {	line = cfg->theLines;
1756	/* we can preserve the default */	struct keywordTypes *defaultKw = getKeywordByType(LT_DEFAULT, cfg->cfi);
1757	if (hasNew)	while (line) {
1758	config->defaultImage++;	if (line->type == LT_SET_VARIABLE && defaultKw &&
1759		line->numElements == 3 &&
1760	/* count the number of entries erased before this one */	!strcmp(line->elements[1].item, defaultKw->key) &&
1761	for (j = 0; j < config->defaultImage; j++) {	!is_special_grub2_variable(line->elements[2].item)) {
1762	entry2 = findEntryByIndex(config, j);	writeDefault(out, line->indent,
1763	if (entry2->skip) config->defaultImage--;	line->elements[0].indent, cfg);
1764	}	needs &= ~MAIN_DEFAULT;
1765	} else if (hasNew) {	} else if (line->type == LT_DEFAULT) {
1766	config->defaultImage = 0;	writeDefault(out, line->indent,
1767	} else {	line->elements[0].indent, cfg);
1768	/* Either we just erased the default (or the default line was bad	needs &= ~MAIN_DEFAULT;
1769	* to begin with) and didn't put a new one in. We'll use the first	} else if (line->type == LT_FALLBACK) {
1770	* valid image. */	if (cfg->fallbackImage > -1)
1771	newDefault = findTemplate(config, prefix, &config->defaultImage, 1,	fprintf(out, "%s%s%s%d\n", line->indent,
1772	flags);	line->elements[0].item,
1773	if (!newDefault)	line->elements[0].indent,
1774	config->defaultImage = -1;	cfg->fallbackImage);
1775	}	} else {
1776	}	if (lineWrite(out, line, cfg->cfi) == -1) {
1777		fprintf(stderr,
1778	void setFallbackImage(struct grubConfig * config, int hasNew) {	_("grubby: error writing %s: %s\n"),
1779	struct singleEntry * entry, * entry2;	tmpOutName, strerror(errno));
1780	int j;	fclose(out);
1781		unlink(tmpOutName);
1782	if (config->fallbackImage == -1) return;	return 1;
1783		}
1784	entry = findEntryByIndex(config, config->fallbackImage);	}
	if (!entry || entry->skip) {
	config->fallbackImage = -1;
	return;
	}
	if (hasNew)
	config->fallbackImage++;
	/* count the number of entries erased before this one */
	for (j = 0; j < config->fallbackImage; j++) {
	entry2 = findEntryByIndex(config, j);
	if (entry2->skip) config->fallbackImage--;
	}
	}
	void displayEntry(struct singleEntry * entry, const char * prefix, int index) {
	struct singleLine * line;
	char * root = NULL;
	int i;
	printf("index=%d\n", index);
	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
	if (!line) {
	printf("non linux entry\n");
	return;
	}
	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
	printf("kernel=%s\n", line->elements[1].item);
	else
	printf("kernel=%s%s\n", prefix, line->elements[1].item);
	if (line->numElements >= 3) {
	printf("args=\"");
	i = 2;
	while (i < line->numElements) {
	if (!strncmp(line->elements[i].item, "root=", 5)) {
	root = line->elements[i].item + 5;
	} else {
	printf("%s%s", line->elements[i].item,
	line->elements[i].indent);
	}
1785
1786	i++;	line = line->next;
1787	}	}
	printf("\"\n");
	} else {
	line = getLineByType(LT_KERNELARGS, entry->lines);
	if (line) {
	char * s;
1788
1789	printf("args=\"");	if (needs & MAIN_DEFAULT) {
1790	i = 1;	writeDefault(out, cfg->primaryIndent, "=", cfg);
1791	while (i < line->numElements) {	needs &= ~MAIN_DEFAULT;
1792	if (!strncmp(line->elements[i].item, "root=", 5)) {	}
	root = line->elements[i].item + 5;
	} else {
	s = line->elements[i].item;
1793
1794	printf("%s%s", s, line->elements[i].indent);	i = 0;
1795		while ((entry = findEntryByIndex(cfg, i++))) {
1796		if (entry->skip)
1797		continue;
1798
1799		line = entry->lines;
1800		while (line) {
1801		if (lineWrite(out, line, cfg->cfi) == -1) {
1802		fprintf(stderr,
1803		_("grubby: error writing %s: %s\n"),
1804		tmpOutName, strerror(errno));
1805		fclose(out);
1806		unlink(tmpOutName);
1807		return 1;
1808		}
1809		line = line->next;
1810	}	}
1811		}
1812
1813	i++;	if (tmpOutName) {
1814	}	if (rename(tmpOutName, outName)) {
1815		fprintf(stderr,
1816	s = line->elements[i - 1].indent;	_("grubby: error moving %s to %s: %s\n"),
1817	printf("\"\n");	tmpOutName, outName, strerror(errno));
1818		unlink(outName);
1819		return 1;
1820		}
1821	}	}
	}
1822
1823	if (!root) {	return 0;
1824	line = getLineByType(LT_ROOT, entry->lines);	}
	if (line && line->numElements >= 2)
	root=line->elements[1].item;
	}
	if (root) {
	char * s = alloca(strlen(root) + 1);
	strcpy(s, root);
	if (s[strlen(s) - 1] == '"')
	s[strlen(s) - 1] = '\0';
	/* make sure the root doesn't have a trailing " */
	printf("root=%s\n", s);
	}
1825
1826	line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);	static int numEntries(struct grubConfig *cfg)
1827		{
1828		int i = 0;
1829		struct singleEntry *entry;
1830
1831	if (line && line->numElements >= 2) {	entry = cfg->entries;
1832	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))	while (entry) {
1833	printf("initrd=");	if (!entry->skip)
1834	else	i++;
1835	printf("initrd=%s", prefix);	entry = entry->next;
1836		}
1837		return i;
1838		}
1839
1840	for (i = 1; i < line->numElements; i++)	static char *findDiskForRoot()
1841	printf("%s%s", line->elements[i].item, line->elements[i].indent);	{
1842	printf("\n");	int fd;
1843	}	char buf[65536];
1844		char *devname;
1845	line = getLineByType(LT_TITLE, entry->lines);	char *chptr;
1846	if (line) {	int rc;
1847	printf("title=%s\n", line->elements[1].item);
1848	} else {	if ((fd = open(_PATH_MOUNTED, O_RDONLY)) < 0) {
1849	char * title;	fprintf(stderr, "grubby: failed to open %s: %s\n",
1850	line = getLineByType(LT_MENUENTRY, entry->lines);	_PATH_MOUNTED, strerror(errno));
1851	title = grub2ExtractTitle(line);	return NULL;
1852	if (title)	}
1853	printf("title=%s\n", title);
1854	}	rc = read(fd, buf, sizeof(buf) - 1);
1855	}	if (rc <= 0) {
1856		fprintf(stderr, "grubby: failed to read %s: %s\n",
1857	int isSuseSystem(void) {	_PATH_MOUNTED, strerror(errno));
1858	const char * path;	close(fd);
1859	const static char default_path[] = "/etc/SuSE-release";	return NULL;
1860		}
1861		close(fd);
1862		buf[rc] = '\0';
1863		chptr = buf;
1864
1865	if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)	char *foundanswer = NULL;
	path = default_path;
1866
1867	if (!access(path, R_OK))	while (chptr && chptr != buf + rc) {
1868	return 1;	devname = chptr;
1869	return 0;
1870	}	/*
1871		* The first column of a mtab entry is the device, but if the
1872		* entry is a special device it won't start with /, so move
1873		* on to the next line.
1874		*/
1875		if (*devname != '/') {
1876		chptr = strchr(chptr, '\n');
1877		if (chptr)
1878		chptr++;
1879		continue;
1880		}
1881
1882	int isSuseGrubConf(const char * path) {	/* Seek to the next space */
1883	FILE * grubConf;	chptr = strchr(chptr, ' ');
1884	char * line = NULL;	if (!chptr) {
1885	size_t len = 0, res = 0;	fprintf(stderr, "grubby: error parsing %s: %s\n",
1886		_PATH_MOUNTED, strerror(errno));
1887		return NULL;
1888		}
1889
1890	grubConf = fopen(path, "r");	/*
1891	if (!grubConf) {	* The second column of a mtab entry is the mount point, we
1892	dbgPrintf("Could not open SuSE configuration file '%s'\n", path);	* are looking for '/' obviously.
1893	return 0;	*/
1894	}	if (*(++chptr) == '/' && *(++chptr) == ' ') {
1895		/* remember the last / entry in mtab */
1896		foundanswer = devname;
1897		}
1898
1899	while ((res = getline(&line, &len, grubConf)) != -1) {	/* Next line */
1900	if (!strncmp(line, "setup", 5)) {	chptr = strchr(chptr, '\n');
1901	fclose(grubConf);	if (chptr)
1902	free(line);	chptr++;
	return 1;
1903	}	}
	}
1904
1905	dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",	/* Return the last / entry found */
1906	path);	if (foundanswer) {
1907		chptr = strchr(foundanswer, ' ');
1908		*chptr = '\0';
1909		return strdup(foundanswer);
1910		}
1911
1912	fclose(grubConf);	return NULL;
	free(line);
	return 0;
1913	}	}
1914
1915	int suseGrubConfGetLba(const char * path, int * lbaPtr) {	void printEntry(struct singleEntry *entry, FILE * f)
1916	FILE * grubConf;	{
1917	char * line = NULL;	int i;
1918	size_t res = 0, len = 0;	struct singleLine *line;
1919
1920	if (!path) return 1;	for (line = entry->lines; line; line = line->next) {
1921	if (!lbaPtr) return 1;	log_message(f, "DBG: %s", line->indent);
1922		for (i = 0; i < line->numElements; i++) {
1923		/* Need to handle this, because we strip the quotes from
1924		* menuentry when read it. */
1925		if (line->type == LT_MENUENTRY && i == 1) {
1926		if (!isquote(*line->elements[i].item))
1927		log_message(f, "\'%s\'",
1928		line->elements[i].item);
1929		else
1930		log_message(f, "%s",
1931		line->elements[i].item);
1932		log_message(f, "%s", line->elements[i].indent);
1933
1934	grubConf = fopen(path, "r");	continue;
1935	if (!grubConf) return 1;	}
1936
1937	while ((res = getline(&line, &len, grubConf)) != -1) {	log_message(f, "%s%s",
1938	if (line[res - 1] == '\n')	line->elements[i].item,
1939	line[res - 1] = '\0';	line->elements[i].indent);
1940	else if (len > res)	}
1941	line[res] = '\0';	log_message(f, "\n");
	else {
	line = realloc(line, res + 1);
	line[res] = '\0';
1942	}	}
1943		}
1944
1945	if (!strncmp(line, "setup", 5)) {	void notSuitablePrintf(struct singleEntry *entry, int okay, const char *fmt,
1946	if (strstr(line, "--force-lba")) {	...)
1947	*lbaPtr = 1;	{
1948	} else {	static int once;
1949	*lbaPtr = 0;	va_list argp, argq;
	}
	dbgPrintf("lba: %i\n", *lbaPtr);
	break;
	}
	}
	free(line);
	fclose(grubConf);
	return 0;
	}
	int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
	FILE * grubConf;
	char * line = NULL;
	size_t res = 0, len = 0;
	char * lastParamPtr = NULL;
	char * secLastParamPtr = NULL;
	char installDeviceNumber = '\0';
	char * bounds = NULL;
	if (!path) return 1;
	if (!devicePtr) return 1;
	grubConf = fopen(path, "r");
	if (!grubConf) return 1;
	while ((res = getline(&line, &len, grubConf)) != -1) {
	if (strncmp(line, "setup", 5))
	continue;
	if (line[res - 1] == '\n')
	line[res - 1] = '\0';
	else if (len > res)
	line[res] = '\0';
	else {
	line = realloc(line, res + 1);
	line[res] = '\0';
	}
1950
1951	lastParamPtr = bounds = line + res;	va_start(argp, fmt);
1952
1953	/* Last parameter in grub may be an optional IMAGE_DEVICE */	va_copy(argq, argp);
1954	while (!isspace(*lastParamPtr))	if (!once) {
1955	lastParamPtr--;	log_time(NULL);
1956	lastParamPtr++;	log_message(NULL, "command line: %s\n", saved_command_line);
1957		}
1958		log_message(NULL, "DBG: Image entry %s: ",
1959		okay ? "succeeded" : "failed");
1960		log_vmessage(NULL, fmt, argq);
1961
1962		printEntry(entry, NULL);
1963		va_end(argq);
1964
1965		if (!debug) {
1966		once = 1;
1967		va_end(argp);
1968		return;
1969		}
1970
1971		if (okay) {
1972		va_end(argp);
1973		return;
1974		}
1975
1976		if (!once)
1977		log_message(stderr, "DBG: command line: %s\n",
1978		saved_command_line);
1979		once = 1;
1980		fprintf(stderr, "DBG: Image entry failed: ");
1981		vfprintf(stderr, fmt, argp);
1982		printEntry(entry, stderr);
1983		va_end(argp);
1984		}
1985
1986	secLastParamPtr = lastParamPtr - 2;	#define beginswith(s, c) ((s) && (s)[0] == (c))
	dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
1987
1988	if (lastParamPtr + 3 > bounds) {	static int endswith(const char *s, char c)
1989	dbgPrintf("lastParamPtr going over boundary");	{
1990	fclose(grubConf);	int slen;
	free(line);
	return 1;
	}
	if (!strncmp(lastParamPtr, "(hd", 3))
	lastParamPtr += 3;
	dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
1991
1992	/*	if (!s || !s[0])
1993	* Second last parameter will decide wether last parameter is	return 0;
1994	* an IMAGE_DEVICE or INSTALL_DEVICE	slen = strlen(s) - 1;
	*/
	while (!isspace(*secLastParamPtr))
	secLastParamPtr--;
	secLastParamPtr++;
	if (secLastParamPtr + 3 > bounds) {
	dbgPrintf("secLastParamPtr going over boundary");
	fclose(grubConf);
	free(line);
	return 1;
	}
	dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
	if (!strncmp(secLastParamPtr, "(hd", 3)) {
	secLastParamPtr += 3;
	dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
	installDeviceNumber = *secLastParamPtr;
	} else {
	installDeviceNumber = *lastParamPtr;
	}
1995
1996	*devicePtr = malloc(6);	return s[slen] == c;
1997	snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);	}
	dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
	fclose(grubConf);
	free(line);
	return 0;
	}
1998
1999	free(line);	int suitableImage(struct singleEntry *entry, const char *bootPrefix,
2000	fclose(grubConf);	int skipRemoved, int flags)
2001	return 1;	{
2002	}	struct singleLine *line;
2003		char *fullName;
2004	int grubGetBootFromDeviceMap(const char * device,	int i;
2005	char ** bootPtr) {	char *dev;
2006	FILE * deviceMap;	char *rootspec;
2007	char * line = NULL;	char *rootdev;
	size_t res = 0, len = 0;
	char * devicePtr;
	char * bounds = NULL;
	const char * path;
	const static char default_path[] = "/boot/grub/device.map";
	if (!device) return 1;
	if (!bootPtr) return 1;
	if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
	path = default_path;
	dbgPrintf("opening grub device.map file from: %s\n", path);
	deviceMap = fopen(path, "r");
	if (!deviceMap)
	return 1;
2008
2009	while ((res = getline(&line, &len, deviceMap)) != -1) {	if (skipRemoved && entry->skip) {
2010	if (!strncmp(line, "#", 1))	notSuitablePrintf(entry, 0, "marked to skip\n");
2011	continue;	return 0;
2012		}
2013	if (line[res - 1] == '\n')
2014	line[res - 1] = '\0';	line =
2015	else if (len > res)	getLineByType(LT_KERNEL | LT_HYPER | LT_KERNEL_EFI | LT_KERNEL_16,
2016	line[res] = '\0';	entry->lines);
2017	else {	if (!line) {
2018	line = realloc(line, res + 1);	notSuitablePrintf(entry, 0, "no line found\n");
2019	line[res] = '\0';	return 0;
2020		}
2021		if (line->numElements < 2) {
2022		notSuitablePrintf(entry, 0, "line has only %d elements\n",
2023		line->numElements);
2024		return 0;
2025	}	}
2026
2027	devicePtr = line;	if (flags & GRUBBY_BADIMAGE_OKAY) {
2028	bounds = line + res;	notSuitablePrintf(entry, 1, "\n");
2029		return 1;
2030		}
2031
2032	while ((isspace(*line) && ((devicePtr + 1) <= bounds)))	fullName = alloca(strlen(bootPrefix) +
2033	devicePtr++;	strlen(line->elements[1].item) + 1);
2034	dbgPrintf("device: %s\n", devicePtr);	rootspec = getRootSpecifier(line->elements[1].item);
2035		int rootspec_offset = rootspec ? strlen(rootspec) : 0;
2036		int hasslash = endswith(bootPrefix, '/') ||
2037		beginswith(line->elements[1].item + rootspec_offset, '/');
2038		sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
2039		line->elements[1].item + rootspec_offset);
2040		if (access(fullName, R_OK)) {
2041		notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
2042		return 0;
2043		}
2044		for (i = 2; i < line->numElements; i++)
2045		if (!strncasecmp(line->elements[i].item, "root=", 5))
2046		break;
2047		if (i < line->numElements) {
2048		dev = line->elements[i].item + 5;
2049		} else {
2050		/* look for a lilo style LT_ROOT line */
2051		line = getLineByType(LT_ROOT, entry->lines);
2052
2053	if (!strncmp(devicePtr, device, strlen(device))) {	if (line && line->numElements >= 2) {
2054	devicePtr += strlen(device);	dev = line->elements[1].item;
2055	while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))	} else {
2056	devicePtr++;	/* didn't succeed in finding a LT_ROOT, let's try
2057		* LT_KERNELARGS.  grub+multiboot uses LT_MBMODULE
2058		* for the args, so check that too.
2059		*/
2060		line =
2061		getLineByType(LT_KERNELARGS | LT_MBMODULE,
2062		entry->lines);
2063
2064		/* failed to find one */
2065		if (!line) {
2066		notSuitablePrintf(entry, 0, "no line found\n");
2067		return 0;
2068		}
2069
2070	*bootPtr = strdup(devicePtr);	for (i = 1; i < line->numElements; i++)
2071	break;	if (!strncasecmp
2072		(line->elements[i].item, "root=", 5))
2073		break;
2074		if (i < line->numElements)
2075		dev = line->elements[i].item + 5;
2076		else {
2077		notSuitablePrintf(entry, 0,
2078		"no root= entry found\n");
2079		/* it failed too...  can't find root= */
2080		return 0;
2081		}
2082		}
2083	}	}
	}
2084
2085	free(line);	dev = getpathbyspec(dev);
2086	fclose(deviceMap);	if (!getpathbyspec(dev)) {
2087	return 0;	notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n",
2088	}	dev);
2089		return 0;
2090		} else
2091		dev = getpathbyspec(dev);
2092
2093		rootdev = findDiskForRoot();
2094		if (!rootdev) {
2095		notSuitablePrintf(entry, 0, "can't find root device\n");
2096		return 0;
2097		}
2098
2099	int suseGrubConfGetBoot(const char * path, char ** bootPtr) {	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
2100	char * grubDevice;	notSuitablePrintf(entry, 0,
2101		"uuid missing: rootdev %s, dev %s\n",
2102		getuuidbydev(rootdev), getuuidbydev(dev));
2103		free(rootdev);
2104		return 0;
2105		}
2106
2107	if (suseGrubConfGetInstallDevice(path, &grubDevice))	if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
2108	dbgPrintf("error looking for grub installation device\n");	notSuitablePrintf(entry, 0,
2109	else	"uuid mismatch: rootdev %s, dev %s\n",
2110	dbgPrintf("grubby installation device: %s\n", grubDevice);	getuuidbydev(rootdev), getuuidbydev(dev));
2111		free(rootdev);
2112		return 0;
2113		}
2114
2115	if (grubGetBootFromDeviceMap(grubDevice, bootPtr))	free(rootdev);
2116	dbgPrintf("error looking for grub boot device\n");	notSuitablePrintf(entry, 1, "\n");
	else
	dbgPrintf("grubby boot device: %s\n", *bootPtr);
2117
2118	free(grubDevice);	return 1;
	return 0;
2119	}	}
2120
2121	int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {	/* returns the first match on or after the one pointed to by index (if index
2122	/*	is not NULL) which is not marked as skip */
2123	* This SuSE grub configuration file at this location is not your average	struct singleEntry *findEntryByPath(struct grubConfig *config,
2124	* grub configuration file, but instead the grub commands used to setup	const char *kernel, const char *prefix,
2125	* grub on that system.	int *index)
2126	*/	{
2127	const char * path;	struct singleEntry *entry = NULL;
2128	const static char default_path[] = "/etc/grub.conf";	struct singleLine *line;
2129		int i;
2130		char *chptr;
2131		char *rootspec = NULL;
2132		enum lineType_e checkType = LT_KERNEL;
2133
2134		if (isdigit(*kernel)) {
2135		int *indexVars = alloca(sizeof(*indexVars) * strlen(kernel));
2136
2137		i = 0;
2138		indexVars[i] = strtol(kernel, &chptr, 10);
2139		while (*chptr == ',') {
2140		i++;
2141		kernel = chptr + 1;
2142		indexVars[i] = strtol(kernel, &chptr, 10);
2143		}
2144
2145		if (*chptr) {
2146		/* can't parse it, bail */
2147		return NULL;
2148		}
2149
2150	if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)	indexVars[i + 1] = -1;
	path = default_path;
2151
2152	if (!isSuseGrubConf(path)) return 1;	i = 0;
2153		if (index) {
2154		while (i < *index) {
2155		i++;
2156		if (indexVars[i] == -1)
2157		return NULL;
2158		}
2159		}
2160
2161	if (lbaPtr) {	entry = findEntryByIndex(config, indexVars[i]);
2162	*lbaPtr = 0;	if (!entry)
2163	if (suseGrubConfGetLba(path, lbaPtr))	return NULL;
2164	return 1;
2165	}	line =
2166		getLineByType(LT_KERNEL | LT_HYPER | LT_KERNEL_EFI |
2167		LT_KERNEL_16, entry->lines);
2168		if (!line)
2169		return NULL;
2170
2171	if (bootPtr) {	if (index)
2172	*bootPtr = NULL;	*index = indexVars[i];
2173	suseGrubConfGetBoot(path, bootPtr);	return entry;
2174	}	}
2175
2176	return 0;	if (!strcmp(kernel, "DEFAULT")) {
2177	}	if (index && *index > config->defaultImage) {
2178		entry = NULL;
2179		} else {
2180		entry = findEntryByIndex(config, config->defaultImage);
2181		if (entry && entry->skip)
2182		entry = NULL;
2183		else if (index)
2184		*index = config->defaultImage;
2185		}
2186		} else if (!strcmp(kernel, "ALL")) {
2187		if (index)
2188		i = *index;
2189		else
2190		i = 0;
2191
2192	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	while ((entry = findEntryByIndex(config, i))) {
2193	FILE * in;	if (!entry->skip)
2194	char buf[1024];	break;
2195	char * chptr;	i++;
2196	char * start;	}
	char * param;
2197
2198	in = fopen("/etc/conf.d/grub", "r");	if (entry && index)
2199	if (!in) return 1;	*index = i;
2200		} else {
2201		if (index)
2202		i = *index;
2203		else
2204		i = 0;
2205
2206	if (lbaPtr) *lbaPtr = 0;	if (!strncmp(kernel, "TITLE=", 6)) {
2207	if (bootPtr) *bootPtr = NULL;	prefix = "";
2208		checkType = LT_TITLE | LT_MENUENTRY;
2209		kernel += 6;
2210		}
2211
2212	while (fgets(buf, sizeof(buf), in)) {	for (entry = findEntryByIndex(config, i); entry;
2213	start = buf;	entry = entry->next, i++) {
2214	while (isspace(*start)) start++;	if (entry->skip)
2215	if (*start == '#') continue;	continue;
2216
2217		dbgPrintf("findEntryByPath looking for %d %s in %p\n",
2218		checkType, kernel, entry);
2219
2220		/* check all the lines matching checkType */
2221		for (line = entry->lines; line; line = line->next) {
2222		enum lineType_e ct = checkType;
2223		if (entry->multiboot && checkType == LT_KERNEL)
2224		ct = LT_KERNEL | LT_KERNEL_EFI |
2225		LT_MBMODULE | LT_HYPER |
2226		LT_KERNEL_16;
2227		else if (checkType & LT_KERNEL)
2228		ct = checkType | LT_KERNEL_EFI |
2229		LT_KERNEL_16;
2230		line = getLineByType(ct, line);
2231		if (!line)
2232		break; /* not found in this entry */
2233
2234		if (line && line->type != LT_MENUENTRY &&
2235		line->numElements >= 2) {
2236		rootspec =
2237		getRootSpecifier(line->elements[1].
2238		item);
2239		if (!strcmp
2240		(line->elements[1].item +
2241		((rootspec !=
2242		NULL) ? strlen(rootspec) : 0),
2243		kernel + strlen(prefix)))
2244		break;
2245		}
2246		if (line->type == LT_MENUENTRY &&
2247		!strcmp(line->elements[1].item, kernel))
2248		break;
2249		}
2250
2251	chptr = strchr(start, '=');	/* make sure this entry has a kernel identifier; this skips
2252	if (!chptr) continue;	* non-Linux boot entries (could find netbsd etc, though, which is
2253	chptr--;	* unfortunate)
2254	while (*chptr && isspace(*chptr)) chptr--;	*/
2255	chptr++;	if (line
2256	*chptr = '\0';	&& getLineByType(LT_KERNEL | LT_HYPER |
2257		LT_KERNEL_EFI | LT_KERNEL_16,
2258		entry->lines))
2259		break; /* found 'im! */
2260		}
2261
2262	param = chptr + 1;	if (index)
2263	while (*param && isspace(*param)) param++;	*index = i;
	if (*param == '=') {
	param++;
	while (*param && isspace(*param)) param++;
2264	}	}
2265
2266	chptr = param;	return entry;
2267	while (*chptr && !isspace(*chptr)) chptr++;	}
	*chptr = '\0';
2268
2269	if (!strcmp(start, "forcelba") && !strcmp(param, "1") && lbaPtr)	struct singleEntry *findEntryByTitle(struct grubConfig *cfg, char *title,
2270	*lbaPtr = 1;	int *index)
2271	else if (!strcmp(start, "boot") && bootPtr)	{
2272	*bootPtr = strdup(param);	struct singleEntry *entry;
2273	}	struct singleLine *line;
2274		int i;
2275		char *newtitle;
2276
2277		for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2278		if (index && i < *index)
2279		continue;
2280		line = getLineByType(LT_TITLE, entry->lines);
2281		if (!line)
2282		line = getLineByType(LT_MENUENTRY, entry->lines);
2283		if (!line)
2284		continue;
2285		newtitle = grub2ExtractTitle(line);
2286		if (!newtitle)
2287		continue;
2288		if (!strcmp(title, newtitle))
2289		break;
2290		}
2291
2292	fclose(in);	if (!entry)
2293		return NULL;
2294
2295	return 0;	if (index)
2296		*index = i;
2297		return entry;
2298	}	}
2299
2300	void dumpSysconfigGrub(void) {	struct singleEntry *findEntryByIndex(struct grubConfig *cfg, int index)
2301	char * boot = NULL;	{
2302	int lba;	struct singleEntry *entry;
2303
2304	if (isSuseSystem()) {	entry = cfg->entries;
2305	if (parseSuseGrubConf(&lba, &boot)) {	while (index && entry) {
2306	free(boot);	entry = entry->next;
2307	return;	index--;
	}
	} else {
	if (parseSysconfigGrub(&lba, &boot)) {
	free(boot);
	return;
2308	}	}
	}
2309
2310	if (lba) printf("lba\n");	return entry;
	if (boot) {
	printf("boot=%s\n", boot);
	free(boot);
	}
2311	}	}
2312
2313	int displayInfo(struct grubConfig * config, char * kernel,	/* Find a good template to use for the new kernel. An entry is
2314	const char * prefix) {	* good if the kernel and mkinitrd exist (even if the entry
2315	int i = 0;	* is going to be removed). Try and use the default entry, but
2316	struct singleEntry * entry;	* if that doesn't work just take the first. If we can't find one,
2317	struct singleLine * line;	* bail. */
2318		struct singleEntry *findTemplate(struct grubConfig *cfg, const char *prefix,
2319		int *indexPtr, int skipRemoved, int flags)
2320		{
2321		struct singleEntry *entry, *entry2;
2322		int index;
2323
2324		if (cfg->cfi->defaultIsSaved) {
2325		if (cfg->cfi->getEnv) {
2326		char *defTitle =
2327		cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2328		if (defTitle) {
2329		int index = 0;
2330		if (isnumber(defTitle)) {
2331		index = atoi(defTitle);
2332		entry = findEntryByIndex(cfg, index);
2333		} else {
2334		entry =
2335		findEntryByTitle(cfg, defTitle,
2336		&index);
2337		}
2338		if (entry
2339		&& suitableImage(entry, prefix, skipRemoved,
2340		flags)) {
2341		cfg->defaultImage = index;
2342		if (indexPtr)
2343		*indexPtr = index;
2344		return entry;
2345		}
2346		}
2347		}
2348		} else if (cfg->defaultImage > -1) {
2349		entry = findEntryByIndex(cfg, cfg->defaultImage);
2350		if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2351		if (indexPtr)
2352		*indexPtr = cfg->defaultImage;
2353		return entry;
2354		}
2355		}
2356
2357	entry = findEntryByPath(config, kernel, prefix, &i);	index = 0;
2358	if (!entry) {	while ((entry = findEntryByIndex(cfg, index))) {
2359	fprintf(stderr, _("grubby: kernel not found\n"));	if (suitableImage(entry, prefix, skipRemoved, flags)) {
2360	return 1;	int j;
2361	}	for (j = 0; j < index; j++) {
2362		entry2 = findEntryByIndex(cfg, j);
2363		if (entry2->skip)
2364		index--;
2365		}
2366		if (indexPtr)
2367		*indexPtr = index;
2368
2369	/* this is a horrible hack to support /etc/conf.d/grub; there must	return entry;
2370	be a better way */	}
	if (config->cfi == &grubConfigType) {
	dumpSysconfigGrub();
	} else {
	line = getLineByType(LT_BOOT, config->theLines);
	if (line && line->numElements >= 1) {
	printf("boot=%s\n", line->elements[1].item);
	}
	line = getLineByType(LT_LBA, config->theLines);
	if (line) printf("lba\n");
	}
2371
2372	displayEntry(entry, prefix, i);	index++;
2373		}
2374
2375	i++;	fprintf(stderr,
2376	while ((entry = findEntryByPath(config, kernel, prefix, &i))) {	_("grubby fatal error: unable to find a suitable template\n"));
	displayEntry(entry, prefix, i);
	i++;
	}
2377
2378	return 0;	return NULL;
2379	}	}
2380
2381	struct singleLine * addLineTmpl(struct singleEntry * entry,	char *findBootPrefix(void)
	struct singleLine * tmplLine,
	struct singleLine * prevLine,
	const char * val,
	struct configFileInfo * cfi)
2382	{	{
2383	struct singleLine * newLine = lineDup(tmplLine);	struct stat sb, sb2;
2384
2385	if (isEfi && cfi == &grub2ConfigType) {	stat("/", &sb);
2386	enum lineType_e old = newLine->type;	#ifdef __ia64__
2387	newLine->type = preferredLineType(newLine->type, cfi);	stat("/boot/efi/EFI/redhat/", &sb2);
2388	if (old != newLine->type)	#else
2389	newLine->elements[0].item = getKeyByType(newLine->type, cfi);	stat("/boot", &sb2);
2390	}	#endif
2391
2392	if (val) {	if (sb.st_dev == sb2.st_dev)
2393	/* override the inherited value with our own.	return strdup("");
	* This is a little weak because it only applies to elements[1]
	*/
	if (newLine->numElements > 1)
	removeElement(newLine, 1);
	insertElement(newLine, val, 1, cfi);
	/* but try to keep the rootspec from the template... sigh */
	if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI)) {
	char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
	if (rootspec != NULL) {
	free(newLine->elements[1].item);
	newLine->elements[1].item =
	sdupprintf("%s%s", rootspec, val);
	}
	}
	}
	dbgPrintf("addLineTmpl(%s)\n", newLine->numElements ?
	newLine->elements[0].item : "");
	if (!entry->lines) {
	/* first one on the list */
	entry->lines = newLine;
	} else if (prevLine) {
	/* add after prevLine */
	newLine->next = prevLine->next;
	prevLine->next = newLine;
	}
2394
2395	return newLine;	#ifdef __ia64__
2396		return strdup("/boot/efi/EFI/redhat/");
2397		#else
2398		return strdup("/boot");
2399		#endif
2400	}	}
2401
2402	/* val may be NULL */	void markRemovedImage(struct grubConfig *cfg, const char *image,
2403	struct singleLine *  addLine(struct singleEntry * entry,	const char *prefix)
2404	struct configFileInfo * cfi,	{
2405	enum lineType_e type, char * defaultIndent,	struct singleEntry *entry;
	const char * val) {
	struct singleLine * line, * prev;
	struct keywordTypes * kw;
	struct singleLine tmpl;
	/* NB: This function shouldn't allocate items on the heap, rather on the
	* stack since it calls addLineTmpl which will make copies.
	*/
	if (type == LT_TITLE && cfi->titleBracketed) {
	/* we're doing a bracketed title (zipl) */
	tmpl.type = type;
	tmpl.numElements = 1;
	tmpl.elements = alloca(sizeof(*tmpl.elements));
	tmpl.elements[0].item = alloca(strlen(val)+3);
	sprintf(tmpl.elements[0].item, "[%s]", val);
	tmpl.elements[0].indent = "";
	val = NULL;
	} else if (type == LT_MENUENTRY) {
	char *lineend = "--class gnu-linux --class gnu --class os {";
	if (!val) {
	fprintf(stderr, "Line type LT_MENUENTRY requires a value\n");
	abort();
	}
	kw = getKeywordByType(type, cfi);
	if (!kw) {
	fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
	abort();
	}
	tmpl.indent = "";
	tmpl.type = type;
	tmpl.numElements = 3;
	tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
	tmpl.elements[0].item = kw->key;
	tmpl.elements[0].indent = alloca(2);
	sprintf(tmpl.elements[0].indent, "%c", kw->nextChar);
	tmpl.elements[1].item = (char *)val;
	tmpl.elements[1].indent = alloca(2);
	sprintf(tmpl.elements[1].indent, "%c", kw->nextChar);
	tmpl.elements[2].item = alloca(strlen(lineend)+1);
	strcpy(tmpl.elements[2].item, lineend);
	tmpl.elements[2].indent = "";
	} else {
	kw = getKeywordByType(type, cfi);
	if (!kw) {
	fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
	abort();
	}
	tmpl.type = type;
	tmpl.numElements = val ? 2 : 1;
	tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
	tmpl.elements[0].item = kw->key;
	tmpl.elements[0].indent = alloca(2);
	sprintf(tmpl.elements[0].indent, "%c", kw->nextChar);
	if (val) {
	tmpl.elements[1].item = (char *)val;
	tmpl.elements[1].indent = "";
	}
	}
2406
2407	/* The last non-empty line gives us the indention to us and the line	if (!image)
2408	to insert after. Note that comments are considered empty lines, which	return;
	may not be ideal? If there are no lines or we are looking at the
	first line, we use defaultIndent (the first line is normally indented
	differently from the rest) */
	for (line = entry->lines, prev = NULL; line; line = line->next) {
	if (line->numElements) prev = line;
	/* fall back on the last line if prev isn't otherwise set */
	if (!line->next && !prev) prev = line;
	}
	struct singleLine *menuEntry;
	menuEntry = getLineByType(LT_MENUENTRY, entry->lines);
	if (tmpl.type == LT_ENTRY_END) {
	if (menuEntry)
	tmpl.indent = menuEntry->indent;
	else
	tmpl.indent = defaultIndent ?: "";
	} else if (tmpl.type != LT_MENUENTRY) {
	if (menuEntry)
	tmpl.indent = "\t";
	else if (prev == entry->lines)
	tmpl.indent = defaultIndent ?: "";
	else
	tmpl.indent = prev->indent;
	}
2409
2410	return addLineTmpl(entry, &tmpl, prev, val, cfi);	/* check and see if we're removing the default image */
2411		if (isdigit(*image)) {
2412		entry = findEntryByPath(cfg, image, prefix, NULL);
2413		if (entry)
2414		entry->skip = 1;
2415		return;
2416		}
2417
2418		while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2419		entry->skip = 1;
2420	}	}
2421
2422	void removeLine(struct singleEntry * entry, struct singleLine * line) {	void setDefaultImage(struct grubConfig *config, int hasNew,
2423	struct singleLine * prev;	const char *defaultKernelPath, int newIsDefault,
2424	int i;	const char *prefix, int flags, int index)
2425		{
2426	for (i = 0; i < line->numElements; i++) {	struct singleEntry *entry, *entry2, *newDefault;
2427	free(line->elements[i].item);	int i, j;
	free(line->elements[i].indent);
	}
	free(line->elements);
	free(line->indent);
	if (line == entry->lines) {
	entry->lines = line->next;
	} else {
	prev = entry->lines;
	while (prev->next != line) prev = prev->next;
	prev->next = line->next;
	}
	free(line);
	}
	static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
	{
	struct singleLine newLine = {
	.indent = tmplLine->indent,
	.type = tmplLine->type,
	.next = tmplLine->next,
	};
	int firstQuotedItem = -1;
	int quoteLen = 0;
	int j;
	int element = 0;
	char *c;
	c = malloc(strlen(tmplLine->elements[0].item) + 1);
	strcpy(c, tmplLine->elements[0].item);
	insertElement(&newLine, c, element++, cfi);
	free(c);
	c = NULL;
	for (j = 1; j < tmplLine->numElements; j++) {
	if (firstQuotedItem == -1) {
	quoteLen += strlen(tmplLine->elements[j].item);
	if (isquote(tmplLine->elements[j].item[0])) {
	firstQuotedItem = j;
	quoteLen += strlen(tmplLine->elements[j].indent);
	} else {
	c = malloc(quoteLen + 1);
	strcpy(c, tmplLine->elements[j].item);
	insertElement(&newLine, c, element++, cfi);
	free(c);
	quoteLen = 0;
	}
	} else {
	int itemlen = strlen(tmplLine->elements[j].item);
	quoteLen += itemlen;
	quoteLen += strlen(tmplLine->elements[j].indent);
	if (isquote(tmplLine->elements[j].item[itemlen - 1])) {
	c = malloc(quoteLen + 1);
	c[0] = '\0';
	for (int i = firstQuotedItem; i < j+1; i++) {
	strcat(c, tmplLine->elements[i].item);
	strcat(c, tmplLine->elements[i].indent);
	}
	insertElement(&newLine, c, element++, cfi);
	free(c);
	firstQuotedItem = -1;
	quoteLen = 0;
	}
	}
	}
	while (tmplLine->numElements)
	removeElement(tmplLine, 0);
	if (tmplLine->elements)
	free(tmplLine->elements);
	tmplLine->numElements = newLine.numElements;
	tmplLine->elements = newLine.elements;
	}
	static void insertElement(struct singleLine * line,
	const char * item, int insertHere,
	struct configFileInfo * cfi)
	{
	struct keywordTypes * kw;
	char indent[2] = "";
	/* sanity check */
	if (insertHere > line->numElements) {
	dbgPrintf("insertElement() adjusting insertHere from %d to %d\n",
	insertHere, line->numElements);
	insertHere = line->numElements;
	}
	line->elements = realloc(line->elements, (line->numElements + 1) *
	sizeof(*line->elements));
	memmove(&line->elements[insertHere+1],
	&line->elements[insertHere],
	(line->numElements - insertHere) *
	sizeof(*line->elements));
	line->elements[insertHere].item = strdup(item);
	kw = getKeywordByType(line->type, cfi);
	if (line->numElements == 0) {
	indent[0] = '\0';
	} else if (insertHere == 0) {
	indent[0] = kw->nextChar;
	} else if (kw->separatorChar != '\0') {
	indent[0] = kw->separatorChar;
	} else {
	indent[0] = ' ';
	}
	if (insertHere > 0 && line->elements[insertHere-1].indent[0] == '\0') {
	/* move the end-of-line forward */
	line->elements[insertHere].indent =
	line->elements[insertHere-1].indent;
	line->elements[insertHere-1].indent = strdup(indent);
	} else {
	line->elements[insertHere].indent = strdup(indent);
	}
	line->numElements++;
	dbgPrintf("insertElement(%s, '%s%s', %d)\n",
	line->elements[0].item,
	line->elements[insertHere].item,
	line->elements[insertHere].indent,
	insertHere);
	}
	static void removeElement(struct singleLine * line, int removeHere) {
	int i;
	/* sanity check */
	if (removeHere >= line->numElements) return;
	dbgPrintf("removeElement(%s, %d:%s)\n", line->elements[0].item,
	removeHere, line->elements[removeHere].item);
	free(line->elements[removeHere].item);
	if (removeHere > 1) {
	/* previous argument gets this argument's post-indentation */
	free(line->elements[removeHere-1].indent);
	line->elements[removeHere-1].indent =
	line->elements[removeHere].indent;
	} else {
	free(line->elements[removeHere].indent);
	}
	/* now collapse the array, but don't bother to realloc smaller */
	for (i = removeHere; i < line->numElements - 1; i++)
	line->elements[i] = line->elements[i + 1];
	line->numElements--;
	}
	int argMatch(const char * one, const char * two) {
	char * first, * second;
	char * chptr;
	first = strcpy(alloca(strlen(one) + 1), one);
	second = strcpy(alloca(strlen(two) + 1), two);
	chptr = strchr(first, '=');
	if (chptr) *chptr = '\0';
	chptr = strchr(second, '=');
	if (chptr) *chptr = '\0';
	return strcmp(first, second);
	}
	int updateActualImage(struct grubConfig * cfg, const char * image,
	const char * prefix, const char * addArgs,
	const char * removeArgs, int multibootArgs) {
	struct singleEntry * entry;
	struct singleLine * line, * rootLine;
	int index = 0;
	int i, k;
	const char ** newArgs, ** oldArgs;
	const char ** arg;
	int useKernelArgs, useRoot;
	int firstElement;
	int *usedElements;
	int doreplace;
	if (!image) return 0;
	if (!addArgs) {
	newArgs = malloc(sizeof(*newArgs));
	*newArgs = NULL;
	} else {
	if (poptParseArgvString(addArgs, NULL, &newArgs)) {
	fprintf(stderr,
	_("grubby: error separating arguments '%s'\n"), addArgs);
	return 1;
	}
	}
	if (!removeArgs) {
	oldArgs = malloc(sizeof(*oldArgs));
	*oldArgs = NULL;
	} else {
	if (poptParseArgvString(removeArgs, NULL, &oldArgs)) {
	fprintf(stderr,
	_("grubby: error separating arguments '%s'\n"), removeArgs);
	free(newArgs);
	return 1;
	}
	}
	useKernelArgs = (getKeywordByType(LT_KERNELARGS, cfg->cfi)
	&& (!multibootArgs || cfg->cfi->mbConcatArgs));
	useRoot = (getKeywordByType(LT_ROOT, cfg->cfi)
	&& !multibootArgs);
	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
	if (multibootArgs && !entry->multiboot)
	continue;
	/* Determine where to put the args.  If this config supports
	* LT_KERNELARGS, use that.  Otherwise use
	* LT_HYPER/LT_KERNEL/LT_MBMODULE lines.
	*/
	if (useKernelArgs) {
	line = getLineByType(LT_KERNELARGS, entry->lines);
	if (!line) {
	/* no LT_KERNELARGS, need to add it */
	line = addLine(entry, cfg->cfi, LT_KERNELARGS,
	cfg->secondaryIndent, NULL);
	}
	firstElement = 1;
	} else if (multibootArgs) {
	line = getLineByType(LT_HYPER, entry->lines);
	if (!line) {
	/* a multiboot entry without LT_HYPER? */
	continue;
	}
	firstElement = 2;
2428
2429	} else {	if (newIsDefault) {
2430	line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI, entry->lines);	config->defaultImage = 0;
2431	if (!line) {	return;
2432	/* no LT_KERNEL or LT_MBMODULE in this entry? */	} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2433	continue;	if (findEntryByIndex(config, index))
2434	}	config->defaultImage = index;
2435	firstElement = 2;	else
2436		config->defaultImage = -1;
2437		return;
2438		} else if (defaultKernelPath) {
2439		i = 0;
2440		if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
2441		config->defaultImage = i;
2442		} else {
2443		config->defaultImage = -1;
2444		return;
2445		}
2446	}	}
2447
2448	/* handle the elilo case which does:	/* defaultImage now points to what we'd like to use, but before any
2449	*   append="hypervisor args -- kernel args"	* order changes */
2450	*/	if ((config->defaultImage == DEFAULT_SAVED) ||
2451	if (entry->multiboot && cfg->cfi->mbConcatArgs) {	(config->defaultImage == DEFAULT_SAVED_GRUB2))
2452	/* this is a multiboot entry, make sure there's	/* default is set to saved, we don't want to change it */
2453	* -- on the args line	return;
	*/
	for (i = firstElement; i < line->numElements; i++) {
	if (!strcmp(line->elements[i].item, "--"))
	break;
	}
	if (i == line->numElements) {
	/* assume all existing args are kernel args,
	* prepend -- to make it official
	*/
	insertElement(line, "--", firstElement, cfg->cfi);
	i = firstElement;
	}
	if (!multibootArgs) {
	/* kernel args start after the -- */
	firstElement = i + 1;
	}
	} else if (cfg->cfi->mbConcatArgs) {
	/* this is a non-multiboot entry, remove hyper args */
	for (i = firstElement; i < line->numElements; i++) {
	if (!strcmp(line->elements[i].item, "--"))
	break;
	}
	if (i < line->numElements) {
	/* remove args up to -- */
	while (strcmp(line->elements[firstElement].item, "--"))
	removeElement(line, firstElement);
	/* remove -- */
	removeElement(line, firstElement);
	}
	}
	usedElements = calloc(line->numElements, sizeof(*usedElements));
	for (k = 0, arg = newArgs; *arg; arg++, k++) {
	doreplace = 1;
	for (i = firstElement; i < line->numElements; i++) {
	if (multibootArgs && cfg->cfi->mbConcatArgs &&
	!strcmp(line->elements[i].item, "--"))
	{
	/* reached the end of hyper args, insert here */
	doreplace = 0;
	break;
	}
	if (usedElements[i])
	continue;
	if (!argMatch(line->elements[i].item, *arg)) {
	usedElements[i]=1;
	break;
	}
	}
2454
2455	if (i < line->numElements && doreplace) {	if (config->defaultImage > -1)
2456	/* direct replacement */	entry = findEntryByIndex(config, config->defaultImage);
2457	free(line->elements[i].item);	else
2458	line->elements[i].item = strdup(*arg);	entry = NULL;
2459
2460	} else if (useRoot && !strncmp(*arg, "root=/dev/", 10)) {	if (entry && !entry->skip) {
2461	/* root= replacement */	/* we can preserve the default */
2462	rootLine = getLineByType(LT_ROOT, entry->lines);	if (hasNew)
2463	if (rootLine) {	config->defaultImage++;
2464	free(rootLine->elements[1].item);
2465	rootLine->elements[1].item = strdup(*arg + 5);	/* count the number of entries erased before this one */
2466	} else {	for (j = 0; j < config->defaultImage; j++) {
2467	rootLine = addLine(entry, cfg->cfi, LT_ROOT,	entry2 = findEntryByIndex(config, j);
2468	cfg->secondaryIndent, *arg + 5);	if (entry2->skip)
2469		config->defaultImage--;
2470	}	}
2471	}	} else if (hasNew) {
2472		config->defaultImage = 0;
2473		} else {
2474		/* Either we just erased the default (or the default line was
2475		* bad to begin with) and didn't put a new one in. We'll use
2476		* the first valid image. */
2477		newDefault =
2478		findTemplate(config, prefix, &config->defaultImage, 1,
2479		flags);
2480		if (!newDefault)
2481		config->defaultImage = -1;
2482		}
2483		}
2484
2485	else {	void setFallbackImage(struct grubConfig *config, int hasNew)
2486	/* insert/append */	{
2487	insertElement(line, *arg, i, cfg->cfi);	struct singleEntry *entry, *entry2;
2488	usedElements = realloc(usedElements, line->numElements *	int j;
2489	sizeof(*usedElements));
2490	memmove(&usedElements[i + 1], &usedElements[i],	if (config->fallbackImage == -1)
2491	line->numElements - i - 1);	return;
2492	usedElements[i] = 1;
2493		entry = findEntryByIndex(config, config->fallbackImage);
2494	/* if we updated a root= here even though there is a	if (!entry || entry->skip) {
2495	LT_ROOT available we need to remove the LT_ROOT entry	config->fallbackImage = -1;
2496	(this will happen if we switch from a device to a label) */	return;
	if (useRoot && !strncmp(*arg, "root=", 5)) {
	rootLine = getLineByType(LT_ROOT, entry->lines);
	if (rootLine)
	removeLine(entry, rootLine);
	}
	}
	}
	free(usedElements);
	for (arg = oldArgs; *arg; arg++) {
	for (i = firstElement; i < line->numElements; i++) {
	if (multibootArgs && cfg->cfi->mbConcatArgs &&
	!strcmp(line->elements[i].item, "--"))
	/* reached the end of hyper args, stop here */
	break;
	if (!argMatch(line->elements[i].item, *arg)) {
	removeElement(line, i);
	break;
	}
	}
	/* handle removing LT_ROOT line too */
	if (useRoot && !strncmp(*arg, "root=", 5)) {
	rootLine = getLineByType(LT_ROOT, entry->lines);
	if (rootLine)
	removeLine(entry, rootLine);
	}
	}
	if (line->numElements == 1) {
	/* don't need the line at all (note it has to be a
	LT_KERNELARGS for this to happen */
	removeLine(entry, line);
	}
	}
	free(newArgs);
	free(oldArgs);
	return 0;
	}
	int updateImage(struct grubConfig * cfg, const char * image,
	const char * prefix, const char * addArgs,
	const char * removeArgs,
	const char * addMBArgs, const char * removeMBArgs) {
	int rc = 0;
	if (!image) return rc;
	/* update the main args first... */
	if (addArgs || removeArgs)
	rc = updateActualImage(cfg, image, prefix, addArgs, removeArgs, 0);
	if (rc) return rc;
	/* and now any multiboot args */
	if (addMBArgs || removeMBArgs)
	rc = updateActualImage(cfg, image, prefix, addMBArgs, removeMBArgs, 1);
	return rc;
	}
	int updateInitrd(struct grubConfig * cfg, const char * image,
	const char * prefix, const char * initrd) {
	struct singleEntry * entry;
	struct singleLine * line, * kernelLine, *endLine = NULL;
	int index = 0;
	if (!image) return 0;
	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
	kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);
	if (!kernelLine) continue;
	line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);
	if (line)
	removeLine(entry, line);
	if (prefix) {
	int prefixLen = strlen(prefix);
	if (!strncmp(initrd, prefix, prefixLen))
	initrd += prefixLen;
	}
	endLine = getLineByType(LT_ENTRY_END, entry->lines);
	if (endLine)
	removeLine(entry, endLine);
	line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),
	kernelLine->indent, initrd);
	if (!line)
	return 1;
	if (endLine) {
	line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
	if (!line)
	return 1;
2497	}	}
2498
2499	break;	if (hasNew)
2500	}	config->fallbackImage++;
2501
2502	return 0;	/* count the number of entries erased before this one */
2503		for (j = 0; j < config->fallbackImage; j++) {
2504		entry2 = findEntryByIndex(config, j);
2505		if (entry2->skip)
2506		config->fallbackImage--;
2507		}
2508	}	}
2509
2510	int checkDeviceBootloader(const char * device, const unsigned char * boot) {	void displayEntry(struct singleEntry *entry, const char *prefix, int index)
2511	int fd;	{
2512	unsigned char bootSect[512];	struct singleLine *line;
2513	int offset;	char *root = NULL;
2514		int i;
2515		int j;
2516
2517	fd = open(device, O_RDONLY);	printf("index=%d\n", index);
	if (fd < 0) {
	fprintf(stderr, _("grubby: unable to open %s: %s\n"),
	device, strerror(errno));
	return 1;
	}
2518
2519	if (read(fd, bootSect, 512) != 512) {	line =
2520	fprintf(stderr, _("grubby: unable to read %s: %s\n"),	getLineByType(LT_KERNEL | LT_HYPER | LT_KERNEL_EFI | LT_KERNEL_16,
2521	device, strerror(errno));	entry->lines);
2522	return 1;	if (!line) {
2523	}	printf("non linux entry\n");
2524	close(fd);	return;
2525		}
2526
2527	/* first three bytes should match, a jmp short should be in there */	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2528	if (memcmp(boot, bootSect, 3))	printf("kernel=%s\n", line->elements[1].item);
2529		else
2530		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2531
2532		if (line->numElements >= 3) {
2533		printf("args=\"");
2534		i = 2;
2535		while (i < line->numElements) {
2536		if (!strncmp(line->elements[i].item, "root=", 5)) {
2537		root = line->elements[i].item + 5;
2538		} else {
2539		printf("%s%s", line->elements[i].item,
2540		line->elements[i].indent);
2541		}
2542
2543		i++;
2544		}
2545		printf("\"\n");
2546		} else {
2547		line = getLineByType(LT_KERNELARGS, entry->lines);
2548		if (line) {
2549		char *s;
2550
2551		printf("args=\"");
2552		i = 1;
2553		while (i < line->numElements) {
2554		if (!strncmp
2555		(line->elements[i].item, "root=", 5)) {
2556		root = line->elements[i].item + 5;
2557		} else {
2558		s = line->elements[i].item;
2559
2560		printf("%s%s", s,
2561		line->elements[i].indent);
2562		}
2563
2564		i++;
2565		}
2566
2567		s = line->elements[i - 1].indent;
2568		printf("\"\n");
2569		}
2570		}
2571
2572		if (!root) {
2573		line = getLineByType(LT_ROOT, entry->lines);
2574		if (line && line->numElements >= 2)
2575		root = line->elements[1].item;
2576		}
2577
2578		if (root) {
2579		char *s = alloca(strlen(root) + 1);
2580
2581		strcpy(s, root);
2582		if (s[strlen(s) - 1] == '"')
2583		s[strlen(s) - 1] = '\0';
2584		/* make sure the root doesn't have a trailing " */
2585		printf("root=%s\n", s);
2586		}
2587
2588		line =
2589		getLineByType(LT_INITRD | LT_INITRD_EFI | LT_INITRD_16,
2590		entry->lines);
2591
2592		if (line && line->numElements >= 2) {
2593		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2594		printf("initrd=");
2595		else
2596		printf("initrd=%s", prefix);
2597
2598		for (i = 1; i < line->numElements; i++)
2599		printf("%s%s", line->elements[i].item,
2600		line->elements[i].indent);
2601		printf("\n");
2602		}
2603
2604		line = getLineByType(LT_TITLE, entry->lines);
2605		if (line) {
2606		printf("title=%s\n", line->elements[1].item);
2607		} else {
2608		char *title;
2609		line = getLineByType(LT_MENUENTRY, entry->lines);
2610		if (line) {
2611		title = grub2ExtractTitle(line);
2612		if (title)
2613		printf("title=%s\n", title);
2614		}
2615		}
2616
2617		for (j = 0, line = entry->lines; line; line = line->next) {
2618		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2619		if (!strncmp
2620		(prefix, line->elements[1].item, strlen(prefix)))
2621		printf("mbmodule%d=", j);
2622		else
2623		printf("mbmodule%d=%s", j, prefix);
2624
2625		for (i = 1; i < line->numElements; i++)
2626		printf("%s%s", line->elements[i].item,
2627		line->elements[i].indent);
2628		printf("\n");
2629		j++;
2630		}
2631		}
2632		}
2633
2634		int isSuseSystem(void)
2635		{
2636		const char *path;
2637		const static char default_path[] = "/etc/SuSE-release";
2638
2639		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2640		path = default_path;
2641
2642		if (!access(path, R_OK))
2643		return 1;
2644	return 0;	return 0;
2645		}
2646
2647		int isSuseGrubConf(const char *path)
2648		{
2649		FILE *grubConf;
2650		char *line = NULL;
2651		size_t len = 0, res = 0;
2652
2653		grubConf = fopen(path, "r");
2654		if (!grubConf) {
2655		dbgPrintf("Could not open SuSE configuration file '%s'\n",
2656		path);
2657		return 0;
2658		}
2659
2660		while ((res = getline(&line, &len, grubConf)) != -1) {
2661		if (!strncmp(line, "setup", 5)) {
2662		fclose(grubConf);
2663		free(line);
2664		return 1;
2665		}
2666		}
2667
2668		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2669		path);
2670
2671		fclose(grubConf);
2672		free(line);
2673		return 0;
2674		}
2675
2676		int suseGrubConfGetLba(const char *path, int *lbaPtr)
2677		{
2678		FILE *grubConf;
2679		char *line = NULL;
2680		size_t res = 0, len = 0;
2681
2682		if (!path)
2683		return 1;
2684		if (!lbaPtr)
2685		return 1;
2686
2687		grubConf = fopen(path, "r");
2688		if (!grubConf)
2689		return 1;
2690
2691		while ((res = getline(&line, &len, grubConf)) != -1) {
2692		if (line[res - 1] == '\n')
2693		line[res - 1] = '\0';
2694		else if (len > res)
2695		line[res] = '\0';
2696		else {
2697		line = realloc(line, res + 1);
2698		line[res] = '\0';
2699		}
2700
2701		if (!strncmp(line, "setup", 5)) {
2702		if (strstr(line, "--force-lba")) {
2703		*lbaPtr = 1;
2704		} else {
2705		*lbaPtr = 0;
2706		}
2707		dbgPrintf("lba: %i\n", *lbaPtr);
2708		break;
2709		}
2710		}
2711
2712		free(line);
2713		fclose(grubConf);
2714		return 0;
2715		}
2716
2717		int suseGrubConfGetInstallDevice(const char *path, char **devicePtr)
2718		{
2719		FILE *grubConf;
2720		char *line = NULL;
2721		size_t res = 0, len = 0;
2722		char *lastParamPtr = NULL;
2723		char *secLastParamPtr = NULL;
2724		char installDeviceNumber = '\0';
2725		char *bounds = NULL;
2726
2727		if (!path)
2728		return 1;
2729		if (!devicePtr)
2730		return 1;
2731
2732		grubConf = fopen(path, "r");
2733		if (!grubConf)
2734		return 1;
2735
2736		while ((res = getline(&line, &len, grubConf)) != -1) {
2737		if (strncmp(line, "setup", 5))
2738		continue;
2739
2740		if (line[res - 1] == '\n')
2741		line[res - 1] = '\0';
2742		else if (len > res)
2743		line[res] = '\0';
2744		else {
2745		line = realloc(line, res + 1);
2746		line[res] = '\0';
2747		}
2748
2749		lastParamPtr = bounds = line + res;
2750
2751		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2752		while (!isspace(*lastParamPtr))
2753		lastParamPtr--;
2754		lastParamPtr++;
2755
2756		secLastParamPtr = lastParamPtr - 2;
2757		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2758
2759		if (lastParamPtr + 3 > bounds) {
2760		dbgPrintf("lastParamPtr going over boundary");
2761		fclose(grubConf);
2762		free(line);
2763		return 1;
2764		}
2765		if (!strncmp(lastParamPtr, "(hd", 3))
2766		lastParamPtr += 3;
2767		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2768
2769		/*
2770		* Second last parameter will decide wether last parameter is
2771		* an IMAGE_DEVICE or INSTALL_DEVICE
2772		*/
2773		while (!isspace(*secLastParamPtr))
2774		secLastParamPtr--;
2775		secLastParamPtr++;
2776
2777		if (secLastParamPtr + 3 > bounds) {
2778		dbgPrintf("secLastParamPtr going over boundary");
2779		fclose(grubConf);
2780		free(line);
2781		return 1;
2782		}
2783		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2784		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2785		secLastParamPtr += 3;
2786		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2787		installDeviceNumber = *secLastParamPtr;
2788		} else {
2789		installDeviceNumber = *lastParamPtr;
2790		}
2791
2792		*devicePtr = malloc(6);
2793		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2794		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2795		fclose(grubConf);
2796		free(line);
2797		return 0;
2798		}
2799
2800		free(line);
2801		fclose(grubConf);
2802		return 1;
2803		}
2804
2805		int grubGetBootFromDeviceMap(const char *device, char **bootPtr)
2806		{
2807		FILE *deviceMap;
2808		char *line = NULL;
2809		size_t res = 0, len = 0;
2810		char *devicePtr;
2811		char *bounds = NULL;
2812		const char *path;
2813		const static char default_path[] = "/boot/grub/device.map";
2814
2815		if (!device)
2816		return 1;
2817		if (!bootPtr)
2818		return 1;
2819
2820		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2821		path = default_path;
2822
2823		dbgPrintf("opening grub device.map file from: %s\n", path);
2824		deviceMap = fopen(path, "r");
2825		if (!deviceMap)
2826		return 1;
2827
2828		while ((res = getline(&line, &len, deviceMap)) != -1) {
2829		if (!strncmp(line, "#", 1))
2830		continue;
2831
2832		if (line[res - 1] == '\n')
2833		line[res - 1] = '\0';
2834		else if (len > res)
2835		line[res] = '\0';
2836		else {
2837		line = realloc(line, res + 1);
2838		line[res] = '\0';
2839		}
2840
2841		devicePtr = line;
2842		bounds = line + res;
2843
2844		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2845		devicePtr++;
2846		dbgPrintf("device: %s\n", devicePtr);
2847
2848		if (!strncmp(devicePtr, device, strlen(device))) {
2849		devicePtr += strlen(device);
2850		while (isspace(*devicePtr)
2851		&& ((devicePtr + 1) <= bounds))
2852		devicePtr++;
2853
2854		*bootPtr = strdup(devicePtr);
2855		break;
2856		}
2857		}
2858
2859		free(line);
2860		fclose(deviceMap);
2861		return 0;
2862		}
2863
2864		int suseGrubConfGetBoot(const char *path, char **bootPtr)
2865		{
2866		char *grubDevice;
2867
2868		if (suseGrubConfGetInstallDevice(path, &grubDevice))
2869		dbgPrintf("error looking for grub installation device\n");
2870		else
2871		dbgPrintf("grubby installation device: %s\n", grubDevice);
2872
2873		if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2874		dbgPrintf("error looking for grub boot device\n");
2875		else
2876		dbgPrintf("grubby boot device: %s\n", *bootPtr);
2877
2878		free(grubDevice);
2879		return 0;
2880		}
2881
2882		int parseSuseGrubConf(int *lbaPtr, char **bootPtr)
2883		{
2884		/*
2885		* This SuSE grub configuration file at this location is not your
2886		* average grub configuration file, but instead the grub commands
2887		* used to setup grub on that system.
2888		*/
2889		const char *path;
2890		const static char default_path[] = "/etc/grub.conf";
2891
2892		if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2893		path = default_path;
2894
2895		if (!isSuseGrubConf(path))
2896		return 1;
2897
2898		if (lbaPtr) {
2899		*lbaPtr = 0;
2900		if (suseGrubConfGetLba(path, lbaPtr))
2901		return 1;
2902		}
2903
2904		if (bootPtr) {
2905		*bootPtr = NULL;
2906		suseGrubConfGetBoot(path, bootPtr);
2907		}
2908
2909		return 0;
2910		}
2911
2912		int parseSysconfigGrub(int *lbaPtr, char **bootPtr)
2913		{
2914		FILE *in;
2915		char buf[1024];
2916		char *chptr;
2917		char *start;
2918		char *param;
2919
2920		in = fopen("/etc/sysconfig/grub", "r");
2921		if (!in)
2922		return 1;
2923
2924		if (lbaPtr)
2925		*lbaPtr = 0;
2926		if (bootPtr)
2927		*bootPtr = NULL;
2928
2929		while (fgets(buf, sizeof(buf), in)) {
2930		start = buf;
2931		while (isspace(*start))
2932		start++;
2933		if (*start == '#')
2934		continue;
2935
2936		chptr = strchr(start, '=');
2937		if (!chptr)
2938		continue;
2939		chptr--;
2940		while (*chptr && isspace(*chptr))
2941		chptr--;
2942		chptr++;
2943		*chptr = '\0';
2944
2945		param = chptr + 1;
2946		while (*param && isspace(*param))
2947		param++;
2948		if (*param == '=') {
2949		param++;
2950		while (*param && isspace(*param))
2951		param++;
2952		}
2953
2954		chptr = param;
2955		while (*chptr && !isspace(*chptr))
2956		chptr++;
2957		*chptr = '\0';
2958
2959		if (!strcmp(start, "forcelba") && !strcmp(param, "1") && lbaPtr)
2960		*lbaPtr = 1;
2961		else if (!strcmp(start, "boot") && bootPtr)
2962		*bootPtr = strdup(param);
2963		}
2964
2965		fclose(in);
2966
2967		return 0;
2968		}
2969
2970		void dumpSysconfigGrub(void)
2971		{
2972		char *boot = NULL;
2973		int lba;
2974
2975		if (isSuseSystem()) {
2976		if (parseSuseGrubConf(&lba, &boot)) {
2977		free(boot);
2978		return;
2979		}
2980		} else {
2981		if (parseSysconfigGrub(&lba, &boot)) {
2982		free(boot);
2983		return;
2984		}
2985		}
2986
2987		if (lba)
2988		printf("lba\n");
2989		if (boot) {
2990		printf("boot=%s\n", boot);
2991		free(boot);
2992		}
2993		}
2994
2995		int displayInfo(struct grubConfig *config, char *kernel, const char *prefix)
2996		{
2997		int i = 0;
2998		struct singleEntry *entry;
2999		struct singleLine *line;
3000
3001		entry = findEntryByPath(config, kernel, prefix, &i);
3002		if (!entry) {
3003		fprintf(stderr, _("grubby: kernel not found\n"));
3004		return 1;
3005		}
3006
3007		/* this is a horrible hack to support /etc/sysconfig/grub; there must
3008		be a better way */
3009		if (config->cfi == &grubConfigType) {
3010		dumpSysconfigGrub();
3011		} else {
3012		line = getLineByType(LT_BOOT, config->theLines);
3013		if (line && line->numElements >= 1) {
3014		printf("boot=%s\n", line->elements[1].item);
3015		}
3016
3017		line = getLineByType(LT_LBA, config->theLines);
3018		if (line)
3019		printf("lba\n");
3020		}
3021
3022		displayEntry(entry, prefix, i);
3023
3024		i++;
3025		while ((entry = findEntryByPath(config, kernel, prefix, &i))) {
3026		displayEntry(entry, prefix, i);
3027		i++;
3028		}
3029
3030		return 0;
3031		}
3032
3033		struct singleLine *addLineTmpl(struct singleEntry *entry,
3034		struct singleLine *tmplLine,
3035		struct singleLine *prevLine,
3036		const char *val, struct configFileInfo *cfi)
3037		{
3038		struct singleLine *newLine = lineDup(tmplLine);
3039
3040		if (isEfi && cfi == &grub2ConfigType) {
3041		enum lineType_e old = newLine->type;
3042		newLine->type = preferredLineType(newLine->type, cfi);
3043		if (old != newLine->type)
3044		newLine->elements[0].item =
3045		getKeyByType(newLine->type, cfi);
3046		}
3047
3048		if (val) {
3049		/* override the inherited value with our own.
3050		* This is a little weak because it only applies to elements[1]
3051		*/
3052		if (newLine->numElements > 1)
3053		removeElement(newLine, 1);
3054		insertElement(newLine, val, 1, cfi);
3055
3056		/* but try to keep the rootspec from the template... sigh */
3057		if (tmplLine->
3058		type & (LT_HYPER | LT_KERNEL | LT_MBMODULE | LT_INITRD |
3059		LT_KERNEL_EFI | LT_INITRD_EFI | LT_KERNEL_16 |
3060		LT_INITRD_16)) {
3061		char *rootspec =
3062		getRootSpecifier(tmplLine->elements[1].item);
3063		if (rootspec != NULL) {
3064		free(newLine->elements[1].item);
3065		newLine->elements[1].item =
3066		sdupprintf("%s%s", rootspec, val);
3067		}
3068		}
3069		}
3070
3071		dbgPrintf("addLineTmpl(%s)\n", newLine->numElements ?
3072		newLine->elements[0].item : "");
3073
3074		if (!entry->lines) {
3075		/* first one on the list */
3076		entry->lines = newLine;
3077		} else if (prevLine) {
3078		/* add after prevLine */
3079		newLine->next = prevLine->next;
3080		prevLine->next = newLine;
3081		}
3082
3083	if (boot[1] == JMP_SHORT_OPCODE) {	return newLine;
3084	offset = boot[2] + 2;	}
3085	} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {
3086	offset = (boot[3] << 8) + boot[2] + 2;	/* val may be NULL */
3087	} else if (boot[0] == JMP_SHORT_OPCODE) {	struct singleLine *addLine(struct singleEntry *entry,
3088	offset = boot[1] + 2;	struct configFileInfo *cfi,
3089	/*	enum lineType_e type, char *defaultIndent,
3090	* it looks like grub, when copying stage1 into the mbr, patches stage1	const char *val)
3091	* right after the JMP location, replacing other instructions such as	{
3092	* JMPs for NOOPs. So, relax the check a little bit by skipping those	struct singleLine *line, *prev;
3093	* different bytes.	struct keywordTypes *kw;
3094		struct singleLine tmpl;
3095
3096		/* NB: This function shouldn't allocate items on the heap, rather on
3097		* the stack since it calls addLineTmpl which will make copies.
3098	*/	*/
3099	if ((bootSect[offset + 1] == NOOP_OPCODE)	if (type == LT_TITLE && cfi->titleBracketed) {
3100	&& (bootSect[offset + 2] == NOOP_OPCODE)) {	/* we're doing a bracketed title (zipl) */
3101	offset = offset + 3;	tmpl.type = type;
3102	}	tmpl.numElements = 1;
3103	} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {	tmpl.elements = alloca(sizeof(*tmpl.elements));
3104	offset = (boot[2] << 8) + boot[1] + 2;	tmpl.elements[0].item = alloca(strlen(val) + 3);
3105	} else {	sprintf(tmpl.elements[0].item, "[%s]", val);
3106		tmpl.elements[0].indent = "";
3107		val = NULL;
3108		} else if (type == LT_MENUENTRY) {
3109		char *lineend = "--class gnu-linux --class gnu --class os {";
3110		if (!val) {
3111		fprintf(stderr,
3112		"Line type LT_MENUENTRY requires a value\n");
3113		abort();
3114		}
3115		kw = getKeywordByType(type, cfi);
3116		if (!kw) {
3117		fprintf(stderr,
3118		"Looking up keyword for unknown type %d\n",
3119		type);
3120		abort();
3121		}
3122		tmpl.indent = "";
3123		tmpl.type = type;
3124		tmpl.numElements = 3;
3125		tmpl.elements =
3126		alloca(sizeof(*tmpl.elements) * tmpl.numElements);
3127		tmpl.elements[0].item = kw->key;
3128		tmpl.elements[0].indent = alloca(2);
3129		sprintf(tmpl.elements[0].indent, "%c", kw->nextChar);
3130		tmpl.elements[1].item = (char *)val;
3131		tmpl.elements[1].indent = alloca(2);
3132		sprintf(tmpl.elements[1].indent, "%c", kw->nextChar);
3133		tmpl.elements[2].item = alloca(strlen(lineend) + 1);
3134		strcpy(tmpl.elements[2].item, lineend);
3135		tmpl.elements[2].indent = "";
3136		} else {
3137		kw = getKeywordByType(type, cfi);
3138		if (!kw) {
3139		fprintf(stderr,
3140		"Looking up keyword for unknown type %d\n",
3141		type);
3142		abort();
3143		}
3144		tmpl.type = type;
3145		tmpl.numElements = val ? 2 : 1;
3146		tmpl.elements =
3147		alloca(sizeof(*tmpl.elements) * tmpl.numElements);
3148		tmpl.elements[0].item = kw->key;
3149		tmpl.elements[0].indent = alloca(2);
3150		sprintf(tmpl.elements[0].indent, "%c", kw->nextChar);
3151		if (val) {
3152		tmpl.elements[1].item = (char *)val;
3153		tmpl.elements[1].indent = "";
3154		}
3155		}
3156
3157		/* The last non-empty line gives us the indention to us and the line
3158		* to insert after. Note that comments are considered empty lines,
3159		* which may not be ideal? If there are no lines or we are looking at
3160		* the first line, we use defaultIndent (the first line is normally
3161		* indented differently from the rest) */
3162		for (line = entry->lines, prev = NULL; line; line = line->next) {
3163		if (line->numElements)
3164		prev = line;
3165		/* fall back on the last line if prev isn't otherwise set */
3166		if (!line->next && !prev)
3167		prev = line;
3168		}
3169
3170		struct singleLine *menuEntry;
3171		menuEntry = getLineByType(LT_MENUENTRY, entry->lines);
3172		if (tmpl.type == LT_ENTRY_END) {
3173		if (menuEntry)
3174		tmpl.indent = menuEntry->indent;
3175		else
3176		tmpl.indent = defaultIndent ? : "";
3177		} else if (tmpl.type != LT_MENUENTRY) {
3178		if (menuEntry)
3179		tmpl.indent = "\t";
3180		else if (prev == entry->lines)
3181		tmpl.indent = defaultIndent ? : "";
3182		else
3183		tmpl.indent = prev->indent;
3184		}
3185
3186		return addLineTmpl(entry, &tmpl, prev, val, cfi);
3187		}
3188
3189		void removeLine(struct singleEntry *entry, struct singleLine *line)
3190		{
3191		struct singleLine *prev;
3192		int i;
3193
3194		for (i = 0; i < line->numElements; i++) {
3195		free(line->elements[i].item);
3196		free(line->elements[i].indent);
3197		}
3198		free(line->elements);
3199		free(line->indent);
3200
3201		if (line == entry->lines) {
3202		entry->lines = line->next;
3203		} else {
3204		prev = entry->lines;
3205		while (prev->next != line)
3206		prev = prev->next;
3207		prev->next = line->next;
3208		}
3209
3210		free(line);
3211		}
3212
3213		static void requote(struct singleLine *tmplLine, struct configFileInfo *cfi)
3214		{
3215		struct singleLine newLine = {
3216		.indent = tmplLine->indent,
3217		.type = tmplLine->type,
3218		.next = tmplLine->next,
3219		};
3220		int firstQuotedItem = -1;
3221		int quoteLen = 0;
3222		int j;
3223		int element = 0;
3224		char *c;
3225
3226		c = malloc(strlen(tmplLine->elements[0].item) + 1);
3227		strcpy(c, tmplLine->elements[0].item);
3228		insertElement(&newLine, c, element++, cfi);
3229		free(c);
3230		c = NULL;
3231
3232		for (j = 1; j < tmplLine->numElements; j++) {
3233		if (firstQuotedItem == -1) {
3234		quoteLen += strlen(tmplLine->elements[j].item);
3235
3236		if (isquote(tmplLine->elements[j].item[0])) {
3237		firstQuotedItem = j;
3238		quoteLen +=
3239		strlen(tmplLine->elements[j].indent);
3240		} else {
3241		c = malloc(quoteLen + 1);
3242		strcpy(c, tmplLine->elements[j].item);
3243		insertElement(&newLine, c, element++, cfi);
3244		free(c);
3245		quoteLen = 0;
3246		}
3247		} else {
3248		int itemlen = strlen(tmplLine->elements[j].item);
3249		quoteLen += itemlen;
3250		quoteLen += strlen(tmplLine->elements[j].indent);
3251
3252		if (isquote(tmplLine->elements[j].item[itemlen - 1])) {
3253		c = malloc(quoteLen + 1);
3254		c[0] = '\0';
3255		for (int i = firstQuotedItem; i < j + 1; i++) {
3256		strcat(c, tmplLine->elements[i].item);
3257		strcat(c, tmplLine->elements[i].indent);
3258		}
3259		insertElement(&newLine, c, element++, cfi);
3260		free(c);
3261
3262		firstQuotedItem = -1;
3263		quoteLen = 0;
3264		}
3265		}
3266		}
3267		while (tmplLine->numElements)
3268		removeElement(tmplLine, 0);
3269		if (tmplLine->elements)
3270		free(tmplLine->elements);
3271
3272		tmplLine->numElements = newLine.numElements;
3273		tmplLine->elements = newLine.elements;
3274		}
3275
3276		static void insertElement(struct singleLine *line,
3277		const char *item, int insertHere,
3278		struct configFileInfo *cfi)
3279		{
3280		struct keywordTypes *kw;
3281		char indent[2] = "";
3282
3283		/* sanity check */
3284		if (insertHere > line->numElements) {
3285		dbgPrintf
3286		("insertElement() adjusting insertHere from %d to %d\n",
3287		insertHere, line->numElements);
3288		insertHere = line->numElements;
3289		}
3290
3291		line->elements = realloc(line->elements, (line->numElements + 1) *
3292		sizeof(*line->elements));
3293		memmove(&line->elements[insertHere + 1],
3294		&line->elements[insertHere],
3295		(line->numElements - insertHere) * sizeof(*line->elements));
3296		line->elements[insertHere].item = strdup(item);
3297
3298		kw = getKeywordByType(line->type, cfi);
3299
3300		if (line->numElements == 0) {
3301		indent[0] = '\0';
3302		} else if (insertHere == 0) {
3303		indent[0] = kw->nextChar;
3304		} else if (kw->separatorChar != '\0') {
3305		indent[0] = kw->separatorChar;
3306		} else {
3307		indent[0] = ' ';
3308		}
3309
3310		if (insertHere > 0 && line->elements[insertHere - 1].indent[0] == '\0') {
3311		/* move the end-of-line forward */
3312		line->elements[insertHere].indent =
3313		line->elements[insertHere - 1].indent;
3314		line->elements[insertHere - 1].indent = strdup(indent);
3315		} else {
3316		line->elements[insertHere].indent = strdup(indent);
3317		}
3318
3319		line->numElements++;
3320
3321		dbgPrintf("insertElement(%s, '%s%s', %d)\n",
3322		line->elements[0].item,
3323		line->elements[insertHere].item,
3324		line->elements[insertHere].indent, insertHere);
3325		}
3326
3327		static void removeElement(struct singleLine *line, int removeHere)
3328		{
3329		int i;
3330
3331		/* sanity check */
3332		if (removeHere >= line->numElements)
3333		return;
3334
3335		dbgPrintf("removeElement(%s, %d:%s)\n", line->elements[0].item,
3336		removeHere, line->elements[removeHere].item);
3337
3338		free(line->elements[removeHere].item);
3339
3340		if (removeHere > 1) {
3341		/* previous argument gets this argument's post-indentation */
3342		free(line->elements[removeHere - 1].indent);
3343		line->elements[removeHere - 1].indent =
3344		line->elements[removeHere].indent;
3345		} else {
3346		free(line->elements[removeHere].indent);
3347		}
3348
3349		/* now collapse the array, but don't bother to realloc smaller */
3350		for (i = removeHere; i < line->numElements - 1; i++)
3351		line->elements[i] = line->elements[i + 1];
3352
3353		line->numElements--;
3354		}
3355
3356		int argMatch(const char *one, const char *two)
3357		{
3358		char *first, *second;
3359		char *chptr;
3360
3361		first = strcpy(alloca(strlen(one) + 1), one);
3362		second = strcpy(alloca(strlen(two) + 1), two);
3363
3364		chptr = strchr(first, '=');
3365		if (chptr)
3366		*chptr = '\0';
3367
3368		chptr = strchr(second, '=');
3369		if (chptr)
3370		*chptr = '\0';
3371
3372		return strcmp(first, second);
3373		}
3374
3375		int updateActualImage(struct grubConfig *cfg, const char *image,
3376		const char *prefix, const char *addArgs,
3377		const char *removeArgs, int multibootArgs)
3378		{
3379		struct singleEntry *entry;
3380		struct singleLine *line, *rootLine;
3381		int index = 0;
3382		int i, k;
3383		const char **newArgs, **oldArgs;
3384		const char **arg;
3385		int useKernelArgs, useRoot;
3386		int firstElement;
3387		int *usedElements;
3388		int doreplace;
3389
3390		if (!image)
3391		return 0;
3392
3393		if (!addArgs) {
3394		newArgs = malloc(sizeof(*newArgs));
3395		*newArgs = NULL;
3396		} else {
3397		if (poptParseArgvString(addArgs, NULL, &newArgs)) {
3398		fprintf(stderr,
3399		_("grubby: error separating arguments '%s'\n"),
3400		addArgs);
3401		return 1;
3402		}
3403		}
3404
3405		if (!removeArgs) {
3406		oldArgs = malloc(sizeof(*oldArgs));
3407		*oldArgs = NULL;
3408		} else {
3409		if (poptParseArgvString(removeArgs, NULL, &oldArgs)) {
3410		fprintf(stderr,
3411		_("grubby: error separating arguments '%s'\n"),
3412		removeArgs);
3413		free(newArgs);
3414		return 1;
3415		}
3416		}
3417
3418		useKernelArgs = (getKeywordByType(LT_KERNELARGS, cfg->cfi)
3419		&& (!multibootArgs || cfg->cfi->mbConcatArgs));
3420
3421		useRoot = (getKeywordByType(LT_ROOT, cfg->cfi)
3422		&& !multibootArgs);
3423
3424		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3425
3426		if (multibootArgs && !entry->multiboot)
3427		continue;
3428
3429		/* Determine where to put the args.  If this config supports
3430		* LT_KERNELARGS, use that.  Otherwise use
3431		* LT_HYPER/LT_KERNEL/LT_MBMODULE lines.
3432		*/
3433		if (useKernelArgs) {
3434		line = getLineByType(LT_KERNELARGS, entry->lines);
3435		if (!line) {
3436		/* no LT_KERNELARGS, need to add it */
3437		line = addLine(entry, cfg->cfi, LT_KERNELARGS,
3438		cfg->secondaryIndent, NULL);
3439		}
3440		firstElement = 1;
3441
3442		} else if (multibootArgs) {
3443		line = getLineByType(LT_HYPER, entry->lines);
3444		if (!line) {
3445		/* a multiboot entry without LT_HYPER? */
3446		continue;
3447		}
3448		firstElement = 2;
3449
3450		} else {
3451		line =
3452		getLineByType(LT_KERNEL | LT_MBMODULE |
3453		LT_KERNEL_EFI | LT_KERNEL_16,
3454		entry->lines);
3455		if (!line) {
3456		/* no LT_KERNEL or LT_MBMODULE in this entry? */
3457		continue;
3458		}
3459		firstElement = 2;
3460		}
3461
3462		/* handle the elilo case which does:
3463		*   append="hypervisor args -- kernel args"
3464		*/
3465		if (entry->multiboot && cfg->cfi->mbConcatArgs) {
3466		/* this is a multiboot entry, make sure there's
3467		* -- on the args line
3468		*/
3469		for (i = firstElement; i < line->numElements; i++) {
3470		if (!strcmp(line->elements[i].item, "--"))
3471		break;
3472		}
3473		if (i == line->numElements) {
3474		/* assume all existing args are kernel args,
3475		* prepend -- to make it official
3476		*/
3477		insertElement(line, "--", firstElement,
3478		cfg->cfi);
3479		i = firstElement;
3480		}
3481		if (!multibootArgs) {
3482		/* kernel args start after the -- */
3483		firstElement = i + 1;
3484		}
3485		} else if (cfg->cfi->mbConcatArgs) {
3486		/* this is a non-multiboot entry, remove hyper args */
3487		for (i = firstElement; i < line->numElements; i++) {
3488		if (!strcmp(line->elements[i].item, "--"))
3489		break;
3490		}
3491		if (i < line->numElements) {
3492		/* remove args up to -- */
3493		while (strcmp
3494		(line->elements[firstElement].item,
3495		"--"))
3496		removeElement(line, firstElement);
3497		/* remove -- */
3498		removeElement(line, firstElement);
3499		}
3500		}
3501
3502		usedElements = calloc(line->numElements, sizeof(*usedElements));
3503
3504		for (k = 0, arg = newArgs; *arg; arg++, k++) {
3505
3506		doreplace = 1;
3507		for (i = firstElement; i < line->numElements; i++) {
3508		if (multibootArgs && cfg->cfi->mbConcatArgs &&
3509		!strcmp(line->elements[i].item, "--")) {
3510		/* reached the end of hyper args, insert here */
3511		doreplace = 0;
3512		break;
3513		}
3514		if (usedElements[i])
3515		continue;
3516		if (!argMatch(line->elements[i].item, *arg)) {
3517		usedElements[i] = 1;
3518		break;
3519		}
3520		}
3521
3522		if (i < line->numElements && doreplace) {
3523		/* direct replacement */
3524		free(line->elements[i].item);
3525		line->elements[i].item = strdup(*arg);
3526
3527		} else if (useRoot && !strncmp(*arg, "root=/dev/", 10)) {
3528		/* root= replacement */
3529		rootLine = getLineByType(LT_ROOT, entry->lines);
3530		if (rootLine) {
3531		free(rootLine->elements[1].item);
3532		rootLine->elements[1].item =
3533		strdup(*arg + 5);
3534		} else {
3535		rootLine =
3536		addLine(entry, cfg->cfi, LT_ROOT,
3537		cfg->secondaryIndent,
3538		*arg + 5);
3539		}
3540		}
3541
3542		else {
3543		/* insert/append */
3544		insertElement(line, *arg, i, cfg->cfi);
3545		usedElements =
3546		realloc(usedElements,
3547		line->numElements *
3548		sizeof(*usedElements));
3549		memmove(&usedElements[i + 1], &usedElements[i],
3550		line->numElements - i - 1);
3551		usedElements[i] = 1;
3552
3553		/* if we updated a root= here even though
3554		* there is a LT_ROOT available we need to
3555		* remove the LT_ROOT entry (this will happen
3556		* if we switch from a device to a label) */
3557		if (useRoot && !strncmp(*arg, "root=", 5)) {
3558		rootLine =
3559		getLineByType(LT_ROOT,
3560		entry->lines);
3561		if (rootLine)
3562		removeLine(entry, rootLine);
3563		}
3564		}
3565		}
3566
3567		free(usedElements);
3568
3569		for (arg = oldArgs; *arg; arg++) {
3570		for (i = firstElement; i < line->numElements; i++) {
3571		if (multibootArgs && cfg->cfi->mbConcatArgs &&
3572		!strcmp(line->elements[i].item, "--"))
3573		/* reached the end of hyper args, stop here */
3574		break;
3575		if (!argMatch(line->elements[i].item, *arg)) {
3576		removeElement(line, i);
3577		break;
3578		}
3579		}
3580		/* handle removing LT_ROOT line too */
3581		if (useRoot && !strncmp(*arg, "root=", 5)) {
3582		rootLine = getLineByType(LT_ROOT, entry->lines);
3583		if (rootLine)
3584		removeLine(entry, rootLine);
3585		}
3586		}
3587
3588		if (line->numElements == 1) {
3589		/* don't need the line at all (note it has to be a
3590		LT_KERNELARGS for this to happen */
3591		removeLine(entry, line);
3592		}
3593		}
3594
3595		free(newArgs);
3596		free(oldArgs);
3597
3598		return 0;
3599		}
3600
3601		int updateImage(struct grubConfig *cfg, const char *image,
3602		const char *prefix, const char *addArgs,
3603		const char *removeArgs,
3604		const char *addMBArgs, const char *removeMBArgs)
3605		{
3606		int rc = 0;
3607
3608		if (!image)
3609		return rc;
3610
3611		/* update the main args first... */
3612		if (addArgs || removeArgs)
3613		rc = updateActualImage(cfg, image, prefix, addArgs, removeArgs,
3614		0);
3615		if (rc)
3616		return rc;
3617
3618		/* and now any multiboot args */
3619		if (addMBArgs || removeMBArgs)
3620		rc = updateActualImage(cfg, image, prefix, addMBArgs,
3621		removeMBArgs, 1);
3622		return rc;
3623		}
3624
3625		int addMBInitrd(struct grubConfig *cfg, const char *newMBKernel,
3626		const char *image, const char *prefix, const char *initrd,
3627		const char *title)
3628		{
3629		struct singleEntry *entry;
3630		struct singleLine *line, *kernelLine, *endLine = NULL;
3631		int index = 0;
3632
3633		if (!image)
3634		return 0;
3635
3636		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3637		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3638		if (!kernelLine)
3639		continue;
3640
3641		/* if title is supplied, the entry's title must match it. */
3642		if (title) {
3643		char *linetitle;
3644
3645		line =
3646		getLineByType(LT_TITLE | LT_MENUENTRY,
3647		entry->lines);
3648		if (!line)
3649		continue;
3650
3651		linetitle = extractTitle(cfg, line);
3652		if (!linetitle)
3653		continue;
3654		if (strcmp(title, linetitle)) {
3655		free(linetitle);
3656		continue;
3657		}
3658		free(linetitle);
3659		}
3660
3661		if (prefix) {
3662		int prefixLen = strlen(prefix);
3663		if (!strncmp(initrd, prefix, prefixLen))
3664		initrd += prefixLen;
3665		}
3666		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3667		if (endLine)
3668		removeLine(entry, endLine);
3669		line =
3670		addLine(entry, cfg->cfi,
3671		preferredLineType(LT_MBMODULE, cfg->cfi),
3672		kernelLine->indent, initrd);
3673		if (!line)
3674		return 1;
3675		if (endLine) {
3676		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3677		if (!line)
3678		return 1;
3679		}
3680
3681		break;
3682		}
3683
3684	return 0;	return 0;
3685	}	}
3686
3687		int updateInitrd(struct grubConfig *cfg, const char *image,
3688		const char *prefix, const char *initrd, const char *title)
3689		{
3690		struct singleEntry *entry;
3691		struct singleLine *line, *kernelLine, *endLine = NULL;
3692		int index = 0;
3693
3694		if (!image)
3695		return 0;
3696
3697		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3698		kernelLine =
3699		getLineByType(LT_KERNEL | LT_KERNEL_EFI | LT_KERNEL_16,
3700		entry->lines);
3701		if (!kernelLine)
3702		continue;
3703
3704		/* if title is supplied, the entry's title must match it. */
3705		if (title) {
3706		char *linetitle;
3707
3708		line =
3709		getLineByType(LT_TITLE | LT_MENUENTRY,
3710		entry->lines);
3711		if (!line)
3712		continue;
3713
3714		linetitle = extractTitle(cfg, line);
3715		if (!linetitle)
3716		continue;
3717		if (strcmp(title, linetitle)) {
3718		free(linetitle);
3719		continue;
3720		}
3721		free(linetitle);
3722		}
3723
3724		line =
3725		getLineByType(LT_INITRD | LT_INITRD_EFI | LT_INITRD_16,
3726		entry->lines);
3727		if (line)
3728		removeLine(entry, line);
3729		if (prefix) {
3730		int prefixLen = strlen(prefix);
3731		if (!strncmp(initrd, prefix, prefixLen))
3732		initrd += prefixLen;
3733		}
3734		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3735		if (endLine)
3736		removeLine(entry, endLine);
3737		enum lineType_e lt;
3738		switch (kernelLine->type) {
3739		case LT_KERNEL:
3740		lt = LT_INITRD;
3741		break;
3742		case LT_KERNEL_EFI:
3743		lt = LT_INITRD_EFI;
3744		break;
3745		case LT_KERNEL_16:
3746		lt = LT_INITRD_16;
3747		break;
3748		default:
3749		lt = preferredLineType(LT_INITRD, cfg->cfi);
3750		}
3751		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3752		if (!line)
3753		return 1;
3754		if (endLine) {
3755		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3756		if (!line)
3757		return 1;
3758		}
3759
3760		break;
3761		}
3762
3763		return 0;
3764		}
3765
3766		int checkDeviceBootloader(const char *device, const unsigned char *boot)
3767		{
3768		int fd;
3769		unsigned char bootSect[512];
3770		int offset;
3771
3772		fd = open(device, O_RDONLY);
3773		if (fd < 0) {
3774		fprintf(stderr, _("grubby: unable to open %s: %s\n"),
3775		device, strerror(errno));
3776		return 1;
3777		}
3778
3779		if (read(fd, bootSect, 512) != 512) {
3780		fprintf(stderr, _("grubby: unable to read %s: %s\n"),
3781		device, strerror(errno));
3782		return 1;
3783		}
3784		close(fd);
3785
3786		/* first three bytes should match, a jmp short should be in there */
3787		if (memcmp(boot, bootSect, 3))
3788		return 0;
3789
3790	if (memcmp(boot + offset, bootSect + offset, CODE_SEG_SIZE))	if (boot[1] == JMP_SHORT_OPCODE) {
3791	return 0;	offset = boot[2] + 2;
3792		} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {
3793		offset = (boot[3] << 8) + boot[2] + 2;
3794		} else if (boot[0] == JMP_SHORT_OPCODE) {
3795		offset = boot[1] + 2;
3796		/*
3797		* it looks like grub, when copying stage1 into the mbr,
3798		* patches stage1 right after the JMP location, replacing
3799		* other instructions such as JMPs for NOOPs. So, relax the
3800		* check a little bit by skipping those different bytes.
3801		*/
3802		if ((bootSect[offset + 1] == NOOP_OPCODE)
3803		&& (bootSect[offset + 2] == NOOP_OPCODE)) {
3804		offset = offset + 3;
3805		}
3806		} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {
3807		offset = (boot[2] << 8) + boot[1] + 2;
3808		} else {
3809		return 0;
3810		}
3811
3812	return 2;	if (memcmp(boot + offset, bootSect + offset, CODE_SEG_SIZE))
3813	}	return 0;
3814
	int checkLiloOnRaid(char * mdDev, const unsigned char * boot) {
	int fd;
	char buf[65536];
	char * end;
	char * chptr;
	char * chptr2;
	int rc;
	/* it's on raid; we need to parse /proc/mdstat and check all of the
	*raw* devices listed in there */
	if (!strncmp(mdDev, "/dev/", 5))
	mdDev += 5;
	if ((fd = open("/proc/mdstat", O_RDONLY)) < 0) {
	fprintf(stderr, _("grubby: failed to open /proc/mdstat: %s\n"),
	strerror(errno));
3815	return 2;	return 2;
3816	}	}
3817
3818	rc = read(fd, buf, sizeof(buf) - 1);	int checkLiloOnRaid(char *mdDev, const unsigned char *boot)
3819	if (rc < 0 || rc == (sizeof(buf) - 1)) {	{
3820	fprintf(stderr, _("grubby: failed to read /proc/mdstat: %s\n"),	int fd;
3821	strerror(errno));	char buf[65536];
3822		char *end;
3823		char *chptr;
3824		char *chptr2;
3825		int rc;
3826
3827		/* it's on raid; we need to parse /proc/mdstat and check all of the
3828		*raw* devices listed in there */
3829
3830		if (!strncmp(mdDev, "/dev/", 5))
3831		mdDev += 5;
3832
3833		if ((fd = open("/proc/mdstat", O_RDONLY)) < 0) {
3834		fprintf(stderr, _("grubby: failed to open /proc/mdstat: %s\n"),
3835		strerror(errno));
3836		return 2;
3837		}
3838
3839		rc = read(fd, buf, sizeof(buf) - 1);
3840		if (rc < 0 || rc == (sizeof(buf) - 1)) {
3841		fprintf(stderr, _("grubby: failed to read /proc/mdstat: %s\n"),
3842		strerror(errno));
3843		close(fd);
3844		return 2;
3845		}
3846	close(fd);	close(fd);
3847	return 2;	buf[rc] = '\0';
	}
	close(fd);
	buf[rc] = '\0';
	chptr = buf;
	while (*chptr) {
	end = strchr(chptr, '\n');
	if (!end) break;
	*end = '\0';
3848
3849	if (!strncmp(chptr, mdDev, strlen(mdDev)) &&	chptr = buf;
3850	chptr[strlen(mdDev)] == ' ') {	while (*chptr) {
3851		end = strchr(chptr, '\n');
3852		if (!end)
3853		break;
3854		*end = '\0';
3855
3856	/* found the device */	if (!strncmp(chptr, mdDev, strlen(mdDev)) &&
3857	while (*chptr && *chptr != ':') chptr++;	chptr[strlen(mdDev)] == ' ') {
	chptr++;
	while (*chptr && isspace(*chptr)) chptr++;
	/* skip the "active" bit */
	while (*chptr && !isspace(*chptr)) chptr++;
	while (*chptr && isspace(*chptr)) chptr++;
	/* skip the raid level */
	while (*chptr && !isspace(*chptr)) chptr++;
	while (*chptr && isspace(*chptr)) chptr++;
	/* everything else is partition stuff */
	while (*chptr) {
	chptr2 = chptr;
	while (*chptr2 && *chptr2 != '[') chptr2++;
	if (!*chptr2) break;
	/* yank off the numbers at the end */
	chptr2--;
	while (isdigit(*chptr2) && chptr2 > chptr) chptr2--;
	chptr2++;
	*chptr2 = '\0';
	/* Better, now we need the /dev/ back. We're done with
	* everything before this point, so we can just put
	* the /dev/ part there. There will always be room. */
	memcpy(chptr - 5, "/dev/", 5);
	rc = checkDeviceBootloader(chptr - 5, boot);
	if (rc != 2) {
	return rc;
	}
	chptr = chptr2 + 1;
	/* skip the [11] bit */
	while (*chptr && !isspace(*chptr)) chptr++;
	/* and move to the next one */
	while (*chptr && isspace(*chptr)) chptr++;
	}
	/*  we're good to go */
	return 2;
	}
	chptr = end + 1;
	}
	fprintf(stderr,
	_("grubby: raid device /dev/%s not found in /proc/mdstat\n"),
	mdDev);
	return 0;
	}
	int checkForLilo(struct grubConfig * config) {
	int fd;
	unsigned char boot[512];
	struct singleLine * line;
	for (line = config->theLines; line; line = line->next)
	if (line->type == LT_BOOT) break;
	if (!line) {
	fprintf(stderr,
	_("grubby: no boot line found in lilo configuration\n"));
	return 1;
	}
3858
3859	if (line->numElements != 2) return 1;	/* found the device */
3860		while (*chptr && *chptr != ':')
3861		chptr++;
3862		chptr++;
3863		while (*chptr && isspace(*chptr))
3864		chptr++;
3865
3866		/* skip the "active" bit */
3867		while (*chptr && !isspace(*chptr))
3868		chptr++;
3869		while (*chptr && isspace(*chptr))
3870		chptr++;
3871
3872		/* skip the raid level */
3873		while (*chptr && !isspace(*chptr))
3874		chptr++;
3875		while (*chptr && isspace(*chptr))
3876		chptr++;
3877
3878		/* everything else is partition stuff */
3879		while (*chptr) {
3880		chptr2 = chptr;
3881		while (*chptr2 && *chptr2 != '[')
3882		chptr2++;
3883		if (!*chptr2)
3884		break;
3885
3886	fd = open("/boot/boot.b", O_RDONLY);	/* yank off the numbers at the end */
3887	if (fd < 0) {	chptr2--;
3888	fprintf(stderr, _("grubby: unable to open %s: %s\n"),	while (isdigit(*chptr2) && chptr2 > chptr)
3889	"/boot/boot.b", strerror(errno));	chptr2--;
3890	return 1;	chptr2++;
3891	}	*chptr2 = '\0';
3892
3893		/* Better, now we need the /dev/ back. We're
3894		* done with everything before this point, so
3895		* we can just put the /dev/ part there.
3896		* There will always be room. */
3897		memcpy(chptr - 5, "/dev/", 5);
3898		rc = checkDeviceBootloader(chptr - 5, boot);
3899		if (rc != 2) {
3900		return rc;
3901		}
3902
3903	if (read(fd, boot, 512) != 512) {	chptr = chptr2 + 1;
3904	fprintf(stderr, _("grubby: unable to read %s: %s\n"),	/* skip the [11] bit */
3905	"/boot/boot.b", strerror(errno));	while (*chptr && !isspace(*chptr))
3906	return 1;	chptr++;
3907	}	/* and move to the next one */
3908	close(fd);	while (*chptr && isspace(*chptr))
3909		chptr++;
3910		}
3911
3912		/*  we're good to go */
3913		return 2;
3914		}
3915
3916	if (!strncmp("/dev/md", line->elements[1].item, 7))	chptr = end + 1;
3917	return checkLiloOnRaid(line->elements[1].item, boot);	}
3918
3919	return checkDeviceBootloader(line->elements[1].item, boot);	fprintf(stderr,
3920		_("grubby: raid device /dev/%s not found in /proc/mdstat\n"),
3921		mdDev);
3922		return 0;
3923	}	}
3924
3925	int checkForGrub2(struct grubConfig * config) {	int checkForLilo(struct grubConfig *config)
3926	if (!access("/etc/grub.d/", R_OK))	{
3927	return 2;	int fd;
3928		unsigned char boot[512];
3929		struct singleLine *line;
3930
3931	return 1;	for (line = config->theLines; line; line = line->next)
3932	}	if (line->type == LT_BOOT)
3933		break;
3934
3935		if (!line) {
3936		fprintf(stderr,
3937		_
3938		("grubby: no boot line found in lilo configuration\n"));
3939		return 1;
3940		}
3941
3942	int checkForGrub(struct grubConfig * config) {	if (line->numElements != 2)
3943	int fd;	return 1;
	unsigned char bootSect[512];
	char * boot;
	int onSuse = isSuseSystem();
3944
3945		fd = open("/boot/boot.b", O_RDONLY);
3946		if (fd < 0) {
3947		fprintf(stderr, _("grubby: unable to open %s: %s\n"),
3948		"/boot/boot.b", strerror(errno));
3949		return 1;
3950		}
3951
3952	if (onSuse) {	if (read(fd, boot, 512) != 512) {
3953	if (parseSuseGrubConf(NULL, &boot))	fprintf(stderr, _("grubby: unable to read %s: %s\n"),
3954	return 0;	"/boot/boot.b", strerror(errno));
3955	} else {	return 1;
3956	if (parseSysconfigGrub(NULL, &boot))	}
3957	return 0;	close(fd);
	}
3958
3959	/* assume grub is not installed -- not an error condition */	if (!strncmp("/dev/md", line->elements[1].item, 7))
3960	if (!boot)	return checkLiloOnRaid(line->elements[1].item, boot);
	return 0;
3961
3962	fd = open("/boot/grub/stage1", O_RDONLY);	return checkDeviceBootloader(line->elements[1].item, boot);
3963	if (fd < 0)	}
3964	/* this doesn't exist if grub hasn't been installed */
3965	return 0;	int checkForGrub2(struct grubConfig *config)
3966		{
3967		if (!access("/etc/grub.d/", R_OK))
3968		return 2;
3969
	if (read(fd, bootSect, 512) != 512) {
	fprintf(stderr, _("grubby: unable to read %s: %s\n"),
	"/boot/grub/stage1", strerror(errno));
	close(fd);
3970	return 1;	return 1;
3971	}	}
	close(fd);
3972
3973	/* The more elaborate checks do not work on SuSE. The checks done	int checkForGrub(struct grubConfig *config)
3974	* seem to be reasonble (at least for now), so just return success	{
3975	*/	int fd;
3976	if (onSuse)	unsigned char bootSect[512];
3977	return 2;	char *boot;
3978		int onSuse = isSuseSystem();
3979
3980		if (onSuse) {
3981		if (parseSuseGrubConf(NULL, &boot))
3982		return 0;
3983		} else {
3984		if (parseSysconfigGrub(NULL, &boot))
3985		return 0;
3986		}
3987
3988		/* assume grub is not installed -- not an error condition */
3989		if (!boot)
3990		return 0;
3991
3992		fd = open("/boot/grub/stage1", O_RDONLY);
3993		if (fd < 0)
3994		/* this doesn't exist if grub hasn't been installed */
3995		return 0;
3996
3997		if (read(fd, bootSect, 512) != 512) {
3998		fprintf(stderr, _("grubby: unable to read %s: %s\n"),
3999		"/boot/grub/stage1", strerror(errno));
4000		close(fd);
4001		return 1;
4002		}
4003		close(fd);
4004
4005		/* The more elaborate checks do not work on SuSE. The checks done
4006		* seem to be reasonble (at least for now), so just return success
4007		*/
4008		if (onSuse)
4009		return 2;
4010
4011	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
4012	}	}
4013
4014	int checkForExtLinux(struct grubConfig * config) {	int checkForExtLinux(struct grubConfig *config)
4015	int fd;	{
4016	unsigned char bootSect[512];	int fd;
4017	char * boot;	unsigned char bootSect[512];
4018	char executable[] = "/boot/extlinux/extlinux";	char *boot;
4019		char executable[] = "/boot/extlinux/extlinux";
4020
4021	printf("entered: checkForExtLinux()\n");	printf("entered: checkForExtLinux()\n");
4022
4023	if (parseSysconfigGrub(NULL, &boot))	if (parseSysconfigGrub(NULL, &boot))
4024	return 0;	return 0;
4025
4026	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
4027	if (!boot)	if (!boot)
4028	return 0;	return 0;
4029
4030	fd = open(executable, O_RDONLY);	fd = open(executable, O_RDONLY);
4031	if (fd < 0)	if (fd < 0)
4032	/* this doesn't exist if grub hasn't been installed */	/* this doesn't exist if grub hasn't been installed */
4033	return 0;	return 0;
4034
4035	if (read(fd, bootSect, 512) != 512) {	if (read(fd, bootSect, 512) != 512) {
4036	fprintf(stderr, _("grubby: unable to read %s: %s\n"),	fprintf(stderr, _("grubby: unable to read %s: %s\n"),
4037	executable, strerror(errno));	executable, strerror(errno));
4038	return 1;	return 1;
4039	}	}
4040	close(fd);	close(fd);
4041
4042	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
4043	}	}
4044
4045	int checkForYaboot(struct grubConfig * config) {	int checkForYaboot(struct grubConfig *config)
4046	/*	{
4047	* This is a simplistic check that we consider good enough for own puporses	/*
4048	*	* This is a simplistic check that we consider good enough for own puporses
4049	* If we were to properly check if yaboot is *installed* we'd need to:	*
4050	* 1) get the system boot device (LT_BOOT)	* If we were to properly check if yaboot is *installed* we'd need to:
4051	* 2) considering it's a raw filesystem, check if the yaboot binary matches	* 1) get the system boot device (LT_BOOT)
4052	*    the content on the boot device	* 2) considering it's a raw filesystem, check if the yaboot binary matches
4053	* 3) if not, copy the binary to a temporary file and run "addnote" on it	*    the content on the boot device
4054	* 4) check again if binary and boot device contents match	* 3) if not, copy the binary to a temporary file and run "addnote" on it
4055	*/	* 4) check again if binary and boot device contents match
4056	if (!access("/etc/yaboot.conf", R_OK))	*/
4057	return 2;	if (!access("/etc/yaboot.conf", R_OK))
4058		return 2;
4059
4060	return 1;	return 1;
4061	}	}
4062
4063	int checkForElilo(struct grubConfig * config) {	int checkForElilo(struct grubConfig *config)
4064	if (!access("/etc/elilo.conf", R_OK))	{
4065	return 2;	if (!access("/etc/elilo.conf", R_OK))
4066		return 2;
4067
4068	return 1;	return 1;
4069	}	}
4070
4071	static char * getRootSpecifier(char * str) {	static char *getRootSpecifier(char *str)
4072	char * idx, * rootspec = NULL;	{
4073		char *idx, *rootspec = NULL;
4074
4075	if (*str == '(') {	if (*str == '(') {
4076	idx = rootspec = strdup(str);	idx = rootspec = strdup(str);
4077	while(*idx && (*idx != ')') && (!isspace(*idx))) idx++;	while (*idx && (*idx != ')') && (!isspace(*idx)))
4078	*(++idx) = '\0';	idx++;
4079	}	*(++idx) = '\0';
4080	return rootspec;	}
4081		return rootspec;
4082	}	}
4083
4084	static char * getInitrdVal(struct grubConfig * config,	static char *getInitrdVal(struct grubConfig *config,
4085	const char * prefix, struct singleLine *tmplLine,	const char *prefix, struct singleLine *tmplLine,
4086	const char * newKernelInitrd,	const char *newKernelInitrd,
4087	const char ** extraInitrds, int extraInitrdCount)	const char **extraInitrds, int extraInitrdCount)
4088	{	{
4089	char *initrdVal, *end;	char *initrdVal, *end;
4090	int i;	int i;
4091	size_t totalSize;	size_t totalSize;
4092	size_t prefixLen;	size_t prefixLen;
4093	char separatorChar;	char separatorChar;
4094
4095		prefixLen = strlen(prefix);
4096		totalSize = strlen(newKernelInitrd) - prefixLen + 1 /* \0 */ ;
4097
4098		for (i = 0; i < extraInitrdCount; i++) {
4099		totalSize += sizeof(separatorChar);
4100		totalSize += strlen(extraInitrds[i]) - prefixLen;
4101		}
4102
4103		initrdVal = end = malloc(totalSize);
4104
4105		end = stpcpy(end, newKernelInitrd + prefixLen);
4106
4107		separatorChar = getKeywordByType(LT_INITRD, config->cfi)->separatorChar;
4108		for (i = 0; i < extraInitrdCount; i++) {
4109		const char *extraInitrd;
4110		int j;
4111
4112		extraInitrd = extraInitrds[i] + prefixLen;
4113		/* Don't add entries that are already there */
4114		if (tmplLine != NULL) {
4115		for (j = 2; j < tmplLine->numElements; j++)
4116		if (strcmp
4117		(extraInitrd,
4118		tmplLine->elements[j].item) == 0)
4119		break;
4120
4121	prefixLen = strlen(prefix);	if (j != tmplLine->numElements)
4122	totalSize = strlen(newKernelInitrd) - prefixLen + 1 /* \0 */;	continue;
4123		}
4124
4125	for (i = 0; i < extraInitrdCount; i++) {	*end++ = separatorChar;
4126	totalSize += sizeof(separatorChar);	end = stpcpy(end, extraInitrd);
4127	totalSize += strlen(extraInitrds[i]) - prefixLen;	}
	}
4128
4129	initrdVal = end = malloc(totalSize);	return initrdVal;
4130		}
4131
4132	end = stpcpy (end, newKernelInitrd + prefixLen);	int addNewKernel(struct grubConfig *config, struct singleEntry *template,
4133		const char *prefix,
4134		const char *newKernelPath, const char *newKernelTitle,
4135		const char *newKernelArgs, const char *newKernelInitrd,
4136		const char **extraInitrds, int extraInitrdCount,
4137		const char *newMBKernel, const char *newMBKernelArgs,
4138		const char *newDevTreePath)
4139		{
4140		struct singleEntry *new;
4141		struct singleLine *newLine = NULL, *tmplLine = NULL, *masterLine = NULL;
4142		int needs;
4143		char *chptr;
4144
4145	separatorChar = getKeywordByType(LT_INITRD, config->cfi)->separatorChar;	if (!newKernelPath)
4146	for (i = 0; i < extraInitrdCount; i++) {	return 0;
	const char *extraInitrd;
	int j;
4147
4148	extraInitrd = extraInitrds[i] + prefixLen;	/* if the newKernelTitle is too long silently munge it into something
4149	/* Don't add entries that are already there */	* we can live with. truncating is first check, then we'll just mess with
4150	if (tmplLine != NULL) {	* it until it looks better */
4151	for (j = 2; j < tmplLine->numElements; j++)	if (config->cfi->maxTitleLength &&
	if (strcmp(extraInitrd, tmplLine->elements[j].item) == 0)
	break;
	if (j != tmplLine->numElements)
	continue;
	}
	*end++ = separatorChar;
	end = stpcpy(end, extraInitrd);
	}
	return initrdVal;
	}
	int addNewKernel(struct grubConfig * config, struct singleEntry * template,
	const char * prefix,
	const char * newKernelPath, const char * newKernelTitle,
	const char * newKernelArgs, const char * newKernelInitrd,
	const char ** extraInitrds, int extraInitrdCount,
	const char * newMBKernel, const char * newMBKernelArgs) {
	struct singleEntry * new;
	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
	int needs;
	char * chptr;
	if (!newKernelPath) return 0;
	/* if the newKernelTitle is too long silently munge it into something
	* we can live with. truncating is first check, then we'll just mess with
	* it until it looks better */
	if (config->cfi->maxTitleLength &&
4152	(strlen(newKernelTitle) > config->cfi->maxTitleLength)) {	(strlen(newKernelTitle) > config->cfi->maxTitleLength)) {
4153	char * buf = alloca(config->cfi->maxTitleLength + 7);	char *buf = alloca(config->cfi->maxTitleLength + 7);
4154	char * numBuf = alloca(config->cfi->maxTitleLength + 1);	char *numBuf = alloca(config->cfi->maxTitleLength + 1);
4155	int i = 1;	int i = 1;
4156
4157	sprintf(buf, "TITLE=%.*s", config->cfi->maxTitleLength, newKernelTitle);	sprintf(buf, "TITLE=%.*s", config->cfi->maxTitleLength,
4158	while (findEntryByPath(config, buf, NULL, NULL)) {	newKernelTitle);
4159	sprintf(numBuf, "%d", i++);	while (findEntryByPath(config, buf, NULL, NULL)) {
4160	strcpy(buf + strlen(buf) - strlen(numBuf), numBuf);	sprintf(numBuf, "%d", i++);
4161	}	strcpy(buf + strlen(buf) - strlen(numBuf), numBuf);
4162		}
4163	newKernelTitle = buf + 6;
4164	}	newKernelTitle = buf + 6;
	new = malloc(sizeof(*new));
	new->skip = 0;
	new->multiboot = 0;
	new->next = config->entries;
	new->lines = NULL;
	config->entries = new;
	/* copy/update from the template */
	needs = NEED_KERNEL | NEED_TITLE;
	if (newKernelInitrd)
	needs |= NEED_INITRD;
	if (newMBKernel) {
	needs |= NEED_MB;
	new->multiboot = 1;
	}
	if (template) {
	for (masterLine = template->lines;
	masterLine && (tmplLine = lineDup(masterLine));
	lineFree(tmplLine), masterLine = masterLine->next)
	{
	dbgPrintf("addNewKernel processing %d\n", tmplLine->type);
	/* skip comments */
	chptr = tmplLine->indent;
	while (*chptr && isspace(*chptr)) chptr++;
	if (*chptr == '#') continue;
	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
	if (!template->multiboot && (needs & NEED_MB)) {
	/* it's not a multiboot template and this is the kernel
	* line.  Try to be intelligent about inserting the
	* hypervisor at the same time.
	*/
	if (config->cfi->mbHyperFirst) {
	/* insert the hypervisor first */
	newLine = addLine(new, config->cfi, LT_HYPER,
	tmplLine->indent,
	newMBKernel + strlen(prefix));
	/* set up for adding the kernel line */
	free(tmplLine->indent);
	tmplLine->indent = strdup(config->secondaryIndent);
	needs &= ~NEED_MB;
	}
	if (needs & NEED_KERNEL) {
	/* use addLineTmpl to preserve line elements,
	* otherwise we could just call addLine.  Unfortunately
	* this means making some changes to the template
	* such as the indent change above and the type
	* change below.
	*/
	struct keywordTypes * mbm_kw =
	getKeywordByType(LT_MBMODULE, config->cfi);
	if (mbm_kw) {
	tmplLine->type = LT_MBMODULE;
	free(tmplLine->elements[0].item);
	tmplLine->elements[0].item = strdup(mbm_kw->key);
	}
	newLine = addLineTmpl(new, tmplLine, newLine,
	newKernelPath + strlen(prefix), config->cfi);
	needs &= ~NEED_KERNEL;
	}
	if (needs & NEED_MB) { /* !mbHyperFirst */
	newLine = addLine(new, config->cfi, LT_HYPER,
	config->secondaryIndent,
	newMBKernel + strlen(prefix));
	needs &= ~NEED_MB;
	}
	} else if (needs & NEED_KERNEL) {
	newLine = addLineTmpl(new, tmplLine, newLine,
	newKernelPath + strlen(prefix), config->cfi);
	needs &= ~NEED_KERNEL;
	}
	} else if (tmplLine->type == LT_HYPER &&
	tmplLine->numElements >= 2) {
	if (needs & NEED_MB) {
	newLine = addLineTmpl(new, tmplLine, newLine,
	newMBKernel + strlen(prefix), config->cfi);
	needs &= ~NEED_MB;
	}
	} else if (tmplLine->type == LT_MBMODULE &&
	tmplLine->numElements >= 2) {
	if (new->multiboot) {
	if (needs & NEED_KERNEL) {
	newLine = addLineTmpl(new, tmplLine, newLine,
	newKernelPath +
	strlen(prefix), config->cfi);
	needs &= ~NEED_KERNEL;
	} else if (config->cfi->mbInitRdIsModule &&
	(needs & NEED_INITRD)) {
	char *initrdVal;
	initrdVal = getInitrdVal(config, prefix, tmplLine,
	newKernelInitrd, extraInitrds,
	extraInitrdCount);
	newLine = addLineTmpl(new, tmplLine, newLine,
	initrdVal, config->cfi);
	free(initrdVal);
	needs &= ~NEED_INITRD;
	}
	} else if (needs & NEED_KERNEL) {
	/* template is multi but new is not,
	* insert the kernel in the first module slot
	*/
	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
	free(tmplLine->elements[0].item);
	tmplLine->elements[0].item =
	strdup(getKeywordByType(tmplLine->type,
	config->cfi)->key);
	newLine = addLineTmpl(new, tmplLine, newLine,
	newKernelPath + strlen(prefix),
	config->cfi);
	needs &= ~NEED_KERNEL;
	} else if (needs & NEED_INITRD) {
	char *initrdVal;
	/* template is multi but new is not,
	* insert the initrd in the second module slot
	*/
	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
	free(tmplLine->elements[0].item);
	tmplLine->elements[0].item =
	strdup(getKeywordByType(tmplLine->type,
	config->cfi)->key);
	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
	free(initrdVal);
	needs &= ~NEED_INITRD;
	}
	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
	if (needs & NEED_INITRD &&
	new->multiboot && !template->multiboot &&
	config->cfi->mbInitRdIsModule) {
	/* make sure we don't insert the module initrd
	* before the module kernel... if we don't do it here,
	* it will be inserted following the template.
	*/
	if (!needs & NEED_KERNEL) {
	char *initrdVal;
	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
	newLine = addLine(new, config->cfi, LT_MBMODULE,
	config->secondaryIndent,
	initrdVal);
	free(initrdVal);
	needs &= ~NEED_INITRD;
	}
	} else if (needs & NEED_INITRD) {
	char *initrdVal;
	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
	free(initrdVal);
	needs &= ~NEED_INITRD;
	}
	} else if (tmplLine->type == LT_MENUENTRY &&
	(needs & NEED_TITLE)) {
	requote(tmplLine, config->cfi);
	char *nkt = malloc(strlen(newKernelTitle)+3);
	strcpy(nkt, "'");
	strcat(nkt, newKernelTitle);
	strcat(nkt, "'");
	newLine = addLineTmpl(new, tmplLine, newLine, nkt, config->cfi);
	free(nkt);
	needs &= ~NEED_TITLE;
	} else if (tmplLine->type == LT_TITLE &&
	(needs & NEED_TITLE)) {
	if (tmplLine->numElements >= 2) {
	newLine = addLineTmpl(new, tmplLine, newLine,
	newKernelTitle, config->cfi);
	needs &= ~NEED_TITLE;
	} else if (tmplLine->numElements == 1 &&
	config->cfi->titleBracketed) {
	/* addLineTmpl doesn't handle titleBracketed */
	newLine = addLine(new, config->cfi, LT_TITLE,
	tmplLine->indent, newKernelTitle);
	needs &= ~NEED_TITLE;
	}
	} else if (tmplLine->type == LT_ECHO) {
	requote(tmplLine, config->cfi);
	static const char *prefix = "'Loading ";
	if (tmplLine->numElements > 1 &&
	strstr(tmplLine->elements[1].item, prefix) &&
	masterLine->next &&
	iskernel(masterLine->next->type)) {
	char *newTitle = malloc(strlen(prefix) +
	strlen(newKernelTitle) + 2);
	strcpy(newTitle, prefix);
	strcat(newTitle, newKernelTitle);
	strcat(newTitle, "'");
	newLine = addLine(new, config->cfi, LT_ECHO,
	tmplLine->indent, newTitle);
	free(newTitle);
	} else {
	/* pass through other lines from the template */
	newLine = addLineTmpl(new, tmplLine, newLine, NULL,
	config->cfi);
	}
	} else {
	/* pass through other lines from the template */
	newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
	}
4165	}	}
4166
4167	} else {	new = malloc(sizeof(*new));
4168	/* don't have a template, so start the entry with the	new->skip = 0;
4169	* appropriate starting line	new->multiboot = 0;
4170	*/	new->next = config->entries;
4171	switch (config->cfi->entryStart) {	new->lines = NULL;
4172	case LT_KERNEL:	config->entries = new;
4173	case LT_KERNEL_EFI:
4174	if (new->multiboot && config->cfi->mbHyperFirst) {	/* copy/update from the template */
4175	/* fall through to LT_HYPER */	needs = NEED_KERNEL | NEED_TITLE;
4176	} else {	if (newKernelInitrd)
4177	newLine = addLine(new, config->cfi,	needs |= NEED_INITRD;
4178	preferredLineType(LT_KERNEL, config->cfi),	if (newMBKernel) {
4179	config->primaryIndent,	needs |= NEED_MB;
4180	newKernelPath + strlen(prefix));	new->multiboot = 1;
4181	needs &= ~NEED_KERNEL;	}
4182	break;	if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
4183		needs |= NEED_DEVTREE;
4184
4185		if (template) {
4186		for (masterLine = template->lines;
4187		masterLine && (tmplLine = lineDup(masterLine));
4188		lineFree(tmplLine), masterLine = masterLine->next) {
4189		dbgPrintf("addNewKernel processing %d\n",
4190		tmplLine->type);
4191
4192		/* skip comments */
4193		chptr = tmplLine->indent;
4194		while (*chptr && isspace(*chptr))
4195		chptr++;
4196		if (*chptr == '#')
4197		continue;
4198
4199		if (iskernel(tmplLine->type)
4200		&& tmplLine->numElements >= 2) {
4201		if (!template->multiboot && (needs & NEED_MB)) {
4202		/* it's not a multiboot template and
4203		* this is the kernel line.  Try to
4204		* be intelligent about inserting the
4205		* hypervisor at the same time.
4206		*/
4207		if (config->cfi->mbHyperFirst) {
4208		/* insert the hypervisor first */
4209		newLine =
4210		addLine(new, config->cfi,
4211		LT_HYPER,
4212		tmplLine->indent,
4213		newMBKernel +
4214		strlen(prefix));
4215		/* set up for adding the
4216		* kernel line */
4217		free(tmplLine->indent);
4218		tmplLine->indent =
4219		strdup(config->
4220		secondaryIndent);
4221		needs &= ~NEED_MB;
4222		}
4223		if (needs & NEED_KERNEL) {
4224		/* use addLineTmpl to
4225		* preserve line elements,
4226		* otherwise we could just
4227		* call addLine.
4228		* Unfortunately this means
4229		* making some changes to the
4230		* template such as the
4231		* indent change above and
4232		* the type change below.
4233		*/
4234		struct keywordTypes *mbm_kw =
4235		getKeywordByType
4236		(LT_MBMODULE, config->cfi);
4237		if (mbm_kw) {
4238		tmplLine->type =
4239		LT_MBMODULE;
4240		free(tmplLine->
4241		elements[0].item);
4242		tmplLine->elements[0].
4243		item =
4244		strdup(mbm_kw->key);
4245		}
4246		newLine =
4247		addLineTmpl(new, tmplLine,
4248		newLine,
4249		newKernelPath +
4250		strlen(prefix),
4251		config->cfi);
4252		needs &= ~NEED_KERNEL;
4253		}
4254		if (needs & NEED_MB) { /* !mbHyperFirst */
4255		newLine =
4256		addLine(new, config->cfi,
4257		LT_HYPER,
4258		config->
4259		secondaryIndent,
4260		newMBKernel +
4261		strlen(prefix));
4262		needs &= ~NEED_MB;
4263		}
4264		} else if (needs & NEED_KERNEL) {
4265		newLine =
4266		addLineTmpl(new, tmplLine, newLine,
4267		newKernelPath +
4268		strlen(prefix),
4269		config->cfi);
4270		needs &= ~NEED_KERNEL;
4271		}
4272
4273		} else if (tmplLine->type == LT_HYPER &&
4274		tmplLine->numElements >= 2) {
4275		if (needs & NEED_MB) {
4276		newLine =
4277		addLineTmpl(new, tmplLine, newLine,
4278		newMBKernel +
4279		strlen(prefix),
4280		config->cfi);
4281		needs &= ~NEED_MB;
4282		}
4283
4284		} else if (tmplLine->type == LT_MBMODULE &&
4285		tmplLine->numElements >= 2) {
4286		if (new->multiboot) {
4287		if (needs & NEED_KERNEL) {
4288		newLine =
4289		addLineTmpl(new, tmplLine,
4290		newLine,
4291		newKernelPath +
4292		strlen(prefix),
4293		config->cfi);
4294		needs &= ~NEED_KERNEL;
4295		} else if (config->cfi->mbInitRdIsModule
4296		&& (needs & NEED_INITRD)) {
4297		char *initrdVal;
4298		initrdVal =
4299		getInitrdVal(config, prefix,
4300		tmplLine,
4301		newKernelInitrd,
4302		extraInitrds,
4303		extraInitrdCount);
4304		newLine =
4305		addLineTmpl(new, tmplLine,
4306		newLine,
4307		initrdVal,
4308		config->cfi);
4309		free(initrdVal);
4310		needs &= ~NEED_INITRD;
4311		}
4312		} else if (needs & NEED_KERNEL) {
4313		/* template is multi but new is not,
4314		* insert the kernel in the first
4315		* module slot
4316		*/
4317		tmplLine->type =
4318		preferredLineType(LT_KERNEL,
4319		config->cfi);
4320		free(tmplLine->elements[0].item);
4321		tmplLine->elements[0].item =
4322		strdup(getKeywordByType
4323		(tmplLine->type,
4324		config->cfi)->key);
4325		newLine =
4326		addLineTmpl(new, tmplLine, newLine,
4327		newKernelPath +
4328		strlen(prefix),
4329		config->cfi);
4330		needs &= ~NEED_KERNEL;
4331		} else if (needs & NEED_INITRD) {
4332		char *initrdVal;
4333		/* template is multi but new is not,
4334		* insert the initrd in the second
4335		* module slot
4336		*/
4337		tmplLine->type =
4338		preferredLineType(LT_INITRD,
4339		config->cfi);
4340		free(tmplLine->elements[0].item);
4341		tmplLine->elements[0].item =
4342		strdup(getKeywordByType
4343		(tmplLine->type,
4344		config->cfi)->key);
4345		initrdVal =
4346		getInitrdVal(config, prefix,
4347		tmplLine,
4348		newKernelInitrd,
4349		extraInitrds,
4350		extraInitrdCount);
4351		newLine =
4352		addLineTmpl(new, tmplLine, newLine,
4353		initrdVal, config->cfi);
4354		free(initrdVal);
4355		needs &= ~NEED_INITRD;
4356		}
4357
4358		} else if (isinitrd(tmplLine->type)
4359		&& tmplLine->numElements >= 2) {
4360		if (needs & NEED_INITRD && new->multiboot
4361		&& !template->multiboot
4362		&& config->cfi->mbInitRdIsModule) {
4363		/* make sure we don't insert the
4364		* module initrd before the module
4365		* kernel... if we don't do it here,
4366		* it will be inserted following the
4367		* template.
4368		*/
4369		if (!needs & NEED_KERNEL) {
4370		char *initrdVal;
4371
4372		initrdVal =
4373		getInitrdVal(config, prefix,
4374		tmplLine,
4375		newKernelInitrd,
4376		extraInitrds,
4377		extraInitrdCount);
4378		newLine =
4379		addLine(new, config->cfi,
4380		LT_MBMODULE,
4381		config->
4382		secondaryIndent,
4383		initrdVal);
4384		free(initrdVal);
4385		needs &= ~NEED_INITRD;
4386		}
4387		} else if (needs & NEED_INITRD) {
4388		char *initrdVal;
4389		initrdVal =
4390		getInitrdVal(config, prefix,
4391		tmplLine,
4392		newKernelInitrd,
4393		extraInitrds,
4394		extraInitrdCount);
4395		newLine =
4396		addLineTmpl(new, tmplLine, newLine,
4397		initrdVal, config->cfi);
4398		free(initrdVal);
4399		needs &= ~NEED_INITRD;
4400		}
4401
4402		} else if (tmplLine->type == LT_MENUENTRY &&
4403		(needs & NEED_TITLE)) {
4404		requote(tmplLine, config->cfi);
4405		char *nkt = malloc(strlen(newKernelTitle) + 3);
4406		strcpy(nkt, "'");
4407		strcat(nkt, newKernelTitle);
4408		strcat(nkt, "'");
4409		newLine =
4410		addLineTmpl(new, tmplLine, newLine, nkt,
4411		config->cfi);
4412		free(nkt);
4413		needs &= ~NEED_TITLE;
4414		} else if (tmplLine->type == LT_TITLE &&
4415		(needs & NEED_TITLE)) {
4416		if (tmplLine->numElements >= 2) {
4417		newLine =
4418		addLineTmpl(new, tmplLine, newLine,
4419		newKernelTitle,
4420		config->cfi);
4421		needs &= ~NEED_TITLE;
4422		} else if (tmplLine->numElements == 1 &&
4423		config->cfi->titleBracketed) {
4424		/* addLineTmpl doesn't handle
4425		* titleBracketed */
4426		newLine =
4427		addLine(new, config->cfi, LT_TITLE,
4428		tmplLine->indent,
4429		newKernelTitle);
4430		needs &= ~NEED_TITLE;
4431		}
4432		} else if (tmplLine->type == LT_ECHO) {
4433		requote(tmplLine, config->cfi);
4434		static const char *prefix = "'Loading ";
4435		if (tmplLine->numElements > 1 &&
4436		strstr(tmplLine->elements[1].item, prefix)
4437		&& masterLine->next
4438		&& iskernel(masterLine->next->type)) {
4439		char *newTitle =
4440		malloc(strlen(prefix) +
4441		strlen(newKernelTitle) + 2);
4442
4443		strcpy(newTitle, prefix);
4444		strcat(newTitle, newKernelTitle);
4445		strcat(newTitle, "'");
4446		newLine =
4447		addLine(new, config->cfi, LT_ECHO,
4448		tmplLine->indent, newTitle);
4449		free(newTitle);
4450		} else {
4451		/* pass through other lines from the
4452		* template */
4453		newLine =
4454		addLineTmpl(new, tmplLine, newLine,
4455		NULL, config->cfi);
4456		}
4457		} else if (tmplLine->type == LT_DEVTREE &&
4458		tmplLine->numElements == 2
4459		&& newDevTreePath) {
4460		newLine =
4461		addLineTmpl(new, tmplLine, newLine,
4462		newDevTreePath + strlen(prefix),
4463		config->cfi);
4464		needs &= ~NEED_DEVTREE;
4465		} else if (tmplLine->type == LT_ENTRY_END
4466		&& needs & NEED_DEVTREE) {
4467		const char *ndtp = newDevTreePath;
4468		if (!strncmp
4469		(newDevTreePath, prefix, strlen(prefix)))
4470		ndtp += strlen(prefix);
4471		newLine = addLine(new, config->cfi, LT_DEVTREE,
4472		config->secondaryIndent,
4473		ndtp);
4474		needs &= ~NEED_DEVTREE;
4475		newLine =
4476		addLineTmpl(new, tmplLine, newLine, NULL,
4477		config->cfi);
4478		} else {
4479		/* pass through other lines from the template */
4480		newLine =
4481		addLineTmpl(new, tmplLine, newLine, NULL,
4482		config->cfi);
4483		}
4484	}	}
4485
4486	case LT_HYPER:	} else {
4487	newLine = addLine(new, config->cfi, LT_HYPER,	/* don't have a template, so start the entry with the
4488	config->primaryIndent,	* appropriate starting line
4489	newMBKernel + strlen(prefix));	*/
4490	needs &= ~NEED_MB;	switch (config->cfi->entryStart) {
4491	break;	case LT_KERNEL:
4492		case LT_KERNEL_EFI:
4493		case LT_KERNEL_16:
4494		if (new->multiboot && config->cfi->mbHyperFirst) {
4495		/* fall through to LT_HYPER */
4496		} else {
4497		newLine = addLine(new, config->cfi,
4498		preferredLineType(LT_KERNEL,
4499		config->
4500		cfi),
4501		config->primaryIndent,
4502		newKernelPath +
4503		strlen(prefix));
4504		needs &= ~NEED_KERNEL;
4505		break;
4506		}
4507
4508	case LT_MENUENTRY: {	case LT_HYPER:
4509	char *nkt = malloc(strlen(newKernelTitle)+3);	newLine = addLine(new, config->cfi, LT_HYPER,
4510	strcpy(nkt, "'");	config->primaryIndent,
4511	strcat(nkt, newKernelTitle);	newMBKernel + strlen(prefix));
4512	strcat(nkt, "'");	needs &= ~NEED_MB;
4513	newLine = addLine(new, config->cfi, LT_MENUENTRY,	break;
4514	config->primaryIndent, nkt);
4515	free(nkt);	case LT_MENUENTRY:{
4516	needs &= ~NEED_TITLE;	char *nkt = malloc(strlen(newKernelTitle) + 3);
4517	needs |= NEED_END;	strcpy(nkt, "'");
4518	break;	strcat(nkt, newKernelTitle);
4519	}	strcat(nkt, "'");
4520	case LT_TITLE:	newLine =
4521	if( useextlinuxmenu != 0 ){ // We just need useextlinuxmenu to not be zero (set above)	addLine(new, config->cfi, LT_MENUENTRY,
4522	char * templabel;	config->primaryIndent, nkt);
4523	int x = 0, y = 0;	free(nkt);
4524		needs &= ~NEED_TITLE;
4525	templabel = strdup(newKernelTitle);	needs |= NEED_END;
4526	while( templabel[x]){	break;
4527	if( templabel[x] == ' ' ){	}
4528	y = x;	case LT_TITLE:
4529	while( templabel[y] ){	if (useextlinuxmenu != 0) { // We just need useextlinuxmenu to not be zero (set above)
4530	templabel[y] = templabel[y+1];	char *templabel;
4531	y++;	int x = 0, y = 0;
4532
4533		templabel = strdup(newKernelTitle);
4534		while (templabel[x]) {
4535		if (templabel[x] == ' ') {
4536		y = x;
4537		while (templabel[y]) {
4538		templabel[y] =
4539		templabel[y + 1];
4540		y++;
4541		}
4542	}	}
4543		x++;
4544	}	}
4545	x++;	newLine = addLine(new, config->cfi, LT_TITLE,
4546		config->primaryIndent,
4547		templabel);
4548		free(templabel);
4549		} else {
4550		newLine = addLine(new, config->cfi, LT_TITLE,
4551		config->primaryIndent,
4552		newKernelTitle);
4553	}	}
4554	newLine = addLine(new, config->cfi, LT_TITLE,	needs &= ~NEED_TITLE;
4555	config->primaryIndent, templabel);	break;
4556	free(templabel);
4557	}else{	default:
4558	newLine = addLine(new, config->cfi, LT_TITLE,	abort();
	config->primaryIndent, newKernelTitle);
4559	}	}
4560		}
4561
4562		struct singleLine *endLine = NULL;
4563		endLine = getLineByType(LT_ENTRY_END, new->lines);
4564		if (endLine) {
4565		removeLine(new, endLine);
4566		needs |= NEED_END;
4567		}
4568
4569		/* add the remainder of the lines, i.e. those that either
4570		* weren't present in the template, or in the case of no template,
4571		* all the lines following the entryStart.
4572		*/
4573		if (needs & NEED_TITLE) {
4574		newLine = addLine(new, config->cfi, LT_TITLE,
4575		config->secondaryIndent, newKernelTitle);
4576	needs &= ~NEED_TITLE;	needs &= ~NEED_TITLE;
4577	break;	}
4578		if ((needs & NEED_MB) && config->cfi->mbHyperFirst) {
4579		newLine = addLine(new, config->cfi, LT_HYPER,
4580		config->secondaryIndent,
4581		newMBKernel + strlen(prefix));
4582		needs &= ~NEED_MB;
4583		}
4584		if (needs & NEED_KERNEL) {
4585		newLine = addLine(new, config->cfi,
4586		(new->multiboot
4587		&& getKeywordByType(LT_MBMODULE,
4588		config->cfi))
4589		? LT_MBMODULE : preferredLineType(LT_KERNEL,
4590		config->
4591		cfi),
4592		config->secondaryIndent,
4593		newKernelPath + strlen(prefix));
4594		needs &= ~NEED_KERNEL;
4595		}
4596		if (needs & NEED_MB) {
4597		newLine = addLine(new, config->cfi, LT_HYPER,
4598		config->secondaryIndent,
4599		newMBKernel + strlen(prefix));
4600		needs &= ~NEED_MB;
4601		}
4602		if (needs & NEED_INITRD) {
4603		char *initrdVal;
4604		initrdVal =
4605		getInitrdVal(config, prefix, NULL, newKernelInitrd,
4606		extraInitrds, extraInitrdCount);
4607		newLine =
4608		addLine(new, config->cfi,
4609		(new->multiboot
4610		&& getKeywordByType(LT_MBMODULE, config->cfi))
4611		? LT_MBMODULE : preferredLineType(LT_INITRD,
4612		config->cfi),
4613		config->secondaryIndent, initrdVal);
4614		free(initrdVal);
4615		needs &= ~NEED_INITRD;
4616		}
4617		if (needs & NEED_DEVTREE) {
4618		newLine = addLine(new, config->cfi, LT_DEVTREE,
4619		config->secondaryIndent, newDevTreePath);
4620		needs &= ~NEED_DEVTREE;
4621		}
4622
4623		/* NEEDS_END must be last on bootloaders that need it... */
4624		if (needs & NEED_END) {
4625		newLine = addLine(new, config->cfi, LT_ENTRY_END,
4626		config->secondaryIndent, NULL);
4627		needs &= ~NEED_END;
4628		}
4629
4630	default:	if (needs) {
4631		printf(_("grubby: needs=%d, aborting\n"), needs);
4632	abort();	abort();
4633	}	}
	}
4634
4635	/* add the remainder of the lines, i.e. those that either	if (updateImage(config, "0", prefix, newKernelArgs, NULL,
4636	* weren't present in the template, or in the case of no template,	newMBKernelArgs, NULL))
4637	* all the lines following the entryStart.	return 1;
4638	*/
4639	if (needs & NEED_TITLE) {	return 0;
4640	newLine = addLine(new, config->cfi, LT_TITLE,	}
4641	config->secondaryIndent,
4642	newKernelTitle);	int main(int argc, const char **argv)
4643	needs &= ~NEED_TITLE;	{
4644	}	poptContext optCon;
4645	if ((needs & NEED_MB) && config->cfi->mbHyperFirst) {	const char *grubConfig = NULL;
4646	newLine = addLine(new, config->cfi, LT_HYPER,	char *outputFile = NULL;
4647	config->secondaryIndent,	int arg = 0;
4648	newMBKernel + strlen(prefix));	int flags = 0;
4649	needs &= ~NEED_MB;	int badImageOkay = 0;
4650	}	int configureGrub2 = 0;
4651	if (needs & NEED_KERNEL) {	int configureLilo = 0, configureELilo = 0, configureGrub = 0;
4652	newLine = addLine(new, config->cfi,	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;
4653	(new->multiboot && getKeywordByType(LT_MBMODULE,	int configureExtLinux = 0;
4654	config->cfi))	int bootloaderProbe = 0;
4655	? LT_MBMODULE	int extraInitrdCount = 0;
4656	: preferredLineType(LT_KERNEL, config->cfi),	char *updateKernelPath = NULL;
4657	config->secondaryIndent,	char *newKernelPath = NULL;
4658	newKernelPath + strlen(prefix));	char *removeKernelPath = NULL;
4659	needs &= ~NEED_KERNEL;	char *newKernelArgs = NULL;
4660	}	char *newKernelInitrd = NULL;
4661	if (needs & NEED_MB) {	char *newKernelTitle = NULL;
4662	newLine = addLine(new, config->cfi, LT_HYPER,	char *newDevTreePath = NULL;
4663	config->secondaryIndent,	char *newMBKernel = NULL;
4664	newMBKernel + strlen(prefix));	char *newMBKernelArgs = NULL;
4665	needs &= ~NEED_MB;	char *removeMBKernelArgs = NULL;
4666	}	char *removeMBKernel = NULL;
4667	if (needs & NEED_INITRD) {	char *bootPrefix = NULL;
4668	char *initrdVal;	char *defaultKernel = NULL;
4669	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);	char *removeArgs = NULL;
4670	newLine = addLine(new, config->cfi,	char *kernelInfo = NULL;
4671	(new->multiboot && getKeywordByType(LT_MBMODULE,	char *extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4672	config->cfi))	char *envPath = NULL;
4673	? LT_MBMODULE	const char *chptr = NULL;
4674	: preferredLineType(LT_INITRD, config->cfi),	struct configFileInfo *cfi = NULL;
4675	config->secondaryIndent,	struct grubConfig *config;
4676	initrdVal);	struct singleEntry *template = NULL;
4677	free(initrdVal);	int copyDefault = 0, makeDefault = 0;
4678	needs &= ~NEED_INITRD;	int displayDefault = 0;
4679	}	int displayDefaultIndex = 0;
4680	if (needs & NEED_END) {	int displayDefaultTitle = 0;
4681	newLine = addLine(new, config->cfi, LT_ENTRY_END,	int defaultIndex = -1;
4682	config->secondaryIndent, NULL);	struct poptOption options[] = {
4683	needs &= ~NEED_END;	{"add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4684	}	_("add an entry for the specified kernel"), _("kernel-path")},
4685		{"add-multiboot", 0, POPT_ARG_STRING, &newMBKernel, 0,
4686	if (needs) {	_("add an entry for the specified multiboot kernel"), NULL},
4687	printf(_("grubby: needs=%d, aborting\n"), needs);	{"args", 0, POPT_ARG_STRING, &newKernelArgs, 0,
4688	abort();	_("default arguments for the new kernel or new arguments for "
4689	}	"kernel being updated"), _("args")},
4690		{"mbargs", 0, POPT_ARG_STRING, &newMBKernelArgs, 0,
4691	if (updateImage(config, "0", prefix, newKernelArgs, NULL,	_("default arguments for the new multiboot kernel or "
4692	newMBKernelArgs, NULL)) return 1;	"new arguments for multiboot kernel being updated"), NULL},
4693		{"bad-image-okay", 0, 0, &badImageOkay, 0,
4694	return 0;	_
4695	}	("don't sanity check images in boot entries (for testing only)"),
4696		NULL},
4697	static void traceback(int signum)	{"boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4698	{	_
4699	void *array[40];	("filestystem which contains /boot directory (for testing only)"),
4700	size_t size;	_("bootfs")},
	signal(SIGSEGV, SIG_DFL);
	memset(array, '\0', sizeof (array));
	size = backtrace(array, 40);
	fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",
	(unsigned long)size);
	backtrace_symbols_fd(array, size, STDERR_FILENO);
	exit(1);
	}
	int main(int argc, const char ** argv) {
	poptContext optCon;
	const char * grubConfig = NULL;
	char * outputFile = NULL;
	int arg = 0;
	int flags = 0;
	int badImageOkay = 0;
	int configureGrub2 = 0;
	int configureLilo = 0, configureELilo = 0, configureGrub = 0;
	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;
	int configureExtLinux = 0;
	int bootloaderProbe = 0;
	int extraInitrdCount = 0;
	char * updateKernelPath = NULL;
	char * newKernelPath = NULL;
	char * removeKernelPath = NULL;
	char * newKernelArgs = NULL;
	char * newKernelInitrd = NULL;
	char * newKernelTitle = NULL;
	char * newKernelVersion = NULL;
	char * newMBKernel = NULL;
	char * newMBKernelArgs = NULL;
	char * removeMBKernelArgs = NULL;
	char * removeMBKernel = NULL;
	char * bootPrefix = NULL;
	char * defaultKernel = NULL;
	char * removeArgs = NULL;
	char * kernelInfo = NULL;
	char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
	const char * chptr = NULL;
	struct configFileInfo * cfi = NULL;
	struct grubConfig * config;
	struct singleEntry * template = NULL;
	int copyDefault = 0, makeDefault = 0;
	int displayDefault = 0;
	int displayDefaultIndex = 0;
	int displayDefaultTitle = 0;
	int defaultIndex = -1;
	struct poptOption options[] = {
	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
	_("add an entry for the specified kernel"), _("kernel-path") },
	{ "add-multiboot", 0, POPT_ARG_STRING, &newMBKernel, 0,
	_("add an entry for the specified multiboot kernel"), NULL },
	{ "args", 0, POPT_ARG_STRING, &newKernelArgs, 0,
	_("default arguments for the new kernel or new arguments for "
	"kernel being updated"), _("args") },
	{ "mbargs", 0, POPT_ARG_STRING, &newMBKernelArgs, 0,
	_("default arguments for the new multiboot kernel or "
	"new arguments for multiboot kernel being updated"), NULL },
	{ "bad-image-okay", 0, 0, &badImageOkay, 0,
	_("don't sanity check images in boot entries (for testing only)"),
	NULL },
	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
	_("filestystem which contains /boot directory (for testing only)"),
	_("bootfs") },
4701	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4702	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{"bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4703	_("check which bootloader is installed on boot sector") },	_("check which bootloader is installed on boot sector")},
4704	#endif	#endif
4705	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{"config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4706	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
4707	_("path") },	_("path")},
4708	{ "copy-default", 0, 0, &copyDefault, 0,	{"copy-default", 0, 0, &copyDefault, 0,
4709	_("use the default boot entry as a template for the new entry "	_("use the default boot entry as a template for the new entry "
4710	"being added; if the default is not a linux image, or if "	"being added; if the default is not a linux image, or if "
4711	"the kernel referenced by the default image does not exist, "	"the kernel referenced by the default image does not exist, "
4712	"the first linux entry whose kernel does exist is used as the "	"the first linux entry whose kernel does exist is used as the "
4713	"template"), NULL },	"template"), NULL},
4714	{ "debug", 0, 0, &debug, 0,	{"debug", 0, 0, &debug, 0,
4715	_("print debugging information for failures") },	_("print debugging information for failures")},
4716	{ "default-kernel", 0, 0, &displayDefault, 0,	{"default-kernel", 0, 0, &displayDefault, 0,
4717	_("display the path of the default kernel") },	_("display the path of the default kernel")},
4718	{ "default-index", 0, 0, &displayDefaultIndex, 0,	{"default-index", 0, 0, &displayDefaultIndex, 0,
4719	_("display the index of the default kernel") },	_("display the index of the default kernel")},
4720	{ "default-title", 0, 0, &displayDefaultTitle, 0,	{"default-title", 0, 0, &displayDefaultTitle, 0,
4721	_("display the title of the default kernel") },	_("display the title of the default kernel")},
4722	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{"devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4723	_("configure elilo bootloader") },	_("device tree file for new stanza"), _("dtb-path")},
4724	{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,	{"devtreedir", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4725	_("force grub2 stanzas to use efi") },	_("device tree directory for new stanza"), _("dtb-path")},
4726	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,	{"elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4727	_("configure extlinux bootloader (from syslinux)") },	_("configure elilo bootloader")},
4728	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{"efi", 0, POPT_ARG_NONE, &isEfi, 0,
4729	_("configure grub bootloader") },	_("force grub2 stanzas to use efi")},
4730	{ "grub2", 0, POPT_ARG_NONE, &configureGrub2, 0,	{"env", 0, POPT_ARG_STRING, &envPath, 0,
4731	_("configure grub2 bootloader") },	_("path for environment data"),
4732	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,	_("path")},
4733	_("display boot information for specified kernel"),	{"extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4734	_("kernel-path") },	_("configure extlinux bootloader (from syslinux)")},
4735	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{"grub", 0, POPT_ARG_NONE, &configureGrub, 0,
4736	_("initrd image for the new kernel"), _("initrd-path") },	_("configure grub bootloader")},
4737	{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',	{"grub2", 0, POPT_ARG_NONE, &configureGrub2, 0,
4738	_("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },	_("configure grub2 bootloader")},
4739	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{"info", 0, POPT_ARG_STRING, &kernelInfo, 0,
4740	_("configure lilo bootloader") },	_("display boot information for specified kernel"),
4741	{ "make-default", 0, 0, &makeDefault, 0,	_("kernel-path")},
4742	_("make the newly added entry the default boot entry"), NULL },	{"initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4743	{ "output-file", 'o', POPT_ARG_STRING, &outputFile, 0,	_("initrd image for the new kernel"), _("initrd-path")},
4744	_("path to output updated config file (\"-\" for stdout)"),	{"extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4745	_("path") },	_
4746	{ "remove-args", 0, POPT_ARG_STRING, &removeArgs, 0,	("auxiliary initrd image for things other than the new kernel"),
4747	_("remove kernel arguments"), NULL },	_("initrd-path")},
4748	{ "remove-mbargs", 0, POPT_ARG_STRING, &removeMBKernelArgs, 0,	{"lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4749	_("remove multiboot kernel arguments"), NULL },	_("configure lilo bootloader")},
4750	{ "remove-kernel", 0, POPT_ARG_STRING, &removeKernelPath, 0,	{"make-default", 0, 0, &makeDefault, 0,
4751	_("remove all entries for the specified kernel"),	_("make the newly added entry the default boot entry"), NULL},
4752	_("kernel-path") },	{"output-file", 'o', POPT_ARG_STRING, &outputFile, 0,
4753	{ "remove-multiboot", 0, POPT_ARG_STRING, &removeMBKernel, 0,	_("path to output updated config file (\"-\" for stdout)"),
4754	_("remove all entries for the specified multiboot kernel"), NULL },	_("path")},
4755	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{"remove-args", 0, POPT_ARG_STRING, &removeArgs, 0,
4756	_("make the first entry referencing the specified kernel "	_("remove kernel arguments"), NULL},
4757	"the default"), _("kernel-path") },	{"remove-mbargs", 0, POPT_ARG_STRING, &removeMBKernelArgs, 0,
4758	{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,	_("remove multiboot kernel arguments"), NULL},
4759	_("make the given entry index the default entry"),	{"remove-kernel", 0, POPT_ARG_STRING, &removeKernelPath, 0,
4760	_("entry-index") },	_("remove all entries for the specified kernel"),
4761	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	_("kernel-path")},
4762	_("configure silo bootloader") },	{"remove-multiboot", 0, POPT_ARG_STRING, &removeMBKernel, 0,
4763	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	_("remove all entries for the specified multiboot kernel"),
4764	_("title to use for the new kernel entry"), _("entry-title") },	NULL},
4765	{ "update-kernel", 0, POPT_ARG_STRING, &updateKernelPath, 0,	{"set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4766	_("updated information for the specified kernel"),	_("make the first entry referencing the specified kernel "
4767	_("kernel-path") },	"the default"), _("kernel-path")},
4768	{ "version", 'v', 0, NULL, 'v',	{"set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4769	_("print the version of this program and exit"), NULL },	_("make the given entry index the default entry"),
4770	{ "yaboot", 0, POPT_ARG_NONE, &configureYaboot, 0,	_("entry-index")},
4771	_("configure yaboot bootloader") },	{"silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4772	{ "zipl", 0, POPT_ARG_NONE, &configureZipl, 0,	_("configure silo bootloader")},
4773	_("configure zipl bootloader") },	{"title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
4774	POPT_AUTOHELP	_("title to use for the new kernel entry"), _("entry-title")},
4775	{ 0, 0, 0, 0, 0 }	{"update-kernel", 0, POPT_ARG_STRING, &updateKernelPath, 0,
4776	};	_("updated information for the specified kernel"),
4777		_("kernel-path")},
4778	useextlinuxmenu=0;	{"version", 'v', 0, NULL, 'v',
4779		_("print the version of this program and exit"), NULL},
4780	signal(SIGSEGV, traceback);	{"yaboot", 0, POPT_ARG_NONE, &configureYaboot, 0,
4781		_("configure yaboot bootloader")},
4782	optCon = poptGetContext("grubby", argc, argv, options, 0);	{"zipl", 0, POPT_ARG_NONE, &configureZipl, 0,
4783	poptReadDefaultConfig(optCon, 1);	_("configure zipl bootloader")},
4784		POPT_AUTOHELP {0, 0, 0, 0, 0}
4785	while ((arg = poptGetNextOpt(optCon)) >= 0) {	};
4786	switch (arg) {
4787	case 'v':	useextlinuxmenu = 0;
4788	printf("grubby version %s\n", VERSION);
4789	exit(0);	int i = 0;
4790	break;	for (int j = 1; j < argc; j++)
4791	case 'i':	i += strlen(argv[j]) + 1;
4792	if (extraInitrdCount < MAX_EXTRA_INITRDS) {	saved_command_line = malloc(i);
4793	extraInitrds[extraInitrdCount++] = strdup(poptGetOptArg(optCon));	if (!saved_command_line) {
4794	} else {	fprintf(stderr, "grubby: %m\n");
4795	fprintf(stderr, _("grubby: extra initrd maximum is %d\n"), extraInitrdCount);	exit(1);
4796	return 1;	}
4797	}	saved_command_line[0] = '\0';
4798	break;	for (int j = 1; j < argc; j++) {
4799	}	strcat(saved_command_line, argv[j]);
4800	}	strncat(saved_command_line, j == argc - 1 ? "" : " ", 1);
4801		}
4802	if (arg < -1) {
4803	fprintf(stderr, _("grubby: bad argument %s: %s\n"),	optCon = poptGetContext("grubby", argc, argv, options, 0);
4804	poptBadOption(optCon, POPT_BADOPTION_NOALIAS),	poptReadDefaultConfig(optCon, 1);
4805	poptStrerror(arg));
4806	return 1;	while ((arg = poptGetNextOpt(optCon)) >= 0) {
4807	}	switch (arg) {
4808		case 'v':
4809		printf("grubby version %s\n", VERSION);
4810		exit(0);
4811		break;
4812		case 'i':
4813		if (extraInitrdCount < MAX_EXTRA_INITRDS) {
4814		extraInitrds[extraInitrdCount++] =
4815		strdup(poptGetOptArg(optCon));
4816		} else {
4817		fprintf(stderr,
4818		_
4819		("grubby: extra initrd maximum is %d\n"),
4820		extraInitrdCount);
4821		return 1;
4822		}
4823		break;
4824		}
4825		}
4826
4827	if ((chptr = poptGetArg(optCon))) {	if (arg < -1) {
4828	fprintf(stderr, _("grubby: unexpected argument %s\n"), chptr);	fprintf(stderr, _("grubby: bad argument %s: %s\n"),
4829	return 1;	poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
4830	}	poptStrerror(arg));
4831		return 1;
4832		}
4833
4834	if ((configureLilo + configureGrub2 + configureGrub + configureELilo +	if ((chptr = poptGetArg(optCon))) {
4835	configureYaboot + configureSilo + configureZipl +	fprintf(stderr, _("grubby: unexpected argument %s\n"), chptr);
4836	configureExtLinux ) > 1) {	return 1;
4837	fprintf(stderr, _("grubby: cannot specify multiple bootloaders\n"));	}
4838	return 1;
4839	} else if (bootloaderProbe && grubConfig) {	if ((configureLilo + configureGrub2 + configureGrub + configureELilo +
4840	fprintf(stderr,	configureYaboot + configureSilo + configureZipl +
4841	_("grubby: cannot specify config file with --bootloader-probe\n"));	configureExtLinux) > 1) {
4842	return 1;	fprintf(stderr,
4843	} else if (configureGrub2) {	_("grubby: cannot specify multiple bootloaders\n"));
4844	cfi = &grub2ConfigType;	return 1;
4845	} else if (configureLilo) {	} else if (bootloaderProbe && grubConfig) {
4846	cfi = &liloConfigType;	fprintf(stderr,
4847	} else if (configureGrub) {	_
4848	cfi = &grubConfigType;	("grubby: cannot specify config file with --bootloader-probe\n"));
4849	} else if (configureELilo) {	return 1;
4850	cfi = &eliloConfigType;	} else if (configureGrub2) {
4851	} else if (configureYaboot) {	cfi = &grub2ConfigType;
4852	cfi = &yabootConfigType;	if (envPath)
4853	} else if (configureSilo) {	cfi->envFile = envPath;
4854	cfi = &siloConfigType;	} else if (configureLilo) {
4855	} else if (configureZipl) {	cfi = &liloConfigType;
4856	cfi = &ziplConfigType;	} else if (configureGrub) {
4857	} else if (configureExtLinux) {	cfi = &grubConfigType;
4858	cfi = &extlinuxConfigType;	} else if (configureELilo) {
4859	useextlinuxmenu=1;	cfi = &eliloConfigType;
4860	}	} else if (configureYaboot) {
4861		cfi = &yabootConfigType;
4862	if (!cfi) {	} else if (configureSilo) {
4863	if (grub2FindConfig(&grub2ConfigType))	cfi = &siloConfigType;
4864	cfi = &grub2ConfigType;	} else if (configureZipl) {
4865	else	cfi = &ziplConfigType;
4866	#ifdef __ia64__	} else if (configureExtLinux) {
4867	cfi = &eliloConfigType;	cfi = &extlinuxConfigType;
4868	#elif __powerpc__	useextlinuxmenu = 1;
4869	cfi = &yabootConfigType;	}
4870	#elif __sparc__
4871	cfi = &siloConfigType;	if (!cfi) {
4872	#elif __s390__	if (grub2FindConfig(&grub2ConfigType)) {
4873	cfi = &ziplConfigType;	cfi = &grub2ConfigType;
4874	#elif __s390x__	if (envPath)
4875	cfi = &ziplConfigtype;	cfi->envFile = envPath;
4876	#else	} else
4877	cfi = &grubConfigType;	#ifdef __ia64__
4878	#endif	cfi = &eliloConfigType;
4879	}	#elif __powerpc__
4880		cfi = &yabootConfigType;
4881	if (!grubConfig) {	#elif __sparc__
4882	if (cfi->findConfig)	cfi = &siloConfigType;
4883	grubConfig = cfi->findConfig(cfi);	#elif __s390__
4884	if (!grubConfig)	cfi = &ziplConfigType;
4885	grubConfig = cfi->defaultConfig;	#elif __s390x__
4886	}	cfi = &ziplConfigtype;
4887		#else
4888	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	cfi = &grubConfigType;
4889	newKernelPath || removeKernelPath || makeDefault ||	#endif
4890	defaultKernel || displayDefaultIndex || displayDefaultTitle ||	}
4891	(defaultIndex >= 0))) {
4892	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	if (!grubConfig) {
4893		if (cfi->findConfig)
4894		grubConfig = cfi->findConfig(cfi);
4895		if (!grubConfig)
4896		grubConfig = cfi->defaultConfig;
4897		}
4898
4899		if (bootloaderProbe && (displayDefault || kernelInfo ||
4900		newKernelPath || removeKernelPath || makeDefault
4901		|| defaultKernel || displayDefaultIndex
4902		|| displayDefaultTitle
4903		|| (defaultIndex >= 0))) {
4904		fprintf(stderr,
4905		_("grubby: --bootloader-probe may not be used with "
4906	"specified option"));	"specified option"));
4907	return 1;	return 1;
4908	}	}
4909
4910	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4911	removeKernelPath)) {	removeKernelPath)) {
4912	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4913	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
4914	return 1;	return 1;
4915	}	}
4916
4917	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4918	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4919	return 1;	return 1;
4920	} else if (!newKernelPath && (newKernelTitle  || copyDefault ||	} else if (!newKernelPath && (copyDefault ||
4921	(newKernelInitrd && !updateKernelPath)||	(newKernelInitrd && !updateKernelPath) ||
4922	makeDefault || extraInitrdCount > 0)) {	makeDefault || extraInitrdCount > 0)) {
4923	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
4924	return 1;	return 1;
4925	}	}
4926
4927	if (newKernelPath && updateKernelPath) {	if (newKernelPath && updateKernelPath) {
4928	fprintf(stderr, _("grubby: --add-kernel and --update-kernel may"	fprintf(stderr, _("grubby: --add-kernel and --update-kernel may"
4929	"not be used together"));	"not be used together"));
4930	return 1;	return 1;
4931	}	}
4932
4933	if (makeDefault && defaultKernel) {	if (makeDefault && defaultKernel) {
4934	fprintf(stderr, _("grubby: --make-default and --default-kernel "	fprintf(stderr, _("grubby: --make-default and --default-kernel "
4935	"may not be used together\n"));	"may not be used together\n"));
4936	return 1;	return 1;
4937	} else if (defaultKernel && removeKernelPath &&	} else if (defaultKernel && removeKernelPath &&
4938	!strcmp(defaultKernel, removeKernelPath)) {	!strcmp(defaultKernel, removeKernelPath)) {
4939	fprintf(stderr, _("grubby: cannot make removed kernel the default\n"));	fprintf(stderr,
4940	return 1;	_("grubby: cannot make removed kernel the default\n"));
4941	} else if (defaultKernel && newKernelPath &&	return 1;
4942	!strcmp(defaultKernel, newKernelPath)) {	} else if (defaultKernel && newKernelPath &&
4943	makeDefault = 1;	!strcmp(defaultKernel, newKernelPath)) {
4944	defaultKernel = NULL;	makeDefault = 1;
4945	}	defaultKernel = NULL;
4946	else if (defaultKernel && (defaultIndex >= 0)) {	} else if (defaultKernel && (defaultIndex >= 0)) {
4947	fprintf(stderr, _("grubby: --set-default and --set-default-index "	fprintf(stderr,
4948		_("grubby: --set-default and --set-default-index "
4949	"may not be used together\n"));	"may not be used together\n"));
4950	return 1;	return 1;
4951	}	}
4952
4953	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4954	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr,
4955	"is used\n"));	_("grubby: output file must be specified if stdin "
4956	return 1;	"is used\n"));
4957	}	return 1;
4958		}
4959
4960	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault
4961	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !defaultKernel && !kernelInfo && !bootloaderProbe
4962	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle	&& !updateKernelPath && !removeMBKernel && !displayDefaultIndex
4963	&& (defaultIndex == -1)) {	&& !displayDefaultTitle && (defaultIndex == -1)) {
4964	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4965	return 1;	return 1;
4966	}	}
4967
4968	flags |= badImageOkay ? GRUBBY_BADIMAGE_OKAY : 0;	flags |= badImageOkay ? GRUBBY_BADIMAGE_OKAY : 0;
4969
4970	if (cfi->needsBootPrefix) {	if (cfi->needsBootPrefix) {
4971	if (!bootPrefix) {	if (!bootPrefix) {
4972	bootPrefix = findBootPrefix();	bootPrefix = findBootPrefix();
4973	if (!bootPrefix) return 1;	if (!bootPrefix)
4974		return 1;
4975		} else {
4976		/* this shouldn't end with a / */
4977		if (bootPrefix[strlen(bootPrefix) - 1] == '/')
4978		bootPrefix[strlen(bootPrefix) - 1] = '\0';
4979		}
4980	} else {	} else {
4981	/* this shouldn't end with a / */	bootPrefix = "";
4982	if (bootPrefix[strlen(bootPrefix) - 1] == '/')	}
	bootPrefix[strlen(bootPrefix) - 1] = '\0';
	}
	} else {
	bootPrefix = "";
	}
	if (!cfi->mbAllowExtraInitRds &&
	extraInitrdCount > 0) {
	fprintf(stderr, _("grubby: %s doesn't allow multiple initrds\n"), cfi->defaultConfig);
	return 1;
	}
4983
4984	if (bootloaderProbe) {	if (!cfi->mbAllowExtraInitRds && extraInitrdCount > 0) {
4985	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;	fprintf(stderr,
4986	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;	_("grubby: %s doesn't allow multiple initrds\n"),
4987		cfi->defaultConfig);
4988	const char *grub2config = grub2FindConfig(&grub2ConfigType);	return 1;
4989	if (grub2config) {	}
	gconfig = readConfig(grub2config, &grub2ConfigType);
	if (!gconfig)
	gr2c = 1;
	else
	gr2c = checkForGrub2(gconfig);
	}
	const char *grubconfig = grubFindConfig(&grubConfigType);
	if (!access(grubconfig, F_OK)) {
	gconfig = readConfig(grubconfig, &grubConfigType);
	if (!gconfig)
	grc = 1;
	else
	grc = checkForGrub(gconfig);
	}
	if (!access(liloConfigType.defaultConfig, F_OK)) {
	lconfig = readConfig(liloConfigType.defaultConfig, &liloConfigType);
	if (!lconfig)
	lrc = 1;
	else
	lrc = checkForLilo(lconfig);
	}
	if (!access(eliloConfigType.defaultConfig, F_OK)) {
	econfig = readConfig(eliloConfigType.defaultConfig,
	&eliloConfigType);
	if (!econfig)
	erc = 1;
	else
	erc = checkForElilo(econfig);
	}
	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
	lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
	if (!lconfig)
	extrc = 1;
	else
	extrc = checkForExtLinux(lconfig);
	}
	if (!access(yabootConfigType.defaultConfig, F_OK)) {
	yconfig = readConfig(yabootConfigType.defaultConfig,
	&yabootConfigType);
	if (!yconfig)
	yrc = 1;
	else
	yrc = checkForYaboot(yconfig);
	}
	if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
	erc == 1)
	return 1;
	if (lrc == 2) printf("lilo\n");
	if (gr2c == 2) printf("grub2\n");
	if (grc == 2) printf("grub\n");
	if (extrc == 2) printf("extlinux\n");
	if (yrc == 2) printf("yaboot\n");
	if (erc == 2) printf("elilo\n");
4990
4991	return 0;	if (bootloaderProbe) {
4992	}	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4993		struct grubConfig *lconfig, *gconfig, *yconfig, *econfig;
4994
4995		const char *grub2config = grub2FindConfig(&grub2ConfigType);
4996		if (grub2config) {
4997		gconfig = readConfig(grub2config, &grub2ConfigType);
4998		if (!gconfig)
4999		gr2c = 1;
5000		else
5001		gr2c = checkForGrub2(gconfig);
5002		}
5003
5004	config = readConfig(grubConfig, cfi);	const char *grubconfig = grubFindConfig(&grubConfigType);
5005	if (!config) return 1;	if (!access(grubconfig, F_OK)) {
5006		gconfig = readConfig(grubconfig, &grubConfigType);
5007		if (!gconfig)
5008		grc = 1;
5009		else
5010		grc = checkForGrub(gconfig);
5011		}
5012
5013	if (displayDefault) {	if (!access(liloConfigType.defaultConfig, F_OK)) {
5014	struct singleLine * line;	lconfig =
5015	struct singleEntry * entry;	readConfig(liloConfigType.defaultConfig,
5016	char * rootspec;	&liloConfigType);
5017		if (!lconfig)
5018	if (config->defaultImage == -1) return 0;	lrc = 1;
5019	entry = findEntryByIndex(config, config->defaultImage);	else
5020	if (!entry) return 0;	lrc = checkForLilo(lconfig);
5021	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	}
	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
	if (!line) return 0;
	rootspec = getRootSpecifier(line->elements[1].item);
	printf("%s%s\n", bootPrefix, line->elements[1].item +
	((rootspec != NULL) ? strlen(rootspec) : 0));
5022
5023	return 0;	if (!access(eliloConfigType.defaultConfig, F_OK)) {
5024		econfig = readConfig(eliloConfigType.defaultConfig,
5025		&eliloConfigType);
5026		if (!econfig)
5027		erc = 1;
5028		else
5029		erc = checkForElilo(econfig);
5030		}
5031
5032	} else if (displayDefaultTitle) {	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
5033	struct singleLine * line;	lconfig =
5034	struct singleEntry * entry;	readConfig(extlinuxConfigType.defaultConfig,
5035		&extlinuxConfigType);
5036	if (config->defaultImage == -1) return 0;	if (!lconfig)
5037	entry = findEntryByIndex(config, config->defaultImage);	extrc = 1;
5038	if (!entry) return 0;	else
5039		extrc = checkForExtLinux(lconfig);
5040	if (!configureGrub2) {	}
	line = getLineByType(LT_TITLE, entry->lines);
	if (!line) return 0;
	printf("%s\n", line->elements[1].item);
5041
5042	} else {	if (!access(yabootConfigType.defaultConfig, F_OK)) {
5043	char * title;	yconfig = readConfig(yabootConfigType.defaultConfig,
5044		&yabootConfigType);
5045		if (!yconfig)
5046		yrc = 1;
5047		else
5048		yrc = checkForYaboot(yconfig);
5049		}
5050
5051	dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");	if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1
5052	line = getLineByType(LT_MENUENTRY, entry->lines);	|| erc == 1)
5053	if (!line) return 0;	return 1;
5054	title = grub2ExtractTitle(line);
5055	if (title)	if (lrc == 2)
5056	printf("%s\n", title);	printf("lilo\n");
5057		if (gr2c == 2)
5058		printf("grub2\n");
5059		if (grc == 2)
5060		printf("grub\n");
5061		if (extrc == 2)
5062		printf("extlinux\n");
5063		if (yrc == 2)
5064		printf("yaboot\n");
5065		if (erc == 2)
5066		printf("elilo\n");
5067
5068		return 0;
5069	}	}
	return 0;
5070
5071	} else if (displayDefaultIndex) {	if (grubConfig == NULL) {
5072	if (config->defaultImage == -1) return 0;	printf("Could not find bootloader configuration file.\n");
5073	printf("%i\n", config->defaultImage);	exit(1);
5074		}
5075	} else if (kernelInfo)
5076	return displayInfo(config, kernelInfo, bootPrefix);	config = readConfig(grubConfig, cfi);
5077		if (!config)
5078	if (copyDefault) {	return 1;
5079	template = findTemplate(config, bootPrefix, NULL, 0, flags);
5080	if (!template) return 1;	if (displayDefault) {
5081	}	struct singleLine *line;
5082		struct singleEntry *entry;
5083	markRemovedImage(config, removeKernelPath, bootPrefix);	char *rootspec;
5084	markRemovedImage(config, removeMBKernel, bootPrefix);
5085	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	if (config->defaultImage == -1)
5086	bootPrefix, flags, defaultIndex);	return 0;
5087	setFallbackImage(config, newKernelPath != NULL);	if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
5088	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	cfi->defaultIsSaved)
5089	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	config->defaultImage = 0;
5090	if (updateKernelPath && newKernelInitrd) {	entry = findEntryByIndex(config, config->defaultImage);
5091	if (updateInitrd(config, updateKernelPath, bootPrefix,	if (!entry)
5092	newKernelInitrd)) return 1;	return 0;
5093	}	if (!suitableImage(entry, bootPrefix, 0, flags))
5094	if (addNewKernel(config, template, bootPrefix, newKernelPath,	return 0;
5095	newKernelTitle, newKernelArgs, newKernelInitrd,
5096	(const char **)extraInitrds, extraInitrdCount,	line =
5097	newMBKernel, newMBKernelArgs)) return 1;	getLineByType(LT_KERNEL | LT_HYPER | LT_KERNEL_EFI |
5098		LT_KERNEL_16, entry->lines);
5099		if (!line)
5100	if (numEntries(config) == 0) {	return 0;
5101	fprintf(stderr, _("grubby: doing this would leave no kernel entries. "
5102	"Not writing out new config.\n"));	rootspec = getRootSpecifier(line->elements[1].item);
5103	return 1;	printf("%s%s\n", bootPrefix, line->elements[1].item +
5104	}	((rootspec != NULL) ? strlen(rootspec) : 0));
5105
5106		return 0;
5107
5108		} else if (displayDefaultTitle) {
5109		struct singleLine *line;
5110		struct singleEntry *entry;
5111
5112		if (config->defaultImage == -1)
5113		return 0;
5114		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
5115		cfi->defaultIsSaved)
5116		config->defaultImage = 0;
5117		entry = findEntryByIndex(config, config->defaultImage);
5118		if (!entry)
5119		return 0;
5120
5121		if (!configureGrub2) {
5122		char *title;
5123		line = getLineByType(LT_TITLE, entry->lines);
5124		if (!line)
5125		return 0;
5126		title = extractTitle(config, line);
5127		if (!title)
5128		return 0;
5129		printf("%s\n", title);
5130		free(title);
5131		} else {
5132		char *title;
5133
5134		dbgPrintf
5135		("This is GRUB2, default title is embeded in menuentry\n");
5136		line = getLineByType(LT_MENUENTRY, entry->lines);
5137		if (!line)
5138		return 0;
5139		title = grub2ExtractTitle(line);
5140		if (title)
5141		printf("%s\n", title);
5142		}
5143		return 0;
5144
5145		} else if (displayDefaultIndex) {
5146		if (config->defaultImage == -1)
5147		return 0;
5148		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
5149		cfi->defaultIsSaved)
5150		config->defaultImage = 0;
5151		printf("%i\n", config->defaultImage);
5152		return 0;
5153
5154		} else if (kernelInfo)
5155		return displayInfo(config, kernelInfo, bootPrefix);
5156
5157		if (copyDefault) {
5158		template = findTemplate(config, bootPrefix, NULL, 0, flags);
5159		if (!template)
5160		return 1;
5161		}
5162
5163		markRemovedImage(config, removeKernelPath, bootPrefix);
5164		markRemovedImage(config, removeMBKernel, bootPrefix);
5165		setDefaultImage(config, newKernelPath != NULL, defaultKernel,
5166		makeDefault, bootPrefix, flags, defaultIndex);
5167		setFallbackImage(config, newKernelPath != NULL);
5168		if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
5169		removeArgs, newMBKernelArgs, removeMBKernelArgs))
5170		return 1;
5171		if (updateKernelPath && newKernelInitrd) {
5172		if (newMBKernel) {
5173		if (addMBInitrd(config, newMBKernel, updateKernelPath,
5174		bootPrefix, newKernelInitrd,
5175		newKernelTitle))
5176		return 1;
5177		} else {
5178		if (updateInitrd(config, updateKernelPath, bootPrefix,
5179		newKernelInitrd, newKernelTitle))
5180		return 1;
5181		}
5182		}
5183		if (addNewKernel(config, template, bootPrefix, newKernelPath,
5184		newKernelTitle, newKernelArgs, newKernelInitrd,
5185		(const char **)extraInitrds, extraInitrdCount,
5186		newMBKernel, newMBKernelArgs, newDevTreePath))
5187		return 1;
5188
5189		if (numEntries(config) == 0) {
5190		fprintf(stderr,
5191		_("grubby: doing this would leave no kernel entries. "
5192		"Not writing out new config.\n"));
5193		return 1;
5194		}
5195
5196	if (!outputFile)	if (!outputFile)
5197	outputFile = (char *)grubConfig;	outputFile = (char *)grubConfig;
5198
5199	return writeConfig(config, outputFile, bootPrefix);	return writeConfig(config, outputFile, bootPrefix);
5200	}	}

---

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

Legend: Removed from v.2052   changed lines   Added in v.3002