Diff of /trunk/grubby/grubby.c

Parent Directory | Revision Log | Patch

	trunk/mkinitrd-magellan/grubby/grubby.c revision 532 by niro, Sat Sep 1 22:45:15 2007 UTC	trunk/grubby/grubby.c revision 2957 by niro, Wed Jun 29 14:06:18 2016 UTC
#	Line 1	Line 1
1	/* Copyright (C) 2001-2005 Red Hat, Inc.	/*
2		* grubby.c
3	This program is free software; you can redistribute it and/or	*
4	modify it under the terms of the General Public License as published	* Copyright (C) 2001-2008 Red Hat, Inc.
5	by the Free Software Foundation; either version 2 of the License, or	* All rights reserved.
6	(at your option) any later version.	*
7		* This program is free software; you can redistribute it and/or modify
8	This program is distributed in the hope that it will be useful,	* it under the terms of the GNU General Public License as published by
9	but WITHOUT ANY WARRANTY; without even the implied warranty of	* the Free Software Foundation; either version 2 of the License, or
10	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU	* (at your option) any later version.
11	General Public License for more details.	*
12		* This program is distributed in the hope that it will be useful,
13	You should have received a copy of the GNU General Public	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	License along with this program; if not, write to the Free	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15	Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA	* GNU General Public License for more details.
16	02111-1307 USA.  */	*
17		* You should have received a copy of the GNU General Public License
18		* along with this program.  If not, see <http://www.gnu.org/licenses/>.
19		*/
20
21		#ifndef _GNU_SOURCE
22		#define _GNU_SOURCE
23		#endif
24	#include <ctype.h>	#include <ctype.h>
25	#include <errno.h>	#include <errno.h>
26	#include <fcntl.h>	#include <fcntl.h>
#	Line 25	Line 31
31	#include <string.h>	#include <string.h>
32	#include <sys/stat.h>	#include <sys/stat.h>
33	#include <unistd.h>	#include <unistd.h>
34		#include <libgen.h>
35		#include <execinfo.h>
36		#include <signal.h>
37		#include <blkid/blkid.h>
38
39		#include "log.h"
40
41		#ifndef DEBUG
42		#define DEBUG 0
43		#endif
44
45		#if DEBUG
46		#define dbgPrintf(format, args...) fprintf(stderr, format , ## args)
47		#else
48		#define dbgPrintf(format, args...)
49		#endif
50
51	#include "mount_by_label.h"	int debug = 0; /* Currently just for template debugging */
52
53	#define _(A) (A)	#define _(A) (A)
54
55		#define MAX_EXTRA_INITRDS  16 /* code segment checked by --bootloader-probe */
56	#define CODE_SEG_SIZE  128 /* code segment checked by --bootloader-probe */	#define CODE_SEG_SIZE  128 /* code segment checked by --bootloader-probe */
57
58		#define NOOP_OPCODE 0x90
59		#define JMP_SHORT_OPCODE 0xeb
60
61		int isEfi = 0;
62
63		#if defined(__aarch64__)
64		#define isEfiOnly 1
65		#else
66		#define isEfiOnly 0
67		#endif
68
69		char *saved_command_line = NULL;
70
71	/* comments get lumped in with indention */	/* comments get lumped in with indention */
72	struct lineElement {	struct lineElement {
73	char * item;	char * item;
74	char * indent;	char * indent;
75	};	};
76
77	enum lineType_e { LT_WHITESPACE, LT_TITLE, LT_KERNEL, LT_INITRD, LT_DEFAULT,	enum lineType_e {
78	LT_UNKNOWN, LT_ROOT, LT_FALLBACK, LT_KERNELARGS, LT_BOOT,	LT_WHITESPACE   = 1 << 0,
79	LT_BOOTROOT, LT_LBA, LT_MBMODULE, LT_OTHER, LT_GENERIC };	LT_TITLE        = 1 << 1,
80		LT_KERNEL       = 1 << 2,
81		LT_INITRD       = 1 << 3,
82		LT_HYPER        = 1 << 4,
83		LT_DEFAULT      = 1 << 5,
84		LT_MBMODULE     = 1 << 6,
85		LT_ROOT         = 1 << 7,
86		LT_FALLBACK     = 1 << 8,
87		LT_KERNELARGS   = 1 << 9,
88		LT_BOOT         = 1 << 10,
89		LT_BOOTROOT     = 1 << 11,
90		LT_LBA          = 1 << 12,
91		LT_OTHER        = 1 << 13,
92		LT_GENERIC      = 1 << 14,
93		LT_ECHO    = 1 << 16,
94		LT_MENUENTRY    = 1 << 17,
95		LT_ENTRY_END    = 1 << 18,
96		LT_SET_VARIABLE = 1 << 19,
97		LT_KERNEL_EFI   = 1 << 20,
98		LT_INITRD_EFI   = 1 << 21,
99		LT_KERNEL_16    = 1 << 22,
100		LT_INITRD_16    = 1 << 23,
101		LT_DEVTREE      = 1 << 24,
102		LT_UNKNOWN      = 1 << 25,
103		};
104
105	struct singleLine {	struct singleLine {
106	char * indent;	char * indent;
#	Line 61  struct singleEntry {	Line 121  struct singleEntry {
121
122	#define GRUB_CONFIG_NO_DEFAULT    (1 << 0) /* don't write out default=0 */	#define GRUB_CONFIG_NO_DEFAULT    (1 << 0) /* don't write out default=0 */
123
124	#define KERNEL_KERNEL    (1 << 0)	/* These defines are (only) used in addNewKernel() */
125	#define KERNEL_INITRD    (1 << 2)	#define NEED_KERNEL  (1 << 0)
126	#define KERNEL_TITLE    (1 << 3)	#define NEED_INITRD  (1 << 1)
127	#define KERNEL_ARGS    (1 << 4)	#define NEED_TITLE   (1 << 2)
128	#define KERNEL_MB           (1 << 5)	#define NEED_ARGS    (1 << 3)
129		#define NEED_MB      (1 << 4)
130		#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
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;
142		};
143
144		struct configFileInfo;
145
146		typedef const char *(*findConfigFunc)(struct configFileInfo *);
147		typedef const int (*writeLineFunc)(struct configFileInfo *,
148		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;
155		writeLineFunc writeLine;
156		getEnvFunc getEnv;
157		setEnvFunc setEnv;
158	struct keywordTypes * keywords;	struct keywordTypes * keywords;
159		int caseInsensitive;
160	int defaultIsIndex;	int defaultIsIndex;
161		int defaultIsVariable;
162	int defaultSupportSaved;	int defaultSupportSaved;
163	enum lineType_e entrySeparator;	int defaultIsSaved;
164		int defaultIsUnquoted;
165		enum lineType_e entryStart;
166		enum lineType_e entryEnd;
167	int needsBootPrefix;	int needsBootPrefix;
168	int argsInQuotes;	int argsInQuotes;
169	int maxTitleLength;	int maxTitleLength;
170	int titleBracketed;	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[] = {
#	Line 94  struct keywordTypes grubKeywords[] = {	Line 182  struct keywordTypes grubKeywords[] = {
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,       ' ' },
188	{ NULL,    0, 0 },	{ NULL,    0, 0 },
189	};	};
190
191		const char *grubFindConfig(struct configFileInfo *cfi) {
192		static const char *configFiles[] = {
193		"/boot/grub/grub.conf",
194		"/boot/grub/menu.lst",
195		"/etc/grub.conf",
196		"/boot/grub2/grub.cfg",
197		"/boot/grub2-efi/grub.cfg",
198		NULL
199		};
200		static int i = -1;
201
202		if (i == -1) {
203		for (i = 0; configFiles[i] != NULL; i++) {
204		dbgPrintf("Checking \"%s\": ", configFiles[i]);
205		if (!access(configFiles[i], R_OK)) {
206		dbgPrintf("found\n");
207		return configFiles[i];
208		}
209		dbgPrintf("not found\n");
210		}
211		}
212		return configFiles[i];
213		}
214
215	struct configFileInfo grubConfigType = {	struct configFileInfo grubConfigType = {
216	"/boot/grub/grub.conf",    /* defaultConfig */	.findConfig = grubFindConfig,
217	grubKeywords,    /* keywords */	.keywords = grubKeywords,
218	1,    /* defaultIsIndex */	.defaultIsIndex = 1,
219	1,    /* defaultSupportSaved */	.defaultSupportSaved = 1,
220	LT_TITLE,    /* entrySeparator */	.entryStart = LT_TITLE,
221	1,    /* needsBootPrefix */	.needsBootPrefix = 1,
222	0,    /* argsInQuotes */	.mbHyperFirst = 1,
223	0,    /* maxTitleLength */	.mbInitRdIsModule = 1,
224	0,                                      /* titleBracketed */	.mbAllowExtraInitRds = 1,
225		};
226
227		struct keywordTypes grub2Keywords[] = {
228		{ "menuentry",  LT_MENUENTRY,   ' ' },
229		{ "}",          LT_ENTRY_END,   ' ' },
230		{ "echo",       LT_ECHO,        ' ' },
231		{ "set",        LT_SET_VARIABLE,' ', '=' },
232		{ "root",       LT_BOOTROOT,    ' ' },
233		{ "default",    LT_DEFAULT,     ' ' },
234		{ "fallback",   LT_FALLBACK,    ' ' },
235		{ "linux",      LT_KERNEL,      ' ' },
236		{ "linuxefi",   LT_KERNEL_EFI,  ' ' },
237		{ "linux16",    LT_KERNEL_16,   ' ' },
238		{ "initrd",     LT_INITRD,      ' ', ' ' },
239		{ "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
240		{ "initrd16",   LT_INITRD_16,   ' ', ' ' },
241		{ "module",     LT_MBMODULE,    ' ' },
242		{ "kernel",     LT_HYPER,       ' ' },
243		{ "devicetree", LT_DEVTREE,  ' ' },
244		{ NULL, 0, 0 },
245		};
246
247		const char *grub2FindConfig(struct configFileInfo *cfi) {
248		static const char *configFiles[] = {
249		"/boot/grub/grub-efi.cfg",
250		"/boot/grub/grub.cfg",
251		NULL
252		};
253		static int i = -1;
254		static const char *grub_cfg = "/boot/grub/grub.cfg";
255		int rc = -1;
256
257		if (i == -1) {
258		for (i = 0; configFiles[i] != NULL; i++) {
259		dbgPrintf("Checking \"%s\": ", configFiles[i]);
260		if ((rc = access(configFiles[i], R_OK))) {
261		if (errno == EACCES) {
262		printf("Unable to access bootloader configuration file "
263		"\"%s\": %m\n", configFiles[i]);
264		exit(1);
265		}
266		continue;
267		} else {
268		dbgPrintf("found\n");
269		return configFiles[i];
270		}
271		}
272		}
273
274		/* Ubuntu renames grub2 to grub, so check for the grub.d directory
275		* that isn't in grub1, and if it exists, return the config file path
276		* that they use. */
277		if (configFiles[i] == NULL && !access("/etc/grub.d/", R_OK)) {
278		dbgPrintf("found\n");
279		return grub_cfg;
280		}
281
282		dbgPrintf("not found\n");
283		return configFiles[i];
284		}
285
286		/* kind of hacky.  It'll give the first 1024 bytes, ish. */
287		static char *grub2GetEnv(struct configFileInfo *info, char *name)
288		{
289		static char buf[1025];
290		char *s = NULL;
291		char *ret = NULL;
292		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
293		int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
294
295		if (rc < 0)
296		return NULL;
297
298		FILE *f = popen(s, "r");
299		if (!f)
300		goto out;
301
302		memset(buf, '\0', sizeof (buf));
303		ret = fgets(buf, 1024, f);
304		pclose(f);
305
306		if (ret) {
307		ret += strlen(name) + 1;
308		ret[strlen(ret) - 1] = '\0';
309		}
310		dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
311		out:
312		free(s);
313		return ret;
314		}
315
316		static int sPopCount(const char *s, const char *c)
317		{
318		int ret = 0;
319		if (!s)
320		return -1;
321		for (int i = 0; s[i] != '\0'; i++)
322		for (int j = 0; c[j] != '\0'; j++)
323		if (s[i] == c[j])
324		ret++;
325		return ret;
326		}
327
328		static char *shellEscape(const char *s)
329		{
330		int l = strlen(s) + sPopCount(s, "'") * 2;
331
332		char *ret = calloc(l+1, sizeof (*ret));
333		if (!ret)
334		return NULL;
335		for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
336		if (s[i] == '\'')
337		ret[j++] = '\\';
338		ret[j] = s[i];
339		}
340		return ret;
341		}
342
343		static void unquote(char *s)
344		{
345		int l = strlen(s);
346
347		if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
348		memmove(s, s+1, l-2);
349		s[l-2] = '\0';
350		}
351		}
352
353		static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
354		{
355		char *s = NULL;
356		int rc = 0;
357		char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
358
359		unquote(value);
360		value = shellEscape(value);
361		if (!value)
362		return -1;
363
364		rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
365		free(value);
366		if (rc <0)
367		return -1;
368
369		dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
370		rc = system(s);
371		free(s);
372		return rc;
373		}
374
375		/* this is a gigantic hack to avoid clobbering grub2 variables... */
376		static int is_special_grub2_variable(const char *name)
377		{
378		if (!strcmp(name,"\"${next_entry}\""))
379		return 1;
380		if (!strcmp(name,"\"${prev_saved_entry}\""))
381		return 1;
382		return 0;
383		}
384
385		int sizeOfSingleLine(struct singleLine * line) {
386		int count = 0;
387
388		for (int i = 0; i < line->numElements; i++) {
389		int indentSize = 0;
390
391		count = count + strlen(line->elements[i].item);
392
393		indentSize = strlen(line->elements[i].indent);
394		if (indentSize > 0)
395		count = count + indentSize;
396		else
397		/* be extra safe and add room for whitespaces */
398		count = count + 1;
399		}
400
401		/* room for trailing terminator */
402		count = count + 1;
403
404		return count;
405		}
406
407		static int isquote(char q)
408		{
409		if (q == '\'' || q == '\"')
410		return 1;
411		return 0;
412		}
413
414		static int iskernel(enum lineType_e type) {
415		return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
416		}
417
418		static int isinitrd(enum lineType_e type) {
419		return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
420		}
421
422		char *grub2ExtractTitle(struct singleLine * line) {
423		char * current;
424		char * current_indent;
425		int current_len;
426		int current_indent_len;
427		int i;
428
429		/* bail out if line does not start with menuentry */
430		if (strcmp(line->elements[0].item, "menuentry"))
431		return NULL;
432
433		i = 1;
434		current = line->elements[i].item;
435		current_len = strlen(current);
436
437		/* if second word is quoted, strip the quotes and return single word */
438		if (isquote(*current) && isquote(current[current_len - 1])) {
439		char *tmp;
440
441		tmp = strdup(current);
442		*(tmp + current_len - 1) = '\0';
443		return ++tmp;
444		}
445
446		/* if no quotes, return second word verbatim */
447		if (!isquote(*current))
448		return current;
449
450		/* second element start with a quote, so we have to find the element
451		* whose last character is also quote (assuming it's the closing one) */
452		int resultMaxSize;
453		char * result;
454
455		resultMaxSize = sizeOfSingleLine(line);
456		result = malloc(resultMaxSize);
457		snprintf(result, resultMaxSize, "%s", ++current);
458
459		i++;
460		for (; i < line->numElements; ++i) {
461		current = line->elements[i].item;
462		current_len = strlen(current);
463		current_indent = line->elements[i].indent;
464		current_indent_len = strlen(current_indent);
465
466		strncat(result, current_indent, current_indent_len);
467		if (!isquote(current[current_len-1])) {
468		strncat(result, current, current_len);
469		} else {
470		strncat(result, current, current_len - 1);
471		break;
472		}
473		}
474		return result;
475		}
476
477		struct configFileInfo grub2ConfigType = {
478		.findConfig = grub2FindConfig,
479		.getEnv = grub2GetEnv,
480		.setEnv = grub2SetEnv,
481		.keywords = grub2Keywords,
482		.defaultIsIndex = 1,
483		.defaultSupportSaved = 1,
484		.defaultIsVariable = 1,
485		.entryStart = LT_MENUENTRY,
486		.entryEnd = LT_ENTRY_END,
487		.titlePosition = 1,
488		.needsBootPrefix = 1,
489		.mbHyperFirst = 1,
490		.mbInitRdIsModule = 1,
491		.mbAllowExtraInitRds = 1,
492	};	};
493
494	struct keywordTypes yabootKeywords[] = {	struct keywordTypes yabootKeywords[] = {
#	Line 142  struct keywordTypes yabootKeywords[] = {	Line 522  struct keywordTypes yabootKeywords[] = {
522	{ "partition",  LT_GENERIC,    '=' },	{ "partition",  LT_GENERIC,    '=' },
523	{ "device",    LT_GENERIC,    '=' },	{ "device",    LT_GENERIC,    '=' },
524	{ "fstype",    LT_GENERIC,    '=' },	{ "fstype",    LT_GENERIC,    '=' },
525	{ "initrd",    LT_INITRD,    '=' },	{ "initrd",    LT_INITRD,    '=', ';' },
526	{ "append",    LT_KERNELARGS,  '=' },	{ "append",    LT_KERNELARGS,  '=' },
527	{ "boot",    LT_BOOT,    '=' },	{ "boot",    LT_BOOT,    '=' },
528	{ "lba",    LT_LBA,    ' ' },	{ "lba",    LT_LBA,    ' ' },
#	Line 162  struct keywordTypes liloKeywords[] = {	Line 542  struct keywordTypes liloKeywords[] = {
542	{ NULL,    0, 0 },	{ NULL,    0, 0 },
543	};	};
544
545		struct keywordTypes eliloKeywords[] = {
546		{ "label",    LT_TITLE,    '=' },
547		{ "root",    LT_ROOT,    '=' },
548		{ "default",    LT_DEFAULT,    '=' },
549		{ "image",    LT_KERNEL,    '=' },
550		{ "initrd",    LT_INITRD,    '=' },
551		{ "append",    LT_KERNELARGS,  '=' },
552		{ "vmm",    LT_HYPER,       '=' },
553		{ NULL,    0, 0 },
554		};
555
556	struct keywordTypes siloKeywords[] = {	struct keywordTypes siloKeywords[] = {
557	{ "label",    LT_TITLE,    '=' },	{ "label",    LT_TITLE,    '=' },
558	{ "root",    LT_ROOT,    '=' },	{ "root",    LT_ROOT,    '=' },
#	Line 183  struct keywordTypes ziplKeywords[] = {	Line 574  struct keywordTypes ziplKeywords[] = {
574	{ NULL,         0, 0 },	{ NULL,         0, 0 },
575	};	};
576
577		struct keywordTypes extlinuxKeywords[] = {
578		{ "label",    LT_TITLE,    ' ' },
579		{ "root",    LT_ROOT,    ' ' },
580		{ "default",    LT_DEFAULT,    ' ' },
581		{ "kernel",    LT_KERNEL,    ' ' },
582		{ "initrd",    LT_INITRD,      ' ', ',' },
583		{ "append",    LT_KERNELARGS,  ' ' },
584		{ "prompt",     LT_UNKNOWN,     ' ' },
585		{ NULL,    0, 0 },
586		};
587		int useextlinuxmenu;
588	struct configFileInfo eliloConfigType = {	struct configFileInfo eliloConfigType = {
589	"/boot/efi/EFI/redhat/elilo.conf",    /* defaultConfig */	.defaultConfig = "/boot/efi/EFI/redhat/elilo.conf",
590	liloKeywords,    /* keywords */	.keywords = eliloKeywords,
591	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
592	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
593	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
594	1,                    /* needsBootPrefix */	.mbConcatArgs = 1,
	1,    /* argsInQuotes */
	0,    /* maxTitleLength */
	0,                                      /* titleBracketed */
595	};	};
596
597	struct configFileInfo liloConfigType = {	struct configFileInfo liloConfigType = {
598	"/etc/lilo.conf",    /* defaultConfig */	.defaultConfig = "/etc/lilo.conf",
599	liloKeywords,    /* keywords */	.keywords = liloKeywords,
600	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
601	0,    /* defaultSupportSaved */	.argsInQuotes = 1,
602	LT_KERNEL,    /* entrySeparator */	.maxTitleLength = 15,
	0,    /* needsBootPrefix */
	1,    /* argsInQuotes */
	15,    /* maxTitleLength */
	0,                                      /* titleBracketed */
603	};	};
604
605	struct configFileInfo yabootConfigType = {	struct configFileInfo yabootConfigType = {
606	"/etc/yaboot.conf",    /* defaultConfig */	.defaultConfig = "/etc/yaboot.conf",
607	yabootKeywords,    /* keywords */	.keywords = yabootKeywords,
608	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
609	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
610	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
611	1,    /* needsBootPrefix */	.maxTitleLength = 15,
612	1,    /* argsInQuotes */	.mbAllowExtraInitRds = 1,
	15,    /* maxTitleLength */
	0,                                      /* titleBracketed */
613	};	};
614
615	struct configFileInfo siloConfigType = {	struct configFileInfo siloConfigType = {
616	"/etc/silo.conf",    /* defaultConfig */	.defaultConfig = "/etc/silo.conf",
617	siloKeywords,    /* keywords */	.keywords = siloKeywords,
618	0,    /* defaultIsIndex */	.entryStart = LT_KERNEL,
619	0,    /* defaultSupportSaved */	.needsBootPrefix = 1,
620	LT_KERNEL,    /* entrySeparator */	.argsInQuotes = 1,
621	1,    /* needsBootPrefix */	.maxTitleLength = 15,
	1,    /* argsInQuotes */
	15,    /* maxTitleLength */
	0,                                      /* titleBracketed */
622	};	};
623
624	struct configFileInfo ziplConfigType = {	struct configFileInfo ziplConfigType = {
625	"/etc/zipl.conf",    /* defaultConfig */	.defaultConfig = "/etc/zipl.conf",
626	ziplKeywords,    /* keywords */	.keywords = ziplKeywords,
627	0,    /* defaultIsIndex */	.entryStart = LT_TITLE,
628	0,    /* defaultSupportSaved */	.argsInQuotes = 1,
629	LT_TITLE,    /* entrySeparator */	.titleBracketed = 1,
630	0,    /* needsBootPrefix */	};
631	1,    /* argsInQuotes */
632	15,    /* maxTitleLength */	struct configFileInfo extlinuxConfigType = {
633	1,                                      /* titleBracketed */	.defaultConfig = "/boot/extlinux/extlinux.conf",
634		.keywords = extlinuxKeywords,
635		.caseInsensitive = 1,
636		.entryStart = LT_TITLE,
637		.needsBootPrefix = 1,
638		.maxTitleLength = 255,
639		.mbAllowExtraInitRds = 1,
640		.defaultIsUnquoted = 1,
641	};	};
642
643	struct grubConfig {	struct grubConfig {
#	Line 255  struct grubConfig {	Line 652  struct grubConfig {
652	struct configFileInfo * cfi;	struct configFileInfo * cfi;
653	};	};
654
655		blkid_cache blkid;
656
657	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index);	struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index);
658	struct singleEntry * findEntryByPath(struct grubConfig * cfg,	struct singleEntry * findEntryByPath(struct grubConfig * cfg,
659	const char * path, const char * prefix,	const char * path, const char * prefix,
660	int * index);	int * index);
661	static char * strndup(char * from, int len);	struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
662		int * index);
663	static int readFile(int fd, char ** bufPtr);	static int readFile(int fd, char ** bufPtr);
664	static void lineInit(struct singleLine * line);	static void lineInit(struct singleLine * line);
665		struct singleLine * lineDup(struct singleLine * line);
666	static void lineFree(struct singleLine * line);	static void lineFree(struct singleLine * line);
667	static int lineWrite(FILE * out, struct singleLine * line,	static int lineWrite(FILE * out, struct singleLine * line,
668	struct configFileInfo * cfi);	struct configFileInfo * cfi);
669	static int getNextLine(char ** bufPtr, struct singleLine * line,	static int getNextLine(char ** bufPtr, struct singleLine * line,
670	struct configFileInfo * cfi);	struct configFileInfo * cfi);
671	static char * getRootSpecifier(char * str);	static char * getRootSpecifier(char * str);
672		static void requote(struct singleLine *line, struct configFileInfo * cfi);
673	static char * strndup(char * from, int len) {	static void insertElement(struct singleLine * line,
674	char * to;	const char * item, int insertHere,
675		struct configFileInfo * cfi);
676	to = malloc(len + 1);	static void removeElement(struct singleLine * line, int removeHere);
677	strncpy(to, from, len);	static struct keywordTypes * getKeywordByType(enum lineType_e type,
678	to[len] = '\0';	struct configFileInfo * cfi);
679		static enum lineType_e getTypeByKeyword(char * keyword,
680	return to;	struct configFileInfo * cfi);
681	}	static struct singleLine * getLineByType(enum lineType_e type,
682		struct singleLine * line);
683		static int checkForExtLinux(struct grubConfig * config);
684		struct singleLine * addLineTmpl(struct singleEntry * entry,
685		struct singleLine * tmplLine,
686		struct singleLine * prevLine,
687		const char * val,
688		struct configFileInfo * cfi);
689		struct singleLine *  addLine(struct singleEntry * entry,
690		struct configFileInfo * cfi,
691		enum lineType_e type, char * defaultIndent,
692		const char * val);
693
694	static char * sdupprintf(const char *format, ...)	static char * sdupprintf(const char *format, ...)
695	#ifdef __GNUC__	#ifdef __GNUC__
#	Line 313  static char * sdupprintf(const char *for	Line 724  static char * sdupprintf(const char *for
724	return buf;	return buf;
725	}	}
726
727		static enum lineType_e preferredLineType(enum lineType_e type,
728		struct configFileInfo *cfi) {
729		if (isEfi && cfi == &grub2ConfigType) {
730		switch (type) {
731		case LT_KERNEL:
732		return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
733		case LT_INITRD:
734		return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
735		default:
736		return type;
737		}
738		#if defined(__i386__) || defined(__x86_64__)
739		} else if (cfi == &grub2ConfigType) {
740		switch (type) {
741		case LT_KERNEL:
742		return LT_KERNEL_16;
743		case LT_INITRD:
744		return LT_INITRD_16;
745		default:
746		return type;
747		}
748		#endif
749		}
750		return type;
751		}
752
753		static struct keywordTypes * getKeywordByType(enum lineType_e type,
754		struct configFileInfo * cfi) {
755		for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
756		if (kw->type == type)
757		return kw;
758		}
759		return NULL;
760		}
761
762		static char *getKeyByType(enum lineType_e type, struct configFileInfo * cfi) {
763		struct keywordTypes *kt = getKeywordByType(type, cfi);
764		if (kt)
765		return kt->key;
766		return "unknown";
767		}
768
769		static char * getpathbyspec(char *device) {
770		if (!blkid)
771		blkid_get_cache(&blkid, NULL);
772
773		return blkid_get_devname(blkid, device, NULL);
774		}
775
776		static char * getuuidbydev(char *device) {
777		if (!blkid)
778		blkid_get_cache(&blkid, NULL);
779
780		return blkid_get_tag_value(blkid, "UUID", device);
781		}
782
783		static enum lineType_e getTypeByKeyword(char * keyword,
784		struct configFileInfo * cfi) {
785		for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
786		if (cfi->caseInsensitive) {
787		if (!strcasecmp(keyword, kw->key))
788		return kw->type;
789		} else {
790		if (!strcmp(keyword, kw->key))
791		return kw->type;
792		}
793		}
794		return LT_UNKNOWN;
795		}
796
797		static struct singleLine * getLineByType(enum lineType_e type,
798		struct singleLine * line) {
799		dbgPrintf("getLineByType(%d): ", type);
800		for (; line; line = line->next) {
801		dbgPrintf("%d:%s ", line->type,
802		line->numElements ? line->elements[0].item : "(empty)");
803		if (line->type & type) break;
804		}
805		dbgPrintf(line ? "\n" : " (failed)\n");
806		return line;
807		}
808
809	static int isBracketedTitle(struct singleLine * line) {	static int isBracketedTitle(struct singleLine * line) {
810	if ((*line->elements[0].item == '[') && (line->numElements == 1)) {	if (line->numElements == 1 && *line->elements[0].item == '[') {
811	int len = strlen(line->elements[0].item);	int len = strlen(line->elements[0].item);
812	if (*(line->elements[0].item + len - 1) == ']') {	if (*(line->elements[0].item + len - 1) == ']') {
813	/* FIXME: this is a hack... */	/* FIXME: this is a hack... */
#	Line 326  static int isBracketedTitle(struct singl	Line 819  static int isBracketedTitle(struct singl
819	return 0;	return 0;
820	}	}
821
822	/* figure out if this is a entry separator */	static int isEntryStart(struct singleLine * line,
	static int isEntrySeparator(struct singleLine * line,
823	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
824	if (line->type == LT_WHITESPACE)	return line->type == cfi->entryStart || line->type == LT_OTHER ||
825	return 0;	(cfi->titleBracketed && isBracketedTitle(line));
	if (line->type == cfi->entrySeparator)
	return 1;
	if (line->type == LT_OTHER)
	return 1;
	if (cfi->titleBracketed && isBracketedTitle(line)) {
	return 1;
	}
	return 0;
826	}	}
827
828	/* extract the title from within brackets (for zipl) */	/* extract the title from within brackets (for zipl) */
829	static char * extractTitle(struct singleLine * line) {	static char * extractTitle(struct singleLine * line) {
830	/* bracketed title... let's extract it (leaks a byte) */	/* bracketed title... let's extract it (leaks a byte) */
831	char * title;	char * title = NULL;
832	title = strdup(line->elements[0].item);	if (line->type == LT_TITLE) {
833	title++;	title = strdup(line->elements[0].item);
834	*(title + strlen(title) - 1) = '\0';	title++;
835		*(title + strlen(title) - 1) = '\0';
836		} else if (line->type == LT_MENUENTRY)
837		title = strdup(line->elements[1].item);
838		else
839		return NULL;
840	return title;	return title;
841	}	}
842
#	Line 389  static void lineInit(struct singleLine *	Line 878  static void lineInit(struct singleLine *
878	line->next = NULL;	line->next = NULL;
879	}	}
880
881	static void lineFree(struct singleLine * line) {	struct singleLine * lineDup(struct singleLine * line) {
882	int i;	struct singleLine * newLine = malloc(sizeof(*newLine));
883
884		newLine->indent = strdup(line->indent);
885		newLine->next = NULL;
886		newLine->type = line->type;
887		newLine->numElements = line->numElements;
888		newLine->elements = malloc(sizeof(*newLine->elements) *
889		newLine->numElements);
890
891		for (int i = 0; i < newLine->numElements; i++) {
892		newLine->elements[i].indent = strdup(line->elements[i].indent);
893		newLine->elements[i].item = strdup(line->elements[i].item);
894		}
895
896		return newLine;
897		}
898
899		static void lineFree(struct singleLine * line) {
900	if (line->indent) free(line->indent);	if (line->indent) free(line->indent);
901
902	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
903	free(line->elements[i].item);	free(line->elements[i].item);
904	free(line->elements[i].indent);	free(line->elements[i].indent);
905	}	}
#	Line 405  static void lineFree(struct singleLine *	Line 910  static void lineFree(struct singleLine *
910
911	static int lineWrite(FILE * out, struct singleLine * line,	static int lineWrite(FILE * out, struct singleLine * line,
912	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
	int i;
913	if (fprintf(out, "%s", line->indent) == -1) return -1;	if (fprintf(out, "%s", line->indent) == -1) return -1;
914
915	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
916		/* Need to handle this, because we strip the quotes from
917		* menuentry when read it. */
918		if (line->type == LT_MENUENTRY && i == 1) {
919		if(!isquote(*line->elements[i].item))
920		fprintf(out, "\'%s\'", line->elements[i].item);
921		else
922		fprintf(out, "%s", line->elements[i].item);
923		fprintf(out, "%s", line->elements[i].indent);
924
925		continue;
926		}
927
928	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)	if (i == 1 && line->type == LT_KERNELARGS && cfi->argsInQuotes)
929	if (fputc('"', out) == EOF) return -1;	if (fputc('"', out) == EOF) return -1;
930
931	if (fprintf(out, "%s", line->elements[i].item) == -1) return -1;	if (fprintf(out, "%s", line->elements[i].item) == -1) return -1;
932	if (fprintf(out, "%s", line->elements[i].indent) == -1) return -1;	if (i < line->numElements - 1)
933		if (fprintf(out, "%s", line->elements[i].indent) == -1) return -1;
934	}	}
935
936	if (line->type == LT_KERNELARGS && cfi->argsInQuotes)	if (line->type == LT_KERNELARGS && cfi->argsInQuotes)
#	Line 433  static int getNextLine(char ** bufPtr, s	Line 949  static int getNextLine(char ** bufPtr, s
949	char * chptr;	char * chptr;
950	int elementsAlloced = 0;	int elementsAlloced = 0;
951	struct lineElement * element;	struct lineElement * element;
	struct keywordTypes * keywords = cfi->keywords;
952	int first = 1;	int first = 1;
	int i;
953
954	lineFree(line);	lineFree(line);
955
#	Line 489  static int getNextLine(char ** bufPtr, s	Line 1003  static int getNextLine(char ** bufPtr, s
1003	if (!line->numElements)	if (!line->numElements)
1004	line->type = LT_WHITESPACE;	line->type = LT_WHITESPACE;
1005	else {	else {
1006	for (i = 0; keywords[i].key; i++)	line->type = getTypeByKeyword(line->elements[0].item, cfi);
1007	if (!strcmp(line->elements[0].item, keywords[i].key)) break;	if (line->type == LT_UNKNOWN) {
	if (keywords[i].key) {
	line->type = keywords[i].type;
	} else {
	line->type = LT_UNKNOWN;
1008	/* zipl does [title] instead of something reasonable like all	/* zipl does [title] instead of something reasonable like all
1009	* the other boot loaders.  kind of ugly */	* the other boot loaders.  kind of ugly */
1010	if (cfi->titleBracketed && isBracketedTitle(line)) {	if (cfi->titleBracketed && isBracketedTitle(line)) {
#	Line 510  static int getNextLine(char ** bufPtr, s	Line 1018  static int getNextLine(char ** bufPtr, s
1018	if (*line->elements[0].item == '#') {	if (*line->elements[0].item == '#') {
1019	char * fullLine;	char * fullLine;
1020	int len;	int len;
	int i;
1021
1022	len = strlen(line->indent);	len = strlen(line->indent);
1023	for (i = 0; i < line->numElements; i++)	for (int i = 0; i < line->numElements; i++)
1024	len += strlen(line->elements[i].item) +	len += strlen(line->elements[i].item) +
1025	strlen(line->elements[i].indent);	strlen(line->elements[i].indent);
1026
#	Line 522  static int getNextLine(char ** bufPtr, s	Line 1029  static int getNextLine(char ** bufPtr, s
1029	free(line->indent);	free(line->indent);
1030	line->indent = fullLine;	line->indent = fullLine;
1031
1032	for (i = 0; i < line->numElements; i++) {	for (int i = 0; i < line->numElements; i++) {
1033	strcat(fullLine, line->elements[i].item);	strcat(fullLine, line->elements[i].item);
1034	strcat(fullLine, line->elements[i].indent);	strcat(fullLine, line->elements[i].indent);
1035	free(line->elements[i].item);	free(line->elements[i].item);
#	Line 532  static int getNextLine(char ** bufPtr, s	Line 1039  static int getNextLine(char ** bufPtr, s
1039	line->type = LT_WHITESPACE;	line->type = LT_WHITESPACE;
1040	line->numElements = 0;	line->numElements = 0;
1041	}	}
1042		} else {
1043		struct keywordTypes *kw;
1044
1045		kw = getKeywordByType(line->type, cfi);
1046
1047		/* space isn't the only separator, we need to split
1048		* elements up more
1049		*/
1050		if (!isspace(kw->separatorChar)) {
1051		char indent[2] = "";
1052		indent[0] = kw->separatorChar;
1053		for (int i = 1; i < line->numElements; i++) {
1054		char *p;
1055		int numNewElements;
1056
1057		numNewElements = 0;
1058		p = line->elements[i].item;
1059		while (*p != '\0') {
1060		if (*p == kw->separatorChar)
1061		numNewElements++;
1062		p++;
1063		}
1064		if (line->numElements + numNewElements >= elementsAlloced) {
1065		elementsAlloced += numNewElements + 5;
1066		line->elements = realloc(line->elements,
1067		sizeof(*line->elements) * elementsAlloced);
1068		}
1069
1070		for (int j = line->numElements; j > i; j--) {
1071		line->elements[j + numNewElements] = line->elements[j];
1072		}
1073		line->numElements += numNewElements;
1074
1075		p = line->elements[i].item;
1076		while (*p != '\0') {
1077
1078		while (*p != kw->separatorChar && *p != '\0') p++;
1079		if (*p == '\0') {
1080		break;
1081		}
1082
1083		line->elements[i + 1].indent = line->elements[i].indent;
1084		line->elements[i].indent = strdup(indent);
1085		*p++ = '\0';
1086		i++;
1087		line->elements[i].item = strdup(p);
1088		}
1089		}
1090		}
1091	}	}
1092	}	}
1093
1094	return 0;	return 0;
1095	}	}
1096
1097		static int isnumber(const char *s)
1098		{
1099		int i;
1100		for (i = 0; s[i] != '\0'; i++)
1101		if (s[i] < '0' || s[i] > '9')
1102		return 0;
1103		return i;
1104		}
1105
1106	static struct grubConfig * readConfig(const char * inName,	static struct grubConfig * readConfig(const char * inName,
1107	struct configFileInfo * cfi) {	struct configFileInfo * cfi) {
1108	int in;	int in;
#	Line 549  static struct grubConfig * readConfig(co	Line 1114  static struct grubConfig * readConfig(co
1114	struct singleLine * last = NULL, * line, * defaultLine = NULL;	struct singleLine * last = NULL, * line, * defaultLine = NULL;
1115	char * end;	char * end;
1116	struct singleEntry * entry = NULL;	struct singleEntry * entry = NULL;
1117	int i, len;	int len;
1118	char * buf;	char * buf;
1119
1120	if (!strcmp(inName, "-")) {	if (inName == NULL) {
1121		printf("Could not find bootloader configuration\n");
1122		exit(1);
1123		} else if (!strcmp(inName, "-")) {
1124	in = 0;	in = 0;
1125	} else {	} else {
1126	if ((in = open(inName, O_RDONLY)) < 0) {	if ((in = open(inName, O_RDONLY)) < 0) {
#	Line 595  static struct grubConfig * readConfig(co	Line 1163  static struct grubConfig * readConfig(co
1163	cfg->secondaryIndent = strdup(line->indent);	cfg->secondaryIndent = strdup(line->indent);
1164	}	}
1165
1166	if (isEntrySeparator(line, cfi)) {	if (isEntryStart(line, cfi) || (cfg->entries && !sawEntry)) {
1167	sawEntry = 1;	sawEntry = 1;
1168	if (!entry) {	if (!entry) {
1169	cfg->entries = malloc(sizeof(*entry));	cfg->entries = malloc(sizeof(*entry));
#	Line 611  static struct grubConfig * readConfig(co	Line 1179  static struct grubConfig * readConfig(co
1179	entry->next = NULL;	entry->next = NULL;
1180	}	}
1181
1182	if (line->type == LT_DEFAULT && line->numElements == 2) {	if (line->type == LT_SET_VARIABLE) {
1183	cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;	dbgPrintf("found 'set' command (%d elements): ", line->numElements);
1184	defaultLine = line;	dbgPrintf("%s", line->indent);
1185		for (int i = 0; i < line->numElements; i++)
1186		dbgPrintf("\"%s\"%s", line->elements[i].item, line->elements[i].indent);
1187		dbgPrintf("\n");
1188		struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
1189		if (kwType && line->numElements == 3 &&
1190		!strcmp(line->elements[1].item, kwType->key) &&
1191		!is_special_grub2_variable(line->elements[2].item)) {
1192		dbgPrintf("Line sets default config\n");
1193		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1194		defaultLine = line;
1195		}
1196
1197		} else if (iskernel(line->type)) {
1198		/* if by some freak chance this is multiboot and the "module"
1199		* lines came earlier in the template, make sure to use LT_HYPER
1200		* instead of LT_KERNEL now
1201		*/
1202		if (entry && entry->multiboot)
1203		line->type = LT_HYPER;
1204
1205	} else if (line->type == LT_MBMODULE) {	} else if (line->type == LT_MBMODULE) {
1206		/* go back and fix the LT_KERNEL line to indicate LT_HYPER
1207		* instead, now that we know this is a multiboot entry.
1208		* This only applies to grub, but that's the only place we
1209		* should find LT_MBMODULE lines anyway.
1210		*/
1211		for (struct singleLine *l = entry->lines; l; l = l->next) {
1212		if (l->type == LT_HYPER)
1213		break;
1214		else if (iskernel(l->type)) {
1215		l->type = LT_HYPER;
1216		break;
1217		}
1218		}
1219	entry->multiboot = 1;	entry->multiboot = 1;
1220
1221		} else if (line->type == LT_HYPER) {
1222		entry->multiboot = 1;
1223
1224	} else if (line->type == LT_FALLBACK && line->numElements == 2) {	} else if (line->type == LT_FALLBACK && line->numElements == 2) {
1225	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);	cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
1226	if (*end) cfg->fallbackImage = -1;	if (*end) cfg->fallbackImage = -1;
1227	} else if (line->type == LT_TITLE && line->numElements > 1) {
1228	/* make the title a single argument (undoing our parsing) */	} else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
1229		(line->type == LT_TITLE && line->numElements > 1)) {
1230		/* make the title/default a single argument (undoing our parsing) */
1231	len = 0;	len = 0;
1232	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1233	len += strlen(line->elements[i].item);	len += strlen(line->elements[i].item);
1234	len += strlen(line->elements[i].indent);	len += strlen(line->elements[i].indent);
1235	}	}
1236	buf = malloc(len + 1);	buf = malloc(len + 1);
1237	*buf = '\0';	*buf = '\0';
1238
1239	for (i = 1; i < line->numElements; i++) {	for (int i = 1; i < line->numElements; i++) {
1240	strcat(buf, line->elements[i].item);	strcat(buf, line->elements[i].item);
1241	free(line->elements[i].item);	free(line->elements[i].item);
1242
#	Line 643  static struct grubConfig * readConfig(co	Line 1250  static struct grubConfig * readConfig(co
1250	line->elements[line->numElements - 1].indent;	line->elements[line->numElements - 1].indent;
1251	line->elements[1].item = buf;	line->elements[1].item = buf;
1252	line->numElements = 2;	line->numElements = 2;
1253		} else if (line->type == LT_MENUENTRY && line->numElements > 3) {
1254		/* let --remove-kernel="TITLE=what" work */
1255		len = 0;
1256		char *extras;
1257		char *title;
1258
1259		for (int i = 1; i < line->numElements; i++) {
1260		len += strlen(line->elements[i].item);
1261		len += strlen(line->elements[i].indent);
1262		}
1263		buf = malloc(len + 1);
1264		*buf = '\0';
1265
1266		/* allocate mem for extra flags. */
1267		extras = malloc(len + 1);
1268		*extras = '\0';
1269
1270		/* get title. */
1271		for (int i = 0; i < line->numElements; i++) {
1272		if (!strcmp(line->elements[i].item, "menuentry"))
1273		continue;
1274		if (isquote(*line->elements[i].item))
1275		title = line->elements[i].item + 1;
1276		else
1277		title = line->elements[i].item;
1278
1279		len = strlen(title);
1280		if (isquote(title[len-1])) {
1281		strncat(buf, title,len-1);
1282		break;
1283		} else {
1284		strcat(buf, title);
1285		strcat(buf, line->elements[i].indent);
1286		}
1287		}
1288
1289		/* get extras */
1290		int count = 0;
1291		for (int i = 0; i < line->numElements; i++) {
1292		if (count >= 2) {
1293		strcat(extras, line->elements[i].item);
1294		strcat(extras, line->elements[i].indent);
1295		}
1296
1297		if (!strcmp(line->elements[i].item, "menuentry"))
1298		continue;
1299
1300		/* count ' or ", there should be two in menuentry line. */
1301		if (isquote(*line->elements[i].item))
1302		count++;
1303
1304		len = strlen(line->elements[i].item);
1305
1306		if (isquote(line->elements[i].item[len -1]))
1307		count++;
1308
1309		/* ok, we get the final ' or ", others are extras. */
1310		}
1311		line->elements[1].indent =
1312		line->elements[line->numElements - 2].indent;
1313		line->elements[1].item = buf;
1314		line->elements[2].indent =
1315		line->elements[line->numElements - 2].indent;
1316		line->elements[2].item = extras;
1317		line->numElements = 3;
1318	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {	} else if (line->type == LT_KERNELARGS && cfi->argsInQuotes) {
1319	/* Strip off any " which may be present; they'll be put back	/* Strip off any " which may be present; they'll be put back
1320	on write. This is one of the few (the only?) places that grubby	on write. This is one of the few (the only?) places that grubby
#	Line 651  static struct grubConfig * readConfig(co	Line 1323  static struct grubConfig * readConfig(co
1323	if (line->numElements >= 2) {	if (line->numElements >= 2) {
1324	int last, len;	int last, len;
1325
1326	if (*line->elements[1].item == '"')	if (isquote(*line->elements[1].item))
1327	memcpy(line->elements[1].item, line->elements[1].item + 1,	memmove(line->elements[1].item, line->elements[1].item + 1,
1328	strlen(line->elements[1].item + 1) + 1);	strlen(line->elements[1].item + 1) + 1);
1329
1330	last = line->numElements - 1;	last = line->numElements - 1;
1331	len = strlen(line->elements[last].item) - 1;	len = strlen(line->elements[last].item) - 1;
1332	if (line->elements[last].item[len] == '"')	if (isquote(line->elements[last].item[len]))
1333	line->elements[last].item[len] = '\0';	line->elements[last].item[len] = '\0';
1334	}	}
1335		}
1336
1337		if (line->type == LT_DEFAULT && line->numElements == 2) {
1338		cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
1339		defaultLine = line;
1340	}	}
1341
1342	/* If we find a generic config option which should live at the	/* If we find a generic config option which should live at the
#	Line 680  static struct grubConfig * readConfig(co	Line 1356  static struct grubConfig * readConfig(co
1356	movedLine = 1;	movedLine = 1;
1357	continue; /* without setting 'last' */	continue; /* without setting 'last' */
1358	}	}
1359
1360	/* If a second line of whitespace happens after a generic option	/* If a second line of whitespace happens after a generic option
1361	which was moved, drop it. */	which was moved, drop it. */
1362	if (movedLine && line->type == LT_WHITESPACE && last->type == LT_WHITESPACE) {	if (movedLine && line->type == LT_WHITESPACE && last->type == LT_WHITESPACE) {
#	Line 695  static struct grubConfig * readConfig(co	Line 1372  static struct grubConfig * readConfig(co
1372	entry->lines = line;	entry->lines = line;
1373	else	else
1374	last->next = line;	last->next = line;
1375		dbgPrintf("readConfig added %s to %p\n", getKeyByType(line->type, cfi), entry);
1376
1377		/* we could have seen this outside of an entry... if so, we
1378		* ignore it like any other line we don't grok */
1379		if (line->type == LT_ENTRY_END && sawEntry)
1380		sawEntry = 0;
1381	} else {	} else {
1382	if (!cfg->theLines)	if (!cfg->theLines)
1383	cfg->theLines = line;	cfg->theLines = line;
1384	else {	else
1385	last->next = line;	last->next = line;
1386	}	dbgPrintf("readConfig added %s to cfg\n", getKeyByType(line->type, cfi));
1387	}	}
1388
1389	last = line;	last = line;
#	Line 708  static struct grubConfig * readConfig(co	Line 1391  static struct grubConfig * readConfig(co
1391
1392	free(incoming);	free(incoming);
1393
1394		dbgPrintf("defaultLine is %s\n", defaultLine ? "set" : "unset");
1395	if (defaultLine) {	if (defaultLine) {
1396	if (cfi->defaultSupportSaved &&	if (defaultLine->numElements > 2 &&
1397		cfi->defaultSupportSaved &&
1398		!strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
1399		cfg->cfi->defaultIsSaved = 1;
1400		cfg->defaultImage = DEFAULT_SAVED_GRUB2;
1401		if (cfg->cfi->getEnv) {
1402		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1403		if (defTitle) {
1404		int index = 0;
1405		if (isnumber(defTitle)) {
1406		index = atoi(defTitle);
1407		entry = findEntryByIndex(cfg, index);
1408		} else {
1409		entry = findEntryByTitle(cfg, defTitle, &index);
1410		}
1411		if (entry)
1412		cfg->defaultImage = index;
1413		}
1414		}
1415		} else if (cfi->defaultIsVariable) {
1416		char *value = defaultLine->elements[2].item;
1417		while (*value && (*value == '"' || *value == '\'' ||
1418		*value == ' ' || *value == '\t'))
1419		value++;
1420		cfg->defaultImage = strtol(value, &end, 10);
1421		while (*end && (*end == '"' || *end == '\'' ||
1422		*end == ' ' || *end == '\t'))
1423		end++;
1424		if (*end) cfg->defaultImage = -1;
1425		} else if (cfi->defaultSupportSaved &&
1426	!strncmp(defaultLine->elements[1].item, "saved", 5)) {	!strncmp(defaultLine->elements[1].item, "saved", 5)) {
1427	cfg->defaultImage = DEFAULT_SAVED;	cfg->defaultImage = DEFAULT_SAVED;
1428	} else if (cfi->defaultIsIndex) {	} else if (cfi->defaultIsIndex) {
1429	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);	cfg->defaultImage = strtol(defaultLine->elements[1].item, &end, 10);
1430	if (*end) cfg->defaultImage = -1;	if (*end) cfg->defaultImage = -1;
1431	} else if (defaultLine->numElements >= 2) {	} else if (defaultLine->numElements >= 2) {
1432	i = 0;	int i = 0;
1433	while ((entry = findEntryByIndex(cfg, i))) {	while ((entry = findEntryByIndex(cfg, i))) {
1434	for (line = entry->lines; line; line = line->next)	for (line = entry->lines; line; line = line->next)
1435	if (line->type == LT_TITLE) break;	if (line->type == LT_TITLE) break;
#	Line 730  static struct grubConfig * readConfig(co	Line 1443  static struct grubConfig * readConfig(co
1443	extractTitle(line))) break;	extractTitle(line))) break;
1444	}	}
1445	i++;	i++;
1446		entry = NULL;
1447	}	}
1448
1449	if (entry) cfg->defaultImage = i;	if (entry){
1450		cfg->defaultImage = i;
1451		}else{
1452		cfg->defaultImage = -1;
1453		}
1454	}	}
1455		} else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
1456		char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
1457		if (defTitle) {
1458		int index = 0;
1459		if (isnumber(defTitle)) {
1460		index = atoi(defTitle);
1461		entry = findEntryByIndex(cfg, index);
1462		} else {
1463		entry = findEntryByTitle(cfg, defTitle, &index);
1464		}
1465		if (entry)
1466		cfg->defaultImage = index;
1467		}
1468		} else {
1469		cfg->defaultImage = 0;
1470	}	}
1471
1472	return cfg;	return cfg;
#	Line 749  static void writeDefault(FILE * out, cha	Line 1482  static void writeDefault(FILE * out, cha
1482
1483	if (cfg->defaultImage == DEFAULT_SAVED)	if (cfg->defaultImage == DEFAULT_SAVED)
1484	fprintf(out, "%sdefault%ssaved\n", indent, separator);	fprintf(out, "%sdefault%ssaved\n", indent, separator);
1485	else if (cfg->defaultImage > -1) {	else if (cfg->cfi->defaultIsSaved) {
1486		fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
1487		if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
1488		char *title;
1489		entry = findEntryByIndex(cfg, cfg->defaultImage);
1490		line = getLineByType(LT_MENUENTRY, entry->lines);
1491		if (!line)
1492		line = getLineByType(LT_TITLE, entry->lines);
1493		if (line) {
1494		title = extractTitle(line);
1495		if (title)
1496		cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
1497		}
1498		}
1499		} else if (cfg->defaultImage > -1) {
1500	if (cfg->cfi->defaultIsIndex) {	if (cfg->cfi->defaultIsIndex) {
1501	fprintf(out, "%sdefault%s%d\n", indent, separator,	if (cfg->cfi->defaultIsVariable) {
1502	cfg->defaultImage);	fprintf(out, "%sset default=\"%d\"\n", indent,
1503		cfg->defaultImage);
1504		} else {
1505		fprintf(out, "%sdefault%s%d\n", indent, separator,
1506		cfg->defaultImage);
1507		}
1508	} else {	} else {
1509	int image = cfg->defaultImage;	int image = cfg->defaultImage;
1510
#	Line 769  static void writeDefault(FILE * out, cha	Line 1521  static void writeDefault(FILE * out, cha
1521
1522	if (!entry) return;	if (!entry) return;
1523
1524	line = entry->lines;	line = getLineByType(LT_TITLE, entry->lines);
	while (line && line->type != LT_TITLE) line = line->next;
1525
1526	if (line && line->numElements >= 2)	if (line && line->numElements >= 2)
1527	fprintf(out, "%sdefault%s%s\n", indent, separator,	fprintf(out, "%sdefault%s%s\n", indent, separator,
#	Line 804  static int writeConfig(struct grubConfig	Line 1555  static int writeConfig(struct grubConfig
1555	int rc;	int rc;
1556
1557	/* most likely the symlink is relative, so change our	/* most likely the symlink is relative, so change our
1558	directory to / */	directory to the dir of the symlink */
1559	rc = chdir("/");	char *dir = strdupa(outName);
1560		rc = chdir(dirname(dir));
1561	do {	do {
1562	buf = alloca(len + 1);	buf = alloca(len + 1);
1563	rc = readlink(outName, buf, len);	rc = readlink(basename(outName), buf, len);
1564	if (rc == len) len += 256;	if (rc == len) len += 256;
1565	} while (rc == len);	} while (rc == len);
1566
#	Line 843  static int writeConfig(struct grubConfig	Line 1595  static int writeConfig(struct grubConfig
1595	}	}
1596
1597	line = cfg->theLines;	line = cfg->theLines;
1598		struct keywordTypes *defaultKw = getKeywordByType(LT_DEFAULT, cfg->cfi);
1599	while (line) {	while (line) {
1600	if (line->type == LT_DEFAULT) {	if (line->type == LT_SET_VARIABLE && defaultKw &&
1601		line->numElements == 3 &&
1602		!strcmp(line->elements[1].item, defaultKw->key) &&
1603		!is_special_grub2_variable(line->elements[2].item)) {
1604		writeDefault(out, line->indent, line->elements[0].indent, cfg);
1605		needs &= ~MAIN_DEFAULT;
1606		} else if (line->type == LT_DEFAULT) {
1607	writeDefault(out, line->indent, line->elements[0].indent, cfg);	writeDefault(out, line->indent, line->elements[0].indent, cfg);
1608	needs &= ~MAIN_DEFAULT;	needs &= ~MAIN_DEFAULT;
1609	} else if (line->type == LT_FALLBACK) {	} else if (line->type == LT_FALLBACK) {
#	Line 912  static int numEntries(struct grubConfig	Line 1671  static int numEntries(struct grubConfig
1671	return i;	return i;
1672	}	}
1673
1674	int suitableImage(struct singleEntry * entry, const char * bootPrefix,	static char *findDiskForRoot()
1675	int skipRemoved, int flags) {	{
1676	struct singleLine * line;	int fd;
1677	char * fullName;	char buf[65536];
1678	int i;	char *devname;
1679	struct stat sb, sb2;	char *chptr;
1680	char * dev;	int rc;
	char * end;
	char * rootspec;
1681
1682	line = entry->lines;	if ((fd = open(_PATH_MOUNTED, O_RDONLY)) < 0) {
1683	while (line && line->type != LT_KERNEL) line = line->next;	fprintf(stderr, "grubby: failed to open %s: %s\n",
1684		_PATH_MOUNTED, strerror(errno));
1685	if (!line) return 0;	return NULL;
1686	if (skipRemoved && entry->skip) return 0;	}
	if (line->numElements < 2) return 0;
1687
1688	if (flags & GRUBBY_BADIMAGE_OKAY) return 1;	rc = read(fd, buf, sizeof(buf) - 1);
1689		if (rc <= 0) {
1690		fprintf(stderr, "grubby: failed to read %s: %s\n",
1691		_PATH_MOUNTED, strerror(errno));
1692		close(fd);
1693		return NULL;
1694		}
1695		close(fd);
1696		buf[rc] = '\0';
1697		chptr = buf;
1698
1699		char *foundanswer = NULL;
1700
1701		while (chptr && chptr != buf+rc) {
1702		devname = chptr;
1703
1704		/*
1705		* The first column of a mtab entry is the device, but if the entry is a
1706		* special device it won't start with /, so move on to the next line.
1707		*/
1708		if (*devname != '/') {
1709		chptr = strchr(chptr, '\n');
1710		if (chptr)
1711		chptr++;
1712		continue;
1713		}
1714
1715		/* Seek to the next space */
1716		chptr = strchr(chptr, ' ');
1717		if (!chptr) {
1718		fprintf(stderr, "grubby: error parsing %s: %s\n",
1719		_PATH_MOUNTED, strerror(errno));
1720		return NULL;
1721		}
1722
1723		/*
1724		* The second column of a mtab entry is the mount point, we are looking
1725		* for '/' obviously.
1726		*/
1727		if (*(++chptr) == '/' && *(++chptr) == ' ') {
1728		/* remember the last / entry in mtab */
1729		foundanswer = devname;
1730		}
1731
1732		/* Next line */
1733		chptr = strchr(chptr, '\n');
1734		if (chptr)
1735		chptr++;
1736		}
1737
1738		/* Return the last / entry found */
1739		if (foundanswer) {
1740		chptr = strchr(foundanswer, ' ');
1741		*chptr = '\0';
1742		return strdup(foundanswer);
1743		}
1744
1745		return NULL;
1746		}
1747
1748		void printEntry(struct singleEntry * entry, FILE *f) {
1749		int i;
1750		struct singleLine * line;
1751
1752		for (line = entry->lines; line; line = line->next) {
1753		log_message(f, "DBG: %s", line->indent);
1754		for (i = 0; i < line->numElements; i++) {
1755		/* Need to handle this, because we strip the quotes from
1756		* menuentry when read it. */
1757		if (line->type == LT_MENUENTRY && i == 1) {
1758		if(!isquote(*line->elements[i].item))
1759		log_message(f, "\'%s\'", line->elements[i].item);
1760		else
1761		log_message(f, "%s", line->elements[i].item);
1762		log_message(f, "%s", line->elements[i].indent);
1763
1764		continue;
1765		}
1766
1767		log_message(f, "%s%s",
1768		line->elements[i].item, line->elements[i].indent);
1769		}
1770		log_message(f, "\n");
1771		}
1772		}
1773
1774		void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
1775		{
1776		static int once;
1777		va_list argp, argq;
1778
1779		va_start(argp, fmt);
1780
1781		va_copy(argq, argp);
1782		if (!once) {
1783		log_time(NULL);
1784		log_message(NULL, "command line: %s\n", saved_command_line);
1785		}
1786		log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
1787		log_vmessage(NULL, fmt, argq);
1788
1789		printEntry(entry, NULL);
1790		va_end(argq);
1791
1792		if (!debug) {
1793		once = 1;
1794		va_end(argp);
1795		return;
1796		}
1797
1798		if (okay) {
1799		va_end(argp);
1800		return;
1801		}
1802
1803		if (!once)
1804		log_message(stderr, "DBG: command line: %s\n", saved_command_line);
1805		once = 1;
1806		fprintf(stderr, "DBG: Image entry failed: ");
1807		vfprintf(stderr, fmt, argp);
1808		printEntry(entry, stderr);
1809		va_end(argp);
1810		}
1811
1812		#define beginswith(s, c) ((s) && (s)[0] == (c))
1813
1814		static int endswith(const char *s, char c)
1815		{
1816		int slen;
1817
1818		if (!s || !s[0])
1819		return 0;
1820		slen = strlen(s) - 1;
1821
1822		return s[slen] == c;
1823		}
1824
1825		int suitableImage(struct singleEntry * entry, const char * bootPrefix,
1826		int skipRemoved, int flags) {
1827		struct singleLine * line;
1828		char * fullName;
1829		int i;
1830		char * dev;
1831		char * rootspec;
1832		char * rootdev;
1833
1834		if (skipRemoved && entry->skip) {
1835		notSuitablePrintf(entry, 0, "marked to skip\n");
1836		return 0;
1837		}
1838
1839		line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
1840		if (!line) {
1841		notSuitablePrintf(entry, 0, "no line found\n");
1842		return 0;
1843		}
1844		if (line->numElements < 2) {
1845		notSuitablePrintf(entry, 0, "line has only %d elements\n",
1846		line->numElements);
1847		return 0;
1848		}
1849
1850		if (flags & GRUBBY_BADIMAGE_OKAY) {
1851		notSuitablePrintf(entry, 1, "\n");
1852		return 1;
1853		}
1854
1855	fullName = alloca(strlen(bootPrefix) +	fullName = alloca(strlen(bootPrefix) +
1856	strlen(line->elements[1].item) + 1);	strlen(line->elements[1].item) + 1);
1857	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
1858	sprintf(fullName, "%s%s", bootPrefix,	int rootspec_offset = rootspec ? strlen(rootspec) : 0;
1859	line->elements[1].item + ((rootspec != NULL) ?	int hasslash = endswith(bootPrefix, '/') ||
1860	strlen(rootspec) : 0));	beginswith(line->elements[1].item + rootspec_offset, '/');
1861	if (access(fullName, R_OK)) return 0;	sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
1862		line->elements[1].item + rootspec_offset);
1863		if (access(fullName, R_OK)) {
1864		notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
1865		return 0;
1866		}
1867	for (i = 2; i < line->numElements; i++)	for (i = 2; i < line->numElements; i++)
1868	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1869	if (i < line->numElements) {	if (i < line->numElements) {
1870	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1871	} else {	} else {
1872	/* look for a lilo style LT_ROOT line */	/* look for a lilo style LT_ROOT line */
1873	line = entry->lines;	line = getLineByType(LT_ROOT, entry->lines);
	while (line && line->type != LT_ROOT) line = line->next;
1874
1875	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
1876	dev = line->elements[1].item;	dev = line->elements[1].item;
1877	} else {	} else {
1878	int type;	/* didn't succeed in finding a LT_ROOT, let's try LT_KERNELARGS.
1879	/* 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.
1880	line = entry->lines;	*/
1881		line = getLineByType(LT_KERNELARGS|LT_MBMODULE, entry->lines);
	type = ((entry->multiboot) ? LT_MBMODULE : LT_KERNELARGS);
	while (line && line->type != type) line = line->next;
1882
1883	/* failed to find one */	/* failed to find one */
1884	if (!line) return 0;	if (!line) {
1885		notSuitablePrintf(entry, 0, "no line found\n");
1886		return 0;
1887		}
1888
1889	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
1890	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;	if (!strncasecmp(line->elements[i].item, "root=", 5)) break;
1891	if (i < line->numElements)	if (i < line->numElements)
1892	dev = line->elements[i].item + 5;	dev = line->elements[i].item + 5;
1893	else {	else {
1894		notSuitablePrintf(entry, 0, "no root= entry found\n");
1895	/* it failed too...  can't find root= */	/* it failed too...  can't find root= */
1896	return 0;	return 0;
1897	}	}
1898	}	}
1899	}	}
1900
1901	if (!strncmp(dev, "LABEL=", 6)) {	dev = getpathbyspec(dev);
1902	dev += 6;	if (!getpathbyspec(dev)) {
1903		notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
1904	/* check which device has this label */	return 0;
1905	dev = get_spec_by_volume_label(dev, &i, &i);	} else
1906	if (!dev) return 0;	dev = getpathbyspec(dev);
1907
1908		rootdev = findDiskForRoot();
1909		if (!rootdev) {
1910		notSuitablePrintf(entry, 0, "can't find root device\n");
1911		return 0;
1912	}	}
1913
1914	if (*dev == '/') {	if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
1915	if (stat(dev, &sb))	notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
1916	return 0;	getuuidbydev(rootdev), getuuidbydev(dev));
1917	} else {	free(rootdev);
1918	sb.st_rdev = strtol(dev, &end, 16);	return 0;
1919	if (*end) return 0;	}
1920
1921		if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
1922		notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
1923		getuuidbydev(rootdev), getuuidbydev(dev));
1924		free(rootdev);
1925		return 0;
1926	}	}
	stat("/", &sb2);
1927
1928	if (sb.st_rdev != sb2.st_dev) return 0;	free(rootdev);
1929		notSuitablePrintf(entry, 1, "\n");
1930
1931	return 1;	return 1;
1932	}	}
#	Line 1024  struct singleEntry * findEntryByPath(str	Line 1960  struct singleEntry * findEntryByPath(str
1960	}	}
1961
1962	indexVars[i + 1] = -1;	indexVars[i + 1] = -1;
1963
1964	i = 0;	i = 0;
1965	if (index) {	if (index) {
1966	while (i < *index) i++;	while (i < *index) {
1967	if (indexVars[i] == -1) return NULL;	i++;
1968		if (indexVars[i] == -1) return NULL;
1969		}
1970	}	}
1971
1972	entry = findEntryByIndex(config, indexVars[i]);	entry = findEntryByIndex(config, indexVars[i]);
1973	if (!entry) return NULL;	if (!entry) return NULL;
1974
1975	line = entry->lines;	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
	while (line && line->type != LT_KERNEL)
	line = line->next;
1976	if (!line) return NULL;	if (!line) return NULL;
1977
1978	if (index) *index = indexVars[i];	if (index) *index = indexVars[i];
#	Line 1075  struct singleEntry * findEntryByPath(str	Line 2010  struct singleEntry * findEntryByPath(str
2010
2011	if (!strncmp(kernel, "TITLE=", 6)) {	if (!strncmp(kernel, "TITLE=", 6)) {
2012	prefix = "";	prefix = "";
2013	checkType = LT_TITLE;	checkType = LT_TITLE|LT_MENUENTRY;
2014	kernel += 6;	kernel += 6;
2015	}	}
2016
2017	while ((entry = findEntryByIndex(config, i))) {	for (entry = findEntryByIndex(config, i); entry; entry = entry->next, i++) {
2018	line = entry->lines;	if (entry->skip) continue;
	while (line && line->type != checkType) line=line->next;
2019
2020		dbgPrintf("findEntryByPath looking for %d %s in %p\n", checkType, kernel, entry);
2021
2022	if (line && line->numElements >= 2 && !entry->skip) {	/* check all the lines matching checkType */
2023	rootspec = getRootSpecifier(line->elements[1].item);	for (line = entry->lines; line; line = line->next) {
2024	if (!strcmp(line->elements[1].item  +	enum lineType_e ct = checkType;
2025	((rootspec != NULL) ? strlen(rootspec) : 0),	if (entry->multiboot && checkType == LT_KERNEL)
2026	kernel + strlen(prefix)))	ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
2027	break;	else if (checkType & LT_KERNEL)
2028	}	ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
2029		line = getLineByType(ct, line);
2030	/* have to check multiboot lines too */	if (!line)
2031	if (entry->multiboot) {	break;  /* not found in this entry */
2032	while (line && line->type != LT_MBMODULE) line = line->next;
2033	if (line && line->numElements >= 2 && !entry->skip) {	if (line && line->type != LT_MENUENTRY &&
2034	rootspec = getRootSpecifier(line->elements[1].item);	line->numElements >= 2) {
2035	if (!strcmp(line->elements[1].item  +	rootspec = getRootSpecifier(line->elements[1].item);
2036	((rootspec != NULL) ? strlen(rootspec) : 0),	if (!strcmp(line->elements[1].item +
2037	kernel + strlen(prefix)))	((rootspec != NULL) ? strlen(rootspec) : 0),
2038	break;	kernel + strlen(prefix)))
2039	}	break;
2040	}	}
2041		if(line->type == LT_MENUENTRY &&
2042		!strcmp(line->elements[1].item, kernel))
2043		break;
2044		}
2045
2046	i++;	/* make sure this entry has a kernel identifier; this skips
2047		* non-Linux boot entries (could find netbsd etc, though, which is
2048		* unfortunate)
2049		*/
2050		if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
2051		break; /* found 'im! */
2052	}	}
2053
2054	if (index) *index = i;	if (index) *index = i;
2055	}	}
2056
2057	if (!entry) return NULL;	return entry;
2058		}
2059
2060	/* make sure this entry has a kernel identifier; this skips non-Linux	struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
2061	boot entries (could find netbsd etc, though, which is unfortunate) */	int * index) {
2062	line = entry->lines;	struct singleEntry * entry;
2063	while (line && line->type != LT_KERNEL) line = line->next;	struct singleLine * line;
2064	if (!line) {	int i;
2065	if (!index) index = &i;	char * newtitle;
2066	(*index)++;
2067	return findEntryByPath(config, kernel, prefix, index);	for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
2068		if (index && i < *index)
2069		continue;
2070		line = getLineByType(LT_TITLE, entry->lines);
2071		if (!line)
2072		line = getLineByType(LT_MENUENTRY, entry->lines);
2073		if (!line)
2074		continue;
2075		newtitle = grub2ExtractTitle(line);
2076		if (!newtitle)
2077		continue;
2078		if (!strcmp(title, newtitle))
2079		break;
2080	}	}
2081
2082		if (!entry)
2083		return NULL;
2084
2085		if (index)
2086		*index = i;
2087	return entry;	return entry;
2088	}	}
2089
#	Line 1147  struct singleEntry * findTemplate(struct	Line 2109  struct singleEntry * findTemplate(struct
2109	struct singleEntry * entry, * entry2;	struct singleEntry * entry, * entry2;
2110	int index;	int index;
2111
2112	if (cfg->defaultImage > -1) {	if (cfg->cfi->defaultIsSaved) {
2113		if (cfg->cfi->getEnv) {
2114		char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
2115		if (defTitle) {
2116		int index = 0;
2117		if (isnumber(defTitle)) {
2118		index = atoi(defTitle);
2119		entry = findEntryByIndex(cfg, index);
2120		} else {
2121		entry = findEntryByTitle(cfg, defTitle, &index);
2122		}
2123		if (entry)
2124		cfg->defaultImage = index;
2125		}
2126		}
2127		} else if (cfg->defaultImage > -1) {
2128	entry = findEntryByIndex(cfg, cfg->defaultImage);	entry = findEntryByIndex(cfg, cfg->defaultImage);
2129	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {	if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
2130	if (indexPtr) *indexPtr = cfg->defaultImage;	if (indexPtr) *indexPtr = cfg->defaultImage;
#	Line 1200  void markRemovedImage(struct grubConfig	Line 2177  void markRemovedImage(struct grubConfig
2177	const char * prefix) {	const char * prefix) {
2178	struct singleEntry * entry;	struct singleEntry * entry;
2179
2180	if (!image) return;	if (!image)
2181		return;
2182
2183		/* check and see if we're removing the default image */
2184		if (isdigit(*image)) {
2185		entry = findEntryByPath(cfg, image, prefix, NULL);
2186		if(entry)
2187		entry->skip = 1;
2188		return;
2189		}
2190
2191	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))	while ((entry = findEntryByPath(cfg, image, prefix, NULL)))
2192	entry->skip = 1;	entry->skip = 1;
#	Line 1208  void markRemovedImage(struct grubConfig	Line 2194  void markRemovedImage(struct grubConfig
2194
2195	void setDefaultImage(struct grubConfig * config, int hasNew,	void setDefaultImage(struct grubConfig * config, int hasNew,
2196	const char * defaultKernelPath, int newIsDefault,	const char * defaultKernelPath, int newIsDefault,
2197	const char * prefix, int flags) {	const char * prefix, int flags, int index) {
2198	struct singleEntry * entry, * entry2, * newDefault;	struct singleEntry * entry, * entry2, * newDefault;
2199	int i, j;	int i, j;
2200
2201	if (newIsDefault) {	if (newIsDefault) {
2202	config->defaultImage = 0;	config->defaultImage = 0;
2203	return;	return;
2204		} else if ((index >= 0) && config->cfi->defaultIsIndex) {
2205		if (findEntryByIndex(config, index))
2206		config->defaultImage = index;
2207		else
2208		config->defaultImage = -1;
2209		return;
2210	} else if (defaultKernelPath) {	} else if (defaultKernelPath) {
2211	i = 0;	i = 0;
2212	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
#	Line 1227  void setDefaultImage(struct grubConfig *	Line 2219  void setDefaultImage(struct grubConfig *
2219
2220	/* defaultImage now points to what we'd like to use, but before any order	/* defaultImage now points to what we'd like to use, but before any order
2221	changes */	changes */
2222	if (config->defaultImage == DEFAULT_SAVED)	if ((config->defaultImage == DEFAULT_SAVED) ||
2223		(config->defaultImage == DEFAULT_SAVED_GRUB2))
2224	/* default is set to saved, we don't want to change it */	/* default is set to saved, we don't want to change it */
2225	return;	return;
2226
#	Line 1285  void displayEntry(struct singleEntry * e	Line 2278  void displayEntry(struct singleEntry * e
2278	struct singleLine * line;	struct singleLine * line;
2279	char * root = NULL;	char * root = NULL;
2280	int i;	int i;
2281		int j;
	line = entry->lines;
	while (line && line->type != LT_KERNEL) line = line->next;
2282
2283	printf("index=%d\n", index);	printf("index=%d\n", index);
2284
2285	printf("kernel=%s\n", line->elements[1].item);	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
2286		if (!line) {
2287		printf("non linux entry\n");
2288		return;
2289		}
2290
2291		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2292		printf("kernel=%s\n", line->elements[1].item);
2293		else
2294		printf("kernel=%s%s\n", prefix, line->elements[1].item);
2295
2296	if (line->numElements >= 3) {	if (line->numElements >= 3) {
2297	printf("args=\"");	printf("args=\"");
#	Line 1308  void displayEntry(struct singleEntry * e	Line 2308  void displayEntry(struct singleEntry * e
2308	}	}
2309	printf("\"\n");	printf("\"\n");
2310	} else {	} else {
2311	line = entry->lines;	line = getLineByType(LT_KERNELARGS, entry->lines);
	while (line && line->type != LT_KERNELARGS) line=line->next;
2312	if (line) {	if (line) {
2313	char * s;	char * s;
2314
#	Line 1334  void displayEntry(struct singleEntry * e	Line 2332  void displayEntry(struct singleEntry * e
2332	}	}
2333
2334	if (!root) {	if (!root) {
2335	line = entry->lines;	line = getLineByType(LT_ROOT, entry->lines);
	while (line && line->type != LT_ROOT) line = line->next;
2336	if (line && line->numElements >= 2)	if (line && line->numElements >= 2)
2337	root=line->elements[1].item;	root=line->elements[1].item;
2338	}	}
#	Line 1351  void displayEntry(struct singleEntry * e	Line 2347  void displayEntry(struct singleEntry * e
2347	printf("root=%s\n", s);	printf("root=%s\n", s);
2348	}	}
2349
2350	line = entry->lines;	line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
	while (line && line->type != LT_INITRD) line = line->next;
2351
2352	if (line && line->numElements >= 2) {	if (line && line->numElements >= 2) {
2353	printf("initrd=%s", prefix);	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2354		printf("initrd=");
2355		else
2356		printf("initrd=%s", prefix);
2357
2358	for (i = 1; i < line->numElements; i++)	for (i = 1; i < line->numElements; i++)
2359	printf("%s%s", line->elements[i].item, line->elements[i].indent);	printf("%s%s", line->elements[i].item, line->elements[i].indent);
2360	printf("\n");	printf("\n");
2361	}	}
2362
2363		line = getLineByType(LT_TITLE, entry->lines);
2364		if (line) {
2365		printf("title=%s\n", line->elements[1].item);
2366		} else {
2367		char * title;
2368		line = getLineByType(LT_MENUENTRY, entry->lines);
2369		title = grub2ExtractTitle(line);
2370		if (title)
2371		printf("title=%s\n", title);
2372		}
2373
2374		for (j = 0, line = entry->lines; line; line = line->next) {
2375		if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
2376		if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
2377		printf("mbmodule%d=", j);
2378		else
2379		printf("mbmodule%d=%s", j, prefix);
2380
2381		for (i = 1; i < line->numElements; i++)
2382		printf("%s%s", line->elements[i].item, line->elements[i].indent);
2383		printf("\n");
2384		j++;
2385		}
2386		}
2387		}
2388
2389		int isSuseSystem(void) {
2390		const char * path;
2391		const static char default_path[] = "/etc/SuSE-release";
2392
2393		if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
2394		path = default_path;
2395
2396		if (!access(path, R_OK))
2397		return 1;
2398		return 0;
2399		}
2400
2401		int isSuseGrubConf(const char * path) {
2402		FILE * grubConf;
2403		char * line = NULL;
2404		size_t len = 0, res = 0;
2405
2406		grubConf = fopen(path, "r");
2407		if (!grubConf) {
2408		dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
2409		return 0;
2410		}
2411
2412		while ((res = getline(&line, &len, grubConf)) != -1) {
2413		if (!strncmp(line, "setup", 5)) {
2414		fclose(grubConf);
2415		free(line);
2416		return 1;
2417		}
2418		}
2419
2420		dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
2421		path);
2422
2423		fclose(grubConf);
2424		free(line);
2425		return 0;
2426		}
2427
2428		int suseGrubConfGetLba(const char * path, int * lbaPtr) {
2429		FILE * grubConf;
2430		char * line = NULL;
2431		size_t res = 0, len = 0;
2432
2433		if (!path) return 1;
2434		if (!lbaPtr) return 1;
2435
2436		grubConf = fopen(path, "r");
2437		if (!grubConf) return 1;
2438
2439		while ((res = getline(&line, &len, grubConf)) != -1) {
2440		if (line[res - 1] == '\n')
2441		line[res - 1] = '\0';
2442		else if (len > res)
2443		line[res] = '\0';
2444		else {
2445		line = realloc(line, res + 1);
2446		line[res] = '\0';
2447		}
2448
2449		if (!strncmp(line, "setup", 5)) {
2450		if (strstr(line, "--force-lba")) {
2451		*lbaPtr = 1;
2452		} else {
2453		*lbaPtr = 0;
2454		}
2455		dbgPrintf("lba: %i\n", *lbaPtr);
2456		break;
2457		}
2458		}
2459
2460		free(line);
2461		fclose(grubConf);
2462		return 0;
2463		}
2464
2465		int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
2466		FILE * grubConf;
2467		char * line = NULL;
2468		size_t res = 0, len = 0;
2469		char * lastParamPtr = NULL;
2470		char * secLastParamPtr = NULL;
2471		char installDeviceNumber = '\0';
2472		char * bounds = NULL;
2473
2474		if (!path) return 1;
2475		if (!devicePtr) return 1;
2476
2477		grubConf = fopen(path, "r");
2478		if (!grubConf) return 1;
2479
2480		while ((res = getline(&line, &len, grubConf)) != -1) {
2481		if (strncmp(line, "setup", 5))
2482		continue;
2483
2484		if (line[res - 1] == '\n')
2485		line[res - 1] = '\0';
2486		else if (len > res)
2487		line[res] = '\0';
2488		else {
2489		line = realloc(line, res + 1);
2490		line[res] = '\0';
2491		}
2492
2493		lastParamPtr = bounds = line + res;
2494
2495		/* Last parameter in grub may be an optional IMAGE_DEVICE */
2496		while (!isspace(*lastParamPtr))
2497		lastParamPtr--;
2498		lastParamPtr++;
2499
2500		secLastParamPtr = lastParamPtr - 2;
2501		dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
2502
2503		if (lastParamPtr + 3 > bounds) {
2504		dbgPrintf("lastParamPtr going over boundary");
2505		fclose(grubConf);
2506		free(line);
2507		return 1;
2508		}
2509		if (!strncmp(lastParamPtr, "(hd", 3))
2510		lastParamPtr += 3;
2511		dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
2512
2513		/*
2514		* Second last parameter will decide wether last parameter is
2515		* an IMAGE_DEVICE or INSTALL_DEVICE
2516		*/
2517		while (!isspace(*secLastParamPtr))
2518		secLastParamPtr--;
2519		secLastParamPtr++;
2520
2521		if (secLastParamPtr + 3 > bounds) {
2522		dbgPrintf("secLastParamPtr going over boundary");
2523		fclose(grubConf);
2524		free(line);
2525		return 1;
2526		}
2527		dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
2528		if (!strncmp(secLastParamPtr, "(hd", 3)) {
2529		secLastParamPtr += 3;
2530		dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
2531		installDeviceNumber = *secLastParamPtr;
2532		} else {
2533		installDeviceNumber = *lastParamPtr;
2534		}
2535
2536		*devicePtr = malloc(6);
2537		snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
2538		dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
2539		fclose(grubConf);
2540		free(line);
2541		return 0;
2542		}
2543
2544		free(line);
2545		fclose(grubConf);
2546		return 1;
2547		}
2548
2549		int grubGetBootFromDeviceMap(const char * device,
2550		char ** bootPtr) {
2551		FILE * deviceMap;
2552		char * line = NULL;
2553		size_t res = 0, len = 0;
2554		char * devicePtr;
2555		char * bounds = NULL;
2556		const char * path;
2557		const static char default_path[] = "/boot/grub/device.map";
2558
2559		if (!device) return 1;
2560		if (!bootPtr) return 1;
2561
2562		if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
2563		path = default_path;
2564
2565		dbgPrintf("opening grub device.map file from: %s\n", path);
2566		deviceMap = fopen(path, "r");
2567		if (!deviceMap)
2568		return 1;
2569
2570		while ((res = getline(&line, &len, deviceMap)) != -1) {
2571		if (!strncmp(line, "#", 1))
2572		continue;
2573
2574		if (line[res - 1] == '\n')
2575		line[res - 1] = '\0';
2576		else if (len > res)
2577		line[res] = '\0';
2578		else {
2579		line = realloc(line, res + 1);
2580		line[res] = '\0';
2581		}
2582
2583		devicePtr = line;
2584		bounds = line + res;
2585
2586		while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
2587		devicePtr++;
2588		dbgPrintf("device: %s\n", devicePtr);
2589
2590		if (!strncmp(devicePtr, device, strlen(device))) {
2591		devicePtr += strlen(device);
2592		while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
2593		devicePtr++;
2594
2595		*bootPtr = strdup(devicePtr);
2596		break;
2597		}
2598		}
2599
2600		free(line);
2601		fclose(deviceMap);
2602		return 0;
2603		}
2604
2605		int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
2606		char * grubDevice;
2607
2608		if (suseGrubConfGetInstallDevice(path, &grubDevice))
2609		dbgPrintf("error looking for grub installation device\n");
2610		else
2611		dbgPrintf("grubby installation device: %s\n", grubDevice);
2612
2613		if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
2614		dbgPrintf("error looking for grub boot device\n");
2615		else
2616		dbgPrintf("grubby boot device: %s\n", *bootPtr);
2617
2618		free(grubDevice);
2619		return 0;
2620		}
2621
2622		int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
2623		/*
2624		* This SuSE grub configuration file at this location is not your average
2625		* grub configuration file, but instead the grub commands used to setup
2626		* grub on that system.
2627		*/
2628		const char * path;
2629		const static char default_path[] = "/etc/grub.conf";
2630
2631		if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
2632		path = default_path;
2633
2634		if (!isSuseGrubConf(path)) return 1;
2635
2636		if (lbaPtr) {
2637		*lbaPtr = 0;
2638		if (suseGrubConfGetLba(path, lbaPtr))
2639		return 1;
2640		}
2641
2642		if (bootPtr) {
2643		*bootPtr = NULL;
2644		suseGrubConfGetBoot(path, bootPtr);
2645		}
2646
2647		return 0;
2648	}	}
2649
2650	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {	int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
#	Line 1369  int parseSysconfigGrub(int * lbaPtr, cha	Line 2654  int parseSysconfigGrub(int * lbaPtr, cha
2654	char * start;	char * start;
2655	char * param;	char * param;
2656
2657	in = fopen("/etc/sysconfig/grub", "r");	in = fopen("/etc/conf.d/grub", "r");
2658	if (!in) return 1;	if (!in) return 1;
2659
2660	if (lbaPtr) *lbaPtr = 0;	if (lbaPtr) *lbaPtr = 0;
#	Line 1410  int parseSysconfigGrub(int * lbaPtr, cha	Line 2695  int parseSysconfigGrub(int * lbaPtr, cha
2695	}	}
2696
2697	void dumpSysconfigGrub(void) {	void dumpSysconfigGrub(void) {
2698	char * boot;	char * boot = NULL;
2699	int lba;	int lba;
2700
2701	if (!parseSysconfigGrub(&lba, &boot)) {	if (isSuseSystem()) {
2702	if (lba) printf("lba\n");	if (parseSuseGrubConf(&lba, &boot)) {
2703	if (boot) printf("boot=%s\n", boot);	free(boot);
2704		return;
2705		}
2706		} else {
2707		if (parseSysconfigGrub(&lba, &boot)) {
2708		free(boot);
2709		return;
2710		}
2711		}
2712
2713		if (lba) printf("lba\n");
2714		if (boot) {
2715		printf("boot=%s\n", boot);
2716		free(boot);
2717	}	}
2718	}	}
2719
#	Line 1431  int displayInfo(struct grubConfig * conf	Line 2729  int displayInfo(struct grubConfig * conf
2729	return 1;	return 1;
2730	}	}
2731
2732	/* this is a horrible hack to support /etc/sysconfig/grub; there must	/* this is a horrible hack to support /etc/conf.d/grub; there must
2733	be a better way */	be a better way */
2734	if (config->cfi == &grubConfigType) {	if (config->cfi == &grubConfigType) {
2735	dumpSysconfigGrub();	dumpSysconfigGrub();
2736	} else {	} else {
2737	line = config->theLines;	line = getLineByType(LT_BOOT, config->theLines);
	while (line && line->type != LT_BOOT) line = line->next;
2738	if (line && line->numElements >= 1) {	if (line && line->numElements >= 1) {
2739	printf("boot=%s\n", line->elements[1].item);	printf("boot=%s\n", line->elements[1].item);
2740	}	}
2741
2742	line = config->theLines;	line = getLineByType(LT_LBA, config->theLines);
	while (line && line->type != LT_LBA) line = line->next;
2743	if (line) printf("lba\n");	if (line) printf("lba\n");
2744	}	}
2745
#	Line 1458  int displayInfo(struct grubConfig * conf	Line 2754  int displayInfo(struct grubConfig * conf
2754	return 0;	return 0;
2755	}	}
2756
2757		struct singleLine * addLineTmpl(struct singleEntry * entry,
2758		struct singleLine * tmplLine,
2759		struct singleLine * prevLine,
2760		const char * val,
2761		struct configFileInfo * cfi)
2762		{
2763		struct singleLine * newLine = lineDup(tmplLine);
2764
2765		if (isEfi && cfi == &grub2ConfigType) {
2766		enum lineType_e old = newLine->type;
2767		newLine->type = preferredLineType(newLine->type, cfi);
2768		if (old != newLine->type)
2769		newLine->elements[0].item = getKeyByType(newLine->type, cfi);
2770		}
2771
2772		if (val) {
2773		/* override the inherited value with our own.
2774		* This is a little weak because it only applies to elements[1]
2775		*/
2776		if (newLine->numElements > 1)
2777		removeElement(newLine, 1);
2778		insertElement(newLine, val, 1, cfi);
2779
2780		/* but try to keep the rootspec from the template... sigh */
2781		if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI|LT_KERNEL_16|LT_INITRD_16)) {
2782		char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
2783		if (rootspec != NULL) {
2784		free(newLine->elements[1].item);
2785		newLine->elements[1].item =
2786		sdupprintf("%s%s", rootspec, val);
2787		}
2788		}
2789		}
2790
2791		dbgPrintf("addLineTmpl(%s)\n", newLine->numElements ?
2792		newLine->elements[0].item : "");
2793
2794		if (!entry->lines) {
2795		/* first one on the list */
2796		entry->lines = newLine;
2797		} else if (prevLine) {
2798		/* add after prevLine */
2799		newLine->next = prevLine->next;
2800		prevLine->next = newLine;
2801		}
2802
2803		return newLine;
2804		}
2805
2806	/* val may be NULL */	/* val may be NULL */
2807	struct singleLine *  addLine(struct singleEntry * entry,	struct singleLine *  addLine(struct singleEntry * entry,
2808	struct configFileInfo * cfi,	struct configFileInfo * cfi,
2809	enum lineType_e type, const char * defaultIndent,	enum lineType_e type, char * defaultIndent,
2810	char * val) {	const char * val) {
2811	struct singleLine * line, * prev;	struct singleLine * line, * prev;
2812	int i;	struct keywordTypes * kw;
2813		struct singleLine tmpl;
2814
2815	for (i = 0; cfi->keywords[i].key; i++)	/* NB: This function shouldn't allocate items on the heap, rather on the
2816	if (cfi->keywords[i].type == type) break;	* stack since it calls addLineTmpl which will make copies.
2817	if (type != LT_TITLE || !cfi->titleBracketed)	*/
2818	if (!cfi->keywords[i].key) abort();	if (type == LT_TITLE && cfi->titleBracketed) {
2819		/* we're doing a bracketed title (zipl) */
2820		tmpl.type = type;
2821		tmpl.numElements = 1;
2822		tmpl.elements = alloca(sizeof(*tmpl.elements));
2823		tmpl.elements[0].item = alloca(strlen(val)+3);
2824		sprintf(tmpl.elements[0].item, "[%s]", val);
2825		tmpl.elements[0].indent = "";
2826		val = NULL;
2827		} else if (type == LT_MENUENTRY) {
2828		char *lineend = "--class gnu-linux --class gnu --class os {";
2829		if (!val) {
2830		fprintf(stderr, "Line type LT_MENUENTRY requires a value\n");
2831		abort();
2832		}
2833		kw = getKeywordByType(type, cfi);
2834		if (!kw) {
2835		fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
2836		abort();
2837		}
2838		tmpl.indent = "";
2839		tmpl.type = type;
2840		tmpl.numElements = 3;
2841		tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
2842		tmpl.elements[0].item = kw->key;
2843		tmpl.elements[0].indent = alloca(2);
2844		sprintf(tmpl.elements[0].indent, "%c", kw->nextChar);
2845		tmpl.elements[1].item = (char *)val;
2846		tmpl.elements[1].indent = alloca(2);
2847		sprintf(tmpl.elements[1].indent, "%c", kw->nextChar);
2848		tmpl.elements[2].item = alloca(strlen(lineend)+1);
2849		strcpy(tmpl.elements[2].item, lineend);
2850		tmpl.elements[2].indent = "";
2851		} else {
2852		kw = getKeywordByType(type, cfi);
2853		if (!kw) {
2854		fprintf(stderr, "Looking up keyword for unknown type %d\n", type);
2855		abort();
2856		}
2857		tmpl.type = type;
2858		tmpl.numElements = val ? 2 : 1;
2859		tmpl.elements = alloca(sizeof(*tmpl.elements) * tmpl.numElements);
2860		tmpl.elements[0].item = kw->key;
2861		tmpl.elements[0].indent = alloca(2);
2862		sprintf(tmpl.elements[0].indent, "%c", kw->nextChar);
2863		if (val) {
2864		tmpl.elements[1].item = (char *)val;
2865		tmpl.elements[1].indent = "";
2866		}
2867		}
2868
2869	/* The last non-empty line gives us the indention to us and the line	/* The last non-empty line gives us the indention to us and the line
2870	to insert after. Note that comments are considered empty lines, which	to insert after. Note that comments are considered empty lines, which
2871	may not be ideal? If there are no lines or we are looking at the	may not be ideal? If there are no lines or we are looking at the
2872	first line, we use defaultIndent (the first line is normally indented	first line, we use defaultIndent (the first line is normally indented
2873	differently from the rest) */	differently from the rest) */
2874	if (entry->lines) {	for (line = entry->lines, prev = NULL; line; line = line->next) {
2875	line = entry->lines;	if (line->numElements) prev = line;
2876	prev = NULL;	/* fall back on the last line if prev isn't otherwise set */
2877	while (line) {	if (!line->next && !prev) prev = line;
	if (line->numElements) prev = line;
	line = line->next;
	}
	if (!prev) {
	/* just use the last line */
	prev = entry->lines;
	while (prev->next) prev = prev->next;
	}
	line = prev->next;
	prev->next = malloc(sizeof(*line));
	prev->next->next = line;
	line = prev->next;
	if (prev == entry->lines)
	line->indent = strdup(defaultIndent);
	else
	line->indent = strdup(prev->indent);
	} else {
	line = malloc(sizeof(*line));
	line->indent = strdup(defaultIndent);
	line->next = NULL;
2878	}	}
2879
2880	if (type != LT_TITLE || !cfi->titleBracketed) {	struct singleLine *menuEntry;
2881	line->type = type;	menuEntry = getLineByType(LT_MENUENTRY, entry->lines);
2882	line->numElements = val ? 2 : 1;	if (tmpl.type == LT_ENTRY_END) {
2883	line->elements = malloc(sizeof(*line->elements) * line->numElements);	if (menuEntry)
2884	line->elements[0].item = strdup(cfi->keywords[i].key);	tmpl.indent = menuEntry->indent;
2885	line->elements[0].indent = malloc(2);	else
2886	line->elements[0].indent[0] = cfi->keywords[i].nextChar;	tmpl.indent = defaultIndent ?: "";
2887	line->elements[0].indent[1] = '\0';	} else if (tmpl.type != LT_MENUENTRY) {
2888		if (menuEntry)
2889	if (val) {	tmpl.indent = "\t";
2890	line->elements[1].item = val;	else if (prev == entry->lines)
2891	line->elements[1].indent = strdup("");	tmpl.indent = defaultIndent ?: "";
2892	}	else
2893	} else {	tmpl.indent = prev->indent;
	/* we're doing the title of a bracketed title (zipl) */
	line->type = type;
	line->numElements = 1;
	line->elements = malloc(sizeof(*line->elements) * line->numElements);
	line->elements[0].item = malloc(strlen(val) + 3);
	sprintf(line->elements[0].item, "[%s]", val);
	line->elements[0].indent = strdup("");
2894	}	}
2895
2896	return line;	return addLineTmpl(entry, &tmpl, prev, val, cfi);
2897	}	}
2898
2899	void removeLine(struct singleEntry * entry, struct singleLine * line) {	void removeLine(struct singleEntry * entry, struct singleLine * line) {
#	Line 1553  void removeLine(struct singleEntry * ent	Line 2918  void removeLine(struct singleEntry * ent
2918	free(line);	free(line);
2919	}	}
2920
2921		static void requote(struct singleLine *tmplLine, struct configFileInfo * cfi)
2922		{
2923		struct singleLine newLine = {
2924		.indent = tmplLine->indent,
2925		.type = tmplLine->type,
2926		.next = tmplLine->next,
2927		};
2928		int firstQuotedItem = -1;
2929		int quoteLen = 0;
2930		int j;
2931		int element = 0;
2932		char *c;
2933
2934		c = malloc(strlen(tmplLine->elements[0].item) + 1);
2935		strcpy(c, tmplLine->elements[0].item);
2936		insertElement(&newLine, c, element++, cfi);
2937		free(c);
2938		c = NULL;
2939
2940		for (j = 1; j < tmplLine->numElements; j++) {
2941		if (firstQuotedItem == -1) {
2942		quoteLen += strlen(tmplLine->elements[j].item);
2943
2944		if (isquote(tmplLine->elements[j].item[0])) {
2945		firstQuotedItem = j;
2946		quoteLen += strlen(tmplLine->elements[j].indent);
2947		} else {
2948		c = malloc(quoteLen + 1);
2949		strcpy(c, tmplLine->elements[j].item);
2950		insertElement(&newLine, c, element++, cfi);
2951		free(c);
2952		quoteLen = 0;
2953		}
2954		} else {
2955		int itemlen = strlen(tmplLine->elements[j].item);
2956		quoteLen += itemlen;
2957		quoteLen += strlen(tmplLine->elements[j].indent);
2958
2959		if (isquote(tmplLine->elements[j].item[itemlen - 1])) {
2960		c = malloc(quoteLen + 1);
2961		c[0] = '\0';
2962		for (int i = firstQuotedItem; i < j+1; i++) {
2963		strcat(c, tmplLine->elements[i].item);
2964		strcat(c, tmplLine->elements[i].indent);
2965		}
2966		insertElement(&newLine, c, element++, cfi);
2967		free(c);
2968
2969		firstQuotedItem = -1;
2970		quoteLen = 0;
2971		}
2972		}
2973		}
2974		while (tmplLine->numElements)
2975		removeElement(tmplLine, 0);
2976		if (tmplLine->elements)
2977		free(tmplLine->elements);
2978
2979		tmplLine->numElements = newLine.numElements;
2980		tmplLine->elements = newLine.elements;
2981		}
2982
2983		static void insertElement(struct singleLine * line,
2984		const char * item, int insertHere,
2985		struct configFileInfo * cfi)
2986		{
2987		struct keywordTypes * kw;
2988		char indent[2] = "";
2989
2990		/* sanity check */
2991		if (insertHere > line->numElements) {
2992		dbgPrintf("insertElement() adjusting insertHere from %d to %d\n",
2993		insertHere, line->numElements);
2994		insertHere = line->numElements;
2995		}
2996
2997		line->elements = realloc(line->elements, (line->numElements + 1) *
2998		sizeof(*line->elements));
2999		memmove(&line->elements[insertHere+1],
3000		&line->elements[insertHere],
3001		(line->numElements - insertHere) *
3002		sizeof(*line->elements));
3003		line->elements[insertHere].item = strdup(item);
3004
3005		kw = getKeywordByType(line->type, cfi);
3006
3007		if (line->numElements == 0) {
3008		indent[0] = '\0';
3009		} else if (insertHere == 0) {
3010		indent[0] = kw->nextChar;
3011		} else if (kw->separatorChar != '\0') {
3012		indent[0] = kw->separatorChar;
3013		} else {
3014		indent[0] = ' ';
3015		}
3016
3017		if (insertHere > 0 && line->elements[insertHere-1].indent[0] == '\0') {
3018		/* move the end-of-line forward */
3019		line->elements[insertHere].indent =
3020		line->elements[insertHere-1].indent;
3021		line->elements[insertHere-1].indent = strdup(indent);
3022		} else {
3023		line->elements[insertHere].indent = strdup(indent);
3024		}
3025
3026		line->numElements++;
3027
3028		dbgPrintf("insertElement(%s, '%s%s', %d)\n",
3029		line->elements[0].item,
3030		line->elements[insertHere].item,
3031		line->elements[insertHere].indent,
3032		insertHere);
3033		}
3034
3035		static void removeElement(struct singleLine * line, int removeHere) {
3036		int i;
3037
3038		/* sanity check */
3039		if (removeHere >= line->numElements) return;
3040
3041		dbgPrintf("removeElement(%s, %d:%s)\n", line->elements[0].item,
3042		removeHere, line->elements[removeHere].item);
3043
3044		free(line->elements[removeHere].item);
3045
3046		if (removeHere > 1) {
3047		/* previous argument gets this argument's post-indentation */
3048		free(line->elements[removeHere-1].indent);
3049		line->elements[removeHere-1].indent =
3050		line->elements[removeHere].indent;
3051		} else {
3052		free(line->elements[removeHere].indent);
3053		}
3054
3055		/* now collapse the array, but don't bother to realloc smaller */
3056		for (i = removeHere; i < line->numElements - 1; i++)
3057		line->elements[i] = line->elements[i + 1];
3058
3059		line->numElements--;
3060		}
3061
3062	int argMatch(const char * one, const char * two) {	int argMatch(const char * one, const char * two) {
3063	char * first, * second;	char * first, * second;
3064	char * chptr;	char * chptr;
#	Line 1575  int updateActualImage(struct grubConfig	Line 3081  int updateActualImage(struct grubConfig
3081	struct singleEntry * entry;	struct singleEntry * entry;
3082	struct singleLine * line, * rootLine;	struct singleLine * line, * rootLine;
3083	int index = 0;	int index = 0;
3084	int i, j, k;	int i, k;
3085	const char ** newArgs, ** oldArgs;	const char ** newArgs, ** oldArgs;
3086	const char ** arg;	const char ** arg;
3087	const char * chptr;	int useKernelArgs, useRoot;
	int useKernelArgs = 0;
	int useRoot = 0;
3088	int firstElement;	int firstElement;
3089	int *usedElements, *usedArgs;	int *usedElements;
3090		int doreplace;
3091
3092	if (!image) return 0;	if (!image) return 0;
3093
#	Line 1609  int updateActualImage(struct grubConfig	Line 3114  int updateActualImage(struct grubConfig
3114	}	}
3115	}	}
3116
	for (i = 0; cfg->cfi->keywords[i].key; i++)
	if (cfg->cfi->keywords[i].type == LT_KERNELARGS) break;
	if (cfg->cfi->keywords[i].key)
	useKernelArgs = 1;
3117
3118	for (i = 0; cfg->cfi->keywords[i].key; i++)	useKernelArgs = (getKeywordByType(LT_KERNELARGS, cfg->cfi)
3119	if (cfg->cfi->keywords[i].type == LT_ROOT) break;	&& (!multibootArgs || cfg->cfi->mbConcatArgs));
3120
3121	if (cfg->cfi->keywords[i].key)	useRoot = (getKeywordByType(LT_ROOT, cfg->cfi)
3122	useRoot = 1;	&& !multibootArgs);
3123
3124	k = 0;	for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
	for (arg = newArgs; *arg; arg++)
	k++;
	usedArgs = calloc(k, sizeof(int));
	while ((entry = findEntryByPath(cfg, image, prefix, &index))) {
	index++;
3125
3126	line = entry->lines;	if (multibootArgs && !entry->multiboot)
3127	while (line && line->type != LT_KERNEL) line = line->next;	continue;
3128	if (!line) continue;
3129	firstElement = 2;	/* Determine where to put the args.  If this config supports
3130		* LT_KERNELARGS, use that.  Otherwise use
3131	if (entry->multiboot && !multibootArgs) {	* LT_HYPER/LT_KERNEL/LT_MBMODULE lines.
3132	/* first mb module line is the real kernel */	*/
3133	while (line && line->type != LT_MBMODULE) line = line->next;	if (useKernelArgs) {
3134	firstElement = 2;	line = getLineByType(LT_KERNELARGS, entry->lines);
3135	} else if (useKernelArgs) {	if (!line) {
3136	while (line && line->type != LT_KERNELARGS) line = line->next;	/* no LT_KERNELARGS, need to add it */
3137		line = addLine(entry, cfg->cfi, LT_KERNELARGS,
3138		cfg->secondaryIndent, NULL);
3139		}
3140	firstElement = 1;	firstElement = 1;
3141
3142		} else if (multibootArgs) {
3143		line = getLineByType(LT_HYPER, entry->lines);
3144		if (!line) {
3145		/* a multiboot entry without LT_HYPER? */
3146		continue;
3147		}
3148		firstElement = 2;
3149
3150		} else {
3151		line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3152		if (!line) {
3153		/* no LT_KERNEL or LT_MBMODULE in this entry? */
3154		continue;
3155		}
3156		firstElement = 2;
3157	}	}
3158
3159	if (!line && useKernelArgs) {	/* handle the elilo case which does:
3160	/* no append in there, need to add it */	*   append="hypervisor args -- kernel args"
3161	line = addLine(entry, cfg->cfi, LT_KERNELARGS, NULL, NULL);	*/
3162		if (entry->multiboot && cfg->cfi->mbConcatArgs) {
3163		/* this is a multiboot entry, make sure there's
3164		* -- on the args line
3165		*/
3166		for (i = firstElement; i < line->numElements; i++) {
3167		if (!strcmp(line->elements[i].item, "--"))
3168		break;
3169		}
3170		if (i == line->numElements) {
3171		/* assume all existing args are kernel args,
3172		* prepend -- to make it official
3173		*/
3174		insertElement(line, "--", firstElement, cfg->cfi);
3175		i = firstElement;
3176		}
3177		if (!multibootArgs) {
3178		/* kernel args start after the -- */
3179		firstElement = i + 1;
3180		}
3181		} else if (cfg->cfi->mbConcatArgs) {
3182		/* this is a non-multiboot entry, remove hyper args */
3183		for (i = firstElement; i < line->numElements; i++) {
3184		if (!strcmp(line->elements[i].item, "--"))
3185		break;
3186		}
3187		if (i < line->numElements) {
3188		/* remove args up to -- */
3189		while (strcmp(line->elements[firstElement].item, "--"))
3190		removeElement(line, firstElement);
3191		/* remove -- */
3192		removeElement(line, firstElement);
3193		}
3194	}	}
3195
3196	usedElements = calloc(line->numElements, sizeof(int));	usedElements = calloc(line->numElements, sizeof(*usedElements));
3197
3198	k = 0;	for (k = 0, arg = newArgs; *arg; arg++, k++) {
3199	for (arg = newArgs; *arg; arg++) {
3200	if (usedArgs[k]) {	doreplace = 1;
	k++;
	continue;
	}
3201	for (i = firstElement; i < line->numElements; i++) {	for (i = firstElement; i < line->numElements; i++) {
3202		if (multibootArgs && cfg->cfi->mbConcatArgs &&
3203		!strcmp(line->elements[i].item, "--"))
3204		{
3205		/* reached the end of hyper args, insert here */
3206		doreplace = 0;
3207		break;
3208		}
3209	if (usedElements[i])	if (usedElements[i])
3210	continue;	continue;
3211	if (!argMatch(line->elements[i].item, *arg)) {	if (!argMatch(line->elements[i].item, *arg)) {
3212	usedElements[i]=1;	usedElements[i]=1;
	usedArgs[k]=1;
3213	break;	break;
3214	}	}
3215	}	}
	chptr = strchr(*arg, '=');
3216
3217	if (i < line->numElements) {	if (i < line->numElements && doreplace) {
3218	/* replace */	/* direct replacement */
3219	free(line->elements[i].item);	free(line->elements[i].item);
3220	line->elements[i].item = strdup(*arg);	line->elements[i].item = strdup(*arg);
	} else if (useRoot && !strncmp(*arg, "root=/dev/", 10) && *chptr) {
	rootLine = entry->lines;
	while (rootLine && rootLine->type != LT_ROOT)
	rootLine = rootLine->next;
	if (!rootLine) {
	rootLine = addLine(entry, cfg->cfi, LT_ROOT, NULL, NULL);
	rootLine->elements = realloc(rootLine->elements,
	2 * sizeof(*rootLine->elements));
	rootLine->numElements++;
	rootLine->elements[1].indent = strdup("");
	rootLine->elements[1].item = strdup("");
	}
3221
3222	free(rootLine->elements[1].item);	} else if (useRoot && !strncmp(*arg, "root=/dev/", 10)) {
3223	rootLine->elements[1].item = strdup(chptr + 1);	/* root= replacement */
3224	} else {	rootLine = getLineByType(LT_ROOT, entry->lines);
3225	/* append */	if (rootLine) {
3226	line->elements = realloc(line->elements,	free(rootLine->elements[1].item);
3227	(line->numElements + 1) * sizeof(*line->elements));	rootLine->elements[1].item = strdup(*arg + 5);
	line->elements[line->numElements].item = strdup(*arg);
	usedElements = realloc(usedElements,
	(line->numElements + 1) * sizeof(int));
	usedElements[line->numElements] = 1;
	if (line->numElements > 1) {
	/* add to existing list of arguments */
	line->elements[line->numElements].indent =
	line->elements[line->numElements - 1].indent;
	line->elements[line->numElements - 1].indent = strdup(" ");
3228	} else {	} else {
3229	/* First thing on this line; treat a bit differently. Note	rootLine = addLine(entry, cfg->cfi, LT_ROOT,
3230	this is only possible if we've added a LT_KERNELARGS	cfg->secondaryIndent, *arg + 5);
	entry */
	line->elements[line->numElements].indent = strdup("");
3231	}	}
3232		}
3233
3234	line->numElements++;	else {
3235		/* insert/append */
3236		insertElement(line, *arg, i, cfg->cfi);
3237		usedElements = realloc(usedElements, line->numElements *
3238		sizeof(*usedElements));
3239		memmove(&usedElements[i + 1], &usedElements[i],
3240		line->numElements - i - 1);
3241		usedElements[i] = 1;
3242
3243	/* if we updated a root= here even though there is a	/* if we updated a root= here even though there is a
3244	LT_ROOT available we need to remove the LT_ROOT entry	LT_ROOT available we need to remove the LT_ROOT entry
3245	(this will happen if we switch from a device to a label) */	(this will happen if we switch from a device to a label) */
3246	if (useRoot && !strncmp(*arg, "root=", 5)) {	if (useRoot && !strncmp(*arg, "root=", 5)) {
3247	rootLine = entry->lines;	rootLine = getLineByType(LT_ROOT, entry->lines);
3248	while (rootLine && rootLine->type != LT_ROOT)	if (rootLine)
	rootLine = rootLine->next;
	if (rootLine) {
3249	removeLine(entry, rootLine);	removeLine(entry, rootLine);
	}
3250	}	}
3251	}	}
	k++;
3252	}	}
3253
3254	free(usedElements);	free(usedElements);
3255
	/* no arguments to remove (i.e. no append line) */
	if (!line) continue;
	/* this won't remove an LT_ROOT item properly (but then again,
	who cares? */
3256	for (arg = oldArgs; *arg; arg++) {	for (arg = oldArgs; *arg; arg++) {
3257	for (i = firstElement; i < line->numElements; i++)	for (i = firstElement; i < line->numElements; i++) {
3258	if (!argMatch(line->elements[i].item, *arg))	if (multibootArgs && cfg->cfi->mbConcatArgs &&
3259		!strcmp(line->elements[i].item, "--"))
3260		/* reached the end of hyper args, stop here */
3261		break;
3262		if (!argMatch(line->elements[i].item, *arg)) {
3263		removeElement(line, i);
3264	break;	break;
	if (i < line->numElements) {
	/* if this isn't the first argument the previous argument
	gets this arguments post-indention */
	if (i > firstElement) {
	free(line->elements[i - 1].indent);
	line->elements[i - 1].indent = line->elements[i].indent;
3265	}	}
3266		}
3267	free(line->elements[i].item);	/* handle removing LT_ROOT line too */
3268		if (useRoot && !strncmp(*arg, "root=", 5)) {
3269	for (j = i + 1; j < line->numElements; j++)	rootLine = getLineByType(LT_ROOT, entry->lines);
3270	line->elements[j - 1] = line->elements[j];	if (rootLine)
3271		removeLine(entry, rootLine);
	line->numElements--;
3272	}	}
3273	}	}
3274
#	Line 1760  int updateActualImage(struct grubConfig	Line 3279  int updateActualImage(struct grubConfig
3279	}	}
3280	}	}
3281
	free(usedArgs);
3282	free(newArgs);	free(newArgs);
3283	free(oldArgs);	free(oldArgs);
3284
#	Line 1786  int updateImage(struct grubConfig * cfg,	Line 3304  int updateImage(struct grubConfig * cfg,
3304	return rc;	return rc;
3305	}	}
3306
3307		int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
3308		const char * image, const char * prefix, const char * initrd) {
3309		struct singleEntry * entry;
3310		struct singleLine * line, * kernelLine, *endLine = NULL;
3311		int index = 0;
3312
3313		if (!image) return 0;
3314
3315		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3316		kernelLine = getLineByType(LT_MBMODULE, entry->lines);
3317		if (!kernelLine) continue;
3318
3319		if (prefix) {
3320		int prefixLen = strlen(prefix);
3321		if (!strncmp(initrd, prefix, prefixLen))
3322		initrd += prefixLen;
3323		}
3324		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3325		if (endLine)
3326		removeLine(entry, endLine);
3327		line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
3328		kernelLine->indent, initrd);
3329		if (!line)
3330		return 1;
3331		if (endLine) {
3332		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3333		if (!line)
3334		return 1;
3335		}
3336
3337		break;
3338		}
3339
3340		return 0;
3341		}
3342
3343		int updateInitrd(struct grubConfig * cfg, const char * image,
3344		const char * prefix, const char * initrd) {
3345		struct singleEntry * entry;
3346		struct singleLine * line, * kernelLine, *endLine = NULL;
3347		int index = 0;
3348
3349		if (!image) return 0;
3350
3351		for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
3352		kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
3353		if (!kernelLine) continue;
3354
3355		line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
3356		if (line)
3357		removeLine(entry, line);
3358		if (prefix) {
3359		int prefixLen = strlen(prefix);
3360		if (!strncmp(initrd, prefix, prefixLen))
3361		initrd += prefixLen;
3362		}
3363		endLine = getLineByType(LT_ENTRY_END, entry->lines);
3364		if (endLine)
3365		removeLine(entry, endLine);
3366		enum lineType_e lt;
3367		switch(kernelLine->type) {
3368		case LT_KERNEL:
3369		lt = LT_INITRD;
3370		break;
3371		case LT_KERNEL_EFI:
3372		lt = LT_INITRD_EFI;
3373		break;
3374		case LT_KERNEL_16:
3375		lt = LT_INITRD_16;
3376		break;
3377		default:
3378		lt = preferredLineType(LT_INITRD, cfg->cfi);
3379		}
3380		line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
3381		if (!line)
3382		return 1;
3383		if (endLine) {
3384		line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
3385		if (!line)
3386		return 1;
3387		}
3388
3389		break;
3390		}
3391
3392		return 0;
3393		}
3394
3395	int checkDeviceBootloader(const char * device, const unsigned char * boot) {	int checkDeviceBootloader(const char * device, const unsigned char * boot) {
3396	int fd;	int fd;
3397	unsigned char bootSect[512];	unsigned char bootSect[512];
#	Line 1809  int checkDeviceBootloader(const char * d	Line 3415  int checkDeviceBootloader(const char * d
3415	if (memcmp(boot, bootSect, 3))	if (memcmp(boot, bootSect, 3))
3416	return 0;	return 0;
3417
3418	if (boot[1] == 0xeb) {	if (boot[1] == JMP_SHORT_OPCODE) {
3419	offset = boot[2] + 2;	offset = boot[2] + 2;
3420	} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {	} else if (boot[1] == 0xe8 || boot[1] == 0xe9) {
3421	offset = (boot[3] << 8) + boot[2] + 2;	offset = (boot[3] << 8) + boot[2] + 2;
3422	} else if (boot[0] == 0xeb) {	} else if (boot[0] == JMP_SHORT_OPCODE) {
3423	offset = boot[1] + 2;	offset = boot[1] + 2;
3424		/*
3425		* it looks like grub, when copying stage1 into the mbr, patches stage1
3426		* right after the JMP location, replacing other instructions such as
3427		* JMPs for NOOPs. So, relax the check a little bit by skipping those
3428		* different bytes.
3429		*/
3430		if ((bootSect[offset + 1] == NOOP_OPCODE)
3431		&& (bootSect[offset + 2] == NOOP_OPCODE)) {
3432		offset = offset + 3;
3433		}
3434	} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {	} else if (boot[0] == 0xe8 || boot[0] == 0xe9) {
3435	offset = (boot[2] << 8) + boot[1] + 2;	offset = (boot[2] << 8) + boot[1] + 2;
3436	} else {	} else {
#	Line 1956  int checkForLilo(struct grubConfig * con	Line 3572  int checkForLilo(struct grubConfig * con
3572	return checkDeviceBootloader(line->elements[1].item, boot);	return checkDeviceBootloader(line->elements[1].item, boot);
3573	}	}
3574
3575		int checkForGrub2(struct grubConfig * config) {
3576		if (!access("/etc/grub.d/", R_OK))
3577		return 2;
3578
3579		return 1;
3580		}
3581
3582	int checkForGrub(struct grubConfig * config) {	int checkForGrub(struct grubConfig * config) {
3583	int fd;	int fd;
3584	unsigned char bootSect[512];	unsigned char bootSect[512];
3585	char * boot;	char * boot;
3586		int onSuse = isSuseSystem();
3587
3588	if (parseSysconfigGrub(NULL, &boot))
3589	return 0;	if (onSuse) {
3590		if (parseSuseGrubConf(NULL, &boot))
3591		return 0;
3592		} else {
3593		if (parseSysconfigGrub(NULL, &boot))
3594		return 0;
3595		}
3596
3597	/* assume grub is not installed -- not an error condition */	/* assume grub is not installed -- not an error condition */
3598	if (!boot)	if (!boot)
#	Line 1976  int checkForGrub(struct grubConfig * con	Line 3606  int checkForGrub(struct grubConfig * con
3606	if (read(fd, bootSect, 512) != 512) {	if (read(fd, bootSect, 512) != 512) {
3607	fprintf(stderr, _("grubby: unable to read %s: %s\n"),	fprintf(stderr, _("grubby: unable to read %s: %s\n"),
3608	"/boot/grub/stage1", strerror(errno));	"/boot/grub/stage1", strerror(errno));
3609		close(fd);
3610		return 1;
3611		}
3612		close(fd);
3613
3614		/* The more elaborate checks do not work on SuSE. The checks done
3615		* seem to be reasonble (at least for now), so just return success
3616		*/
3617		if (onSuse)
3618		return 2;
3619
3620		return checkDeviceBootloader(boot, bootSect);
3621		}
3622
3623		int checkForExtLinux(struct grubConfig * config) {
3624		int fd;
3625		unsigned char bootSect[512];
3626		char * boot;
3627		char executable[] = "/boot/extlinux/extlinux";
3628
3629		printf("entered: checkForExtLinux()\n");
3630
3631		if (parseSysconfigGrub(NULL, &boot))
3632		return 0;
3633
3634		/* assume grub is not installed -- not an error condition */
3635		if (!boot)
3636		return 0;
3637
3638		fd = open(executable, O_RDONLY);
3639		if (fd < 0)
3640		/* this doesn't exist if grub hasn't been installed */
3641		return 0;
3642
3643		if (read(fd, bootSect, 512) != 512) {
3644		fprintf(stderr, _("grubby: unable to read %s: %s\n"),
3645		executable, strerror(errno));
3646	return 1;	return 1;
3647	}	}
3648	close(fd);	close(fd);
#	Line 1983  int checkForGrub(struct grubConfig * con	Line 3650  int checkForGrub(struct grubConfig * con
3650	return checkDeviceBootloader(boot, bootSect);	return checkDeviceBootloader(boot, bootSect);
3651	}	}
3652
3653		int checkForYaboot(struct grubConfig * config) {
3654		/*
3655		* This is a simplistic check that we consider good enough for own puporses
3656		*
3657		* If we were to properly check if yaboot is *installed* we'd need to:
3658		* 1) get the system boot device (LT_BOOT)
3659		* 2) considering it's a raw filesystem, check if the yaboot binary matches
3660		*    the content on the boot device
3661		* 3) if not, copy the binary to a temporary file and run "addnote" on it
3662		* 4) check again if binary and boot device contents match
3663		*/
3664		if (!access("/etc/yaboot.conf", R_OK))
3665		return 2;
3666
3667		return 1;
3668		}
3669
3670		int checkForElilo(struct grubConfig * config) {
3671		if (!access("/etc/elilo.conf", R_OK))
3672		return 2;
3673
3674		return 1;
3675		}
3676
3677	static char * getRootSpecifier(char * str) {	static char * getRootSpecifier(char * str) {
3678	char * idx, * rootspec = NULL;	char * idx, * rootspec = NULL;
3679
#	Line 1994  static char * getRootSpecifier(char * st	Line 3685  static char * getRootSpecifier(char * st
3685	return rootspec;	return rootspec;
3686	}	}
3687
3688		static char * getInitrdVal(struct grubConfig * config,
3689		const char * prefix, struct singleLine *tmplLine,
3690		const char * newKernelInitrd,
3691		const char ** extraInitrds, int extraInitrdCount)
3692		{
3693		char *initrdVal, *end;
3694		int i;
3695		size_t totalSize;
3696		size_t prefixLen;
3697		char separatorChar;
3698
3699		prefixLen = strlen(prefix);
3700		totalSize = strlen(newKernelInitrd) - prefixLen + 1 /* \0 */;
3701
3702		for (i = 0; i < extraInitrdCount; i++) {
3703		totalSize += sizeof(separatorChar);
3704		totalSize += strlen(extraInitrds[i]) - prefixLen;
3705		}
3706
3707		initrdVal = end = malloc(totalSize);
3708
3709		end = stpcpy (end, newKernelInitrd + prefixLen);
3710
3711		separatorChar = getKeywordByType(LT_INITRD, config->cfi)->separatorChar;
3712		for (i = 0; i < extraInitrdCount; i++) {
3713		const char *extraInitrd;
3714		int j;
3715
3716		extraInitrd = extraInitrds[i] + prefixLen;
3717		/* Don't add entries that are already there */
3718		if (tmplLine != NULL) {
3719		for (j = 2; j < tmplLine->numElements; j++)
3720		if (strcmp(extraInitrd, tmplLine->elements[j].item) == 0)
3721		break;
3722
3723		if (j != tmplLine->numElements)
3724		continue;
3725		}
3726
3727		*end++ = separatorChar;
3728		end = stpcpy(end, extraInitrd);
3729		}
3730
3731		return initrdVal;
3732		}
3733
3734	int addNewKernel(struct grubConfig * config, struct singleEntry * template,	int addNewKernel(struct grubConfig * config, struct singleEntry * template,
3735	const char * prefix,	const char * prefix,
3736	char * newKernelPath, char * newKernelTitle,	const char * newKernelPath, const char * newKernelTitle,
3737	char * newKernelArgs, char * newKernelInitrd,	const char * newKernelArgs, const char * newKernelInitrd,
3738	char * newMBKernel, char * newMBKernelArgs) {	const char ** extraInitrds, int extraInitrdCount,
3739		const char * newMBKernel, const char * newMBKernelArgs,
3740		const char * newDevTreePath) {
3741	struct singleEntry * new;	struct singleEntry * new;
3742	struct singleLine * newLine = NULL, * tmplLine = NULL, * lastLine = NULL;	struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
3743	int needs;	int needs;
	char * indent = NULL;
	char * rootspec = NULL;
3744	char * chptr;	char * chptr;
	int i;
	enum lineType_e type;
3745
3746	if (!newKernelPath) return 0;	if (!newKernelPath) return 0;
3747
#	Line 2036  int addNewKernel(struct grubConfig * con	Line 3771  int addNewKernel(struct grubConfig * con
3771	config->entries = new;	config->entries = new;
3772
3773	/* copy/update from the template */	/* copy/update from the template */
3774	needs = KERNEL_KERNEL | KERNEL_INITRD | KERNEL_TITLE;	needs = NEED_KERNEL | NEED_TITLE;
3775		if (newKernelInitrd)
3776		needs |= NEED_INITRD;
3777	if (newMBKernel) {	if (newMBKernel) {
3778	needs |= KERNEL_MB;	needs |= NEED_MB;
3779	new->multiboot = 1;	new->multiboot = 1;
3780	}	}
3781		if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
3782		needs |= NEED_DEVTREE;
3783
3784	if (template) {	if (template) {
3785	for (tmplLine = template->lines; tmplLine; tmplLine = tmplLine->next) {	for (masterLine = template->lines;
3786	/* remember the indention level; we may need it for new lines */	masterLine && (tmplLine = lineDup(masterLine));
3787	if (tmplLine->numElements)	lineFree(tmplLine), masterLine = masterLine->next)
3788	indent = tmplLine->indent;	{
3789		dbgPrintf("addNewKernel processing %d\n", tmplLine->type);
3790
3791	/* skip comments */	/* skip comments */
3792	chptr = tmplLine->indent;	chptr = tmplLine->indent;
3793	while (*chptr && isspace(*chptr)) chptr++;	while (*chptr && isspace(*chptr)) chptr++;
3794	if (*chptr == '#') continue;	if (*chptr == '#') continue;
3795
3796	/* we don't need an initrd here */	if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
3797	if (tmplLine->type == LT_INITRD && !newKernelInitrd) continue;	if (!template->multiboot && (needs & NEED_MB)) {
3798		/* it's not a multiboot template and this is the kernel
3799	if (tmplLine->type == LT_KERNEL &&	* line.  Try to be intelligent about inserting the
3800	!template->multiboot && (needs & KERNEL_MB)) {	* hypervisor at the same time.
3801	struct singleLine *l;	*/
3802	needs &= ~ KERNEL_MB;	if (config->cfi->mbHyperFirst) {
3803		/* insert the hypervisor first */
3804	l = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi, LT_HYPER,
3805	config->secondaryIndent,	tmplLine->indent,
3806	newMBKernel + strlen(prefix));	newMBKernel + strlen(prefix));
3807		/* set up for adding the kernel line */
3808	tmplLine = lastLine;	free(tmplLine->indent);
3809	if (!new->lines) {	tmplLine->indent = strdup(config->secondaryIndent);
3810	new->lines = l;	needs &= ~NEED_MB;
3811	} else {	}
3812	newLine->next = l;	if (needs & NEED_KERNEL) {
3813	newLine = l;	/* use addLineTmpl to preserve line elements,
3814	}	* otherwise we could just call addLine.  Unfortunately
3815	continue;	* this means making some changes to the template
3816	} else if (tmplLine->type == LT_KERNEL &&	* such as the indent change above and the type
3817	template->multiboot && !new->multiboot) {	* change below.
3818	continue; /* don't need multiboot kernel here */	*/
3819	}	struct keywordTypes * mbm_kw =
3820		getKeywordByType(LT_MBMODULE, config->cfi);
3821	if (!new->lines) {	if (mbm_kw) {
3822	newLine = malloc(sizeof(*newLine));	tmplLine->type = LT_MBMODULE;
3823	new->lines = newLine;	free(tmplLine->elements[0].item);
3824	} else {	tmplLine->elements[0].item = strdup(mbm_kw->key);
3825	newLine->next = malloc(sizeof(*newLine));	}
3826	newLine = newLine->next;	newLine = addLineTmpl(new, tmplLine, newLine,
3827	}	newKernelPath + strlen(prefix), config->cfi);
3828		needs &= ~NEED_KERNEL;
3829		}
3830		if (needs & NEED_MB) { /* !mbHyperFirst */
3831		newLine = addLine(new, config->cfi, LT_HYPER,
3832		config->secondaryIndent,
3833		newMBKernel + strlen(prefix));
3834		needs &= ~NEED_MB;
3835		}
3836		} else if (needs & NEED_KERNEL) {
3837		newLine = addLineTmpl(new, tmplLine, newLine,
3838		newKernelPath + strlen(prefix), config->cfi);
3839		needs &= ~NEED_KERNEL;
3840		}
3841
3842		} else if (tmplLine->type == LT_HYPER &&
3843		tmplLine->numElements >= 2) {
3844		if (needs & NEED_MB) {
3845		newLine = addLineTmpl(new, tmplLine, newLine,
3846		newMBKernel + strlen(prefix), config->cfi);
3847		needs &= ~NEED_MB;
3848		}
3849
3850	newLine->indent = strdup(tmplLine->indent);	} else if (tmplLine->type == LT_MBMODULE &&
3851	newLine->next = NULL;	tmplLine->numElements >= 2) {
3852	newLine->type = tmplLine->type;	if (new->multiboot) {
3853	newLine->numElements = tmplLine->numElements;	if (needs & NEED_KERNEL) {
3854	newLine->elements = malloc(sizeof(*newLine->elements) *	newLine = addLineTmpl(new, tmplLine, newLine,
3855	newLine->numElements);	newKernelPath +
3856	for (i = 0; i < newLine->numElements; i++) {	strlen(prefix), config->cfi);
3857	newLine->elements[i].item = strdup(tmplLine->elements[i].item);	needs &= ~NEED_KERNEL;
3858	newLine->elements[i].indent =	} else if (config->cfi->mbInitRdIsModule &&
3859	strdup(tmplLine->elements[i].indent);	(needs & NEED_INITRD)) {
3860	}	char *initrdVal;
3861		initrdVal = getInitrdVal(config, prefix, tmplLine,
3862	lastLine = tmplLine;	newKernelInitrd, extraInitrds,
3863	if (tmplLine->type == LT_KERNEL && tmplLine->numElements >= 2) {	extraInitrdCount);
3864	char * repl;	newLine = addLineTmpl(new, tmplLine, newLine,
3865	if (!template->multiboot) {	initrdVal, config->cfi);
3866	needs &= ~KERNEL_KERNEL;	free(initrdVal);
3867	repl = newKernelPath;	needs &= ~NEED_INITRD;
3868	} else {	}
3869	needs &= ~KERNEL_MB;	} else if (needs & NEED_KERNEL) {
3870	repl = newMBKernel;	/* template is multi but new is not,
3871	}	* insert the kernel in the first module slot
3872	if (new->multiboot && !template->multiboot) {	*/
3873	free(newLine->elements[0].item);	tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
3874	newLine->elements[0].item = strdup("module");	free(tmplLine->elements[0].item);
3875	newLine->type = LT_MBMODULE;	tmplLine->elements[0].item =
3876	}	strdup(getKeywordByType(tmplLine->type,
3877	free(newLine->elements[1].item);	config->cfi)->key);
3878	rootspec = getRootSpecifier(tmplLine->elements[1].item);	newLine = addLineTmpl(new, tmplLine, newLine,
3879	if (rootspec != NULL) {	newKernelPath + strlen(prefix),
3880	newLine->elements[1].item = sdupprintf("%s%s",	config->cfi);
3881	rootspec,	needs &= ~NEED_KERNEL;
3882	repl +	} else if (needs & NEED_INITRD) {
3883	strlen(prefix));	char *initrdVal;
3884	} else {	/* template is multi but new is not,
3885	newLine->elements[1].item = strdup(repl +	* insert the initrd in the second module slot
3886	strlen(prefix));	*/
3887	}	tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
3888	} else if (tmplLine->type == LT_MBMODULE &&	free(tmplLine->elements[0].item);
3889	tmplLine->numElements >= 2 && (needs & KERNEL_KERNEL)) {	tmplLine->elements[0].item =
3890	needs &= ~KERNEL_KERNEL;	strdup(getKeywordByType(tmplLine->type,
3891	if (!new->multiboot && template->multiboot) {	config->cfi)->key);
3892	free(newLine->elements[0].item);	initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3893	newLine->elements[0].item = strdup("kernel");	newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3894	newLine->type = LT_KERNEL;	free(initrdVal);
3895	}	needs &= ~NEED_INITRD;
3896	free(newLine->elements[1].item);	}
	rootspec = getRootSpecifier(tmplLine->elements[1].item);
	if (rootspec != NULL) {
	newLine->elements[1].item = sdupprintf("%s%s",
	rootspec,
	newKernelPath +
	strlen(prefix));
	} else {
	newLine->elements[1].item = strdup(newKernelPath +
	strlen(prefix));
	}
	} else if (tmplLine->type == LT_INITRD &&
	tmplLine->numElements >= 2) {
	needs &= ~KERNEL_INITRD;
	free(newLine->elements[1].item);
	if (new->multiboot && !template->multiboot) {
	free(newLine->elements[0].item);
	newLine->elements[0].item = strdup("module");
	newLine->type = LT_MBMODULE;
	}
	rootspec = getRootSpecifier(tmplLine->elements[1].item);
	if (rootspec != NULL) {
	newLine->elements[1].item = sdupprintf("%s%s",
	rootspec,
	newKernelInitrd +
	strlen(prefix));
	} else {
	newLine->elements[1].item = strdup(newKernelInitrd +
	strlen(prefix));
	}
	} else if (tmplLine->type == LT_MBMODULE &&
	tmplLine->numElements >= 2 && (needs & KERNEL_INITRD)) {
	needs &= ~KERNEL_INITRD;
	if (!new->multiboot && template->multiboot) {
	free(newLine->elements[0].item);
	newLine->elements[0].item = strdup("initrd");
	newLine->type = LT_INITRD;
	}
	free(newLine->elements[1].item);
	rootspec = getRootSpecifier(tmplLine->elements[1].item);
	if (rootspec != NULL) {
	newLine->elements[1].item = sdupprintf("%s%s",
	rootspec,
	newKernelInitrd +
	strlen(prefix));
	} else {
	newLine->elements[1].item = strdup(newKernelInitrd +
	strlen(prefix));
	}
	} else if (tmplLine->type == LT_TITLE &&
	tmplLine->numElements >= 2) {
	needs &= ~KERNEL_TITLE;
3897
3898	for (i = 1; i < newLine->numElements; i++) {	} else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
3899	free(newLine->elements[i].item);	if (needs & NEED_INITRD &&
3900	free(newLine->elements[i].indent);	new->multiboot && !template->multiboot &&
3901		config->cfi->mbInitRdIsModule) {
3902		/* make sure we don't insert the module initrd
3903		* before the module kernel... if we don't do it here,
3904		* it will be inserted following the template.
3905		*/
3906		if (!needs & NEED_KERNEL) {
3907		char *initrdVal;
3908
3909		initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3910		newLine = addLine(new, config->cfi, LT_MBMODULE,
3911		config->secondaryIndent,
3912		initrdVal);
3913		free(initrdVal);
3914		needs &= ~NEED_INITRD;
3915		}
3916		} else if (needs & NEED_INITRD) {
3917		char *initrdVal;
3918		initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
3919		newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
3920		free(initrdVal);
3921		needs &= ~NEED_INITRD;
3922	}	}
3923
3924	newLine->elements[1].item = strdup(newKernelTitle);	} else if (tmplLine->type == LT_MENUENTRY &&
3925	newLine->elements[1].indent = strdup("");	(needs & NEED_TITLE)) {
3926	newLine->numElements = 2;	requote(tmplLine, config->cfi);
3927		char *nkt = malloc(strlen(newKernelTitle)+3);
3928		strcpy(nkt, "'");
3929		strcat(nkt, newKernelTitle);
3930		strcat(nkt, "'");
3931		newLine = addLineTmpl(new, tmplLine, newLine, nkt, config->cfi);
3932		free(nkt);
3933		needs &= ~NEED_TITLE;
3934	} else if (tmplLine->type == LT_TITLE &&	} else if (tmplLine->type == LT_TITLE &&
3935	config->cfi->titleBracketed &&	(needs & NEED_TITLE)) {
3936	tmplLine->numElements == 1) {	if (tmplLine->numElements >= 2) {
3937	needs &= ~KERNEL_TITLE;	newLine = addLineTmpl(new, tmplLine, newLine,
3938	free(newLine->elements[0].item);	newKernelTitle, config->cfi);
3939	free(newLine->elements[0].indent);	needs &= ~NEED_TITLE;
3940	newLine->elements = malloc(sizeof(*newLine->elements) *	} else if (tmplLine->numElements == 1 &&
3941	newLine->numElements);	config->cfi->titleBracketed) {
3942		/* addLineTmpl doesn't handle titleBracketed */
3943	newLine->elements[0].item = malloc(strlen(newKernelTitle) + 3);	newLine = addLine(new, config->cfi, LT_TITLE,
3944	sprintf(newLine->elements[0].item, "[%s]", newKernelTitle);	tmplLine->indent, newKernelTitle);
3945	newLine->elements[0].indent = strdup("");	needs &= ~NEED_TITLE;
3946	newLine->numElements = 1;	}
3947	}	} else if (tmplLine->type == LT_ECHO) {
3948		requote(tmplLine, config->cfi);
3949		static const char *prefix = "'Loading ";
3950		if (tmplLine->numElements > 1 &&
3951		strstr(tmplLine->elements[1].item, prefix) &&
3952		masterLine->next &&
3953		iskernel(masterLine->next->type)) {
3954		char *newTitle = malloc(strlen(prefix) +
3955		strlen(newKernelTitle) + 2);
3956
3957		strcpy(newTitle, prefix);
3958		strcat(newTitle, newKernelTitle);
3959		strcat(newTitle, "'");
3960		newLine = addLine(new, config->cfi, LT_ECHO,
3961		tmplLine->indent, newTitle);
3962		free(newTitle);
3963		} else {
3964		/* pass through other lines from the template */
3965		newLine = addLineTmpl(new, tmplLine, newLine, NULL,
3966		config->cfi);
3967		}
3968		} else if (tmplLine->type == LT_DEVTREE &&
3969		tmplLine->numElements == 2 && newDevTreePath) {
3970		newLine = addLineTmpl(new, tmplLine, newLine,
3971		newDevTreePath + strlen(prefix),
3972		config->cfi);
3973		needs &= ~NEED_DEVTREE;
3974		} else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
3975		const char *ndtp = newDevTreePath;
3976		if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
3977		ndtp += strlen(prefix);
3978		newLine = addLine(new, config->cfi, LT_DEVTREE,
3979		config->secondaryIndent,
3980		ndtp);
3981		needs &= ~NEED_DEVTREE;
3982		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
3983		} else {
3984		/* pass through other lines from the template */
3985		newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
3986		}
3987	}	}
3988
3989	} else {	} else {
3990	for (i = 0; config->cfi->keywords[i].key; i++) {	/* don't have a template, so start the entry with the
3991	if ((config->cfi->keywords[i].type == config->cfi->entrySeparator) || (config->cfi->keywords[i].type == LT_OTHER))	* appropriate starting line
3992		*/
3993		switch (config->cfi->entryStart) {
3994		case LT_KERNEL:
3995		case LT_KERNEL_EFI:
3996		case LT_KERNEL_16:
3997		if (new->multiboot && config->cfi->mbHyperFirst) {
3998		/* fall through to LT_HYPER */
3999		} else {
4000		newLine = addLine(new, config->cfi,
4001		preferredLineType(LT_KERNEL, config->cfi),
4002		config->primaryIndent,
4003		newKernelPath + strlen(prefix));
4004		needs &= ~NEED_KERNEL;
4005		break;
4006		}
4007
4008		case LT_HYPER:
4009		newLine = addLine(new, config->cfi, LT_HYPER,
4010		config->primaryIndent,
4011		newMBKernel + strlen(prefix));
4012		needs &= ~NEED_MB;
4013	break;	break;
	}
4014
4015	switch (config->cfi->keywords[i].type) {	case LT_MENUENTRY: {
4016	case LT_KERNEL:  needs &= ~KERNEL_KERNEL,	char *nkt = malloc(strlen(newKernelTitle)+3);
4017	chptr = newKernelPath + strlen(prefix);	strcpy(nkt, "'");
4018	type = LT_KERNEL; break;	strcat(nkt, newKernelTitle);
4019	case LT_TITLE:   needs &= ~KERNEL_TITLE, chptr = newKernelTitle;	strcat(nkt, "'");
4020	type = LT_TITLE; break;	newLine = addLine(new, config->cfi, LT_MENUENTRY,
4021	default:	config->primaryIndent, nkt);
4022	/* zipl strikes again */	free(nkt);
4023	if (config->cfi->titleBracketed) {	needs &= ~NEED_TITLE;
4024	needs &= ~KERNEL_TITLE;	needs |= NEED_END;
4025	chptr = newKernelTitle;	break;
4026	type = LT_TITLE;	}
4027	break;	case LT_TITLE:
4028	} else {	if( useextlinuxmenu != 0 ){ // We just need useextlinuxmenu to not be zero (set above)
4029	abort();	char * templabel;
4030	}	int x = 0, y = 0;
4031	}
4032		templabel = strdup(newKernelTitle);
4033		while( templabel[x]){
4034		if( templabel[x] == ' ' ){
4035		y = x;
4036		while( templabel[y] ){
4037		templabel[y] = templabel[y+1];
4038		y++;
4039		}
4040		}
4041		x++;
4042		}
4043		newLine = addLine(new, config->cfi, LT_TITLE,
4044		config->primaryIndent, templabel);
4045		free(templabel);
4046		}else{
4047		newLine = addLine(new, config->cfi, LT_TITLE,
4048		config->primaryIndent, newKernelTitle);
4049		}
4050		needs &= ~NEED_TITLE;
4051		break;
4052
4053	newLine = addLine(new, config->cfi, type, config->primaryIndent, chptr);	default:
4054	new->lines = newLine;	abort();
4055		}
4056	}	}
4057
4058	if (new->multiboot) {	struct singleLine *endLine = NULL;
4059	if (needs & KERNEL_MB)	endLine = getLineByType(LT_ENTRY_END, new->lines);
4060	newLine = addLine(new, config->cfi, LT_KERNEL,	if (endLine) {
4061	config->secondaryIndent,	removeLine(new, endLine);
4062	newMBKernel + strlen(prefix));	needs |= NEED_END;
4063	if (needs & KERNEL_KERNEL)	}
4064	newLine = addLine(new, config->cfi, LT_MBMODULE,
4065	config->secondaryIndent,	/* add the remainder of the lines, i.e. those that either
4066	newKernelPath + strlen(prefix));	* weren't present in the template, or in the case of no template,
4067	/* don't need to check for title as it's guaranteed to have been	* all the lines following the entryStart.
4068	* done as we only do multiboot with grub which uses title as	*/
4069	* a separator */	if (needs & NEED_TITLE) {
4070	if (needs & KERNEL_INITRD && newKernelInitrd)	newLine = addLine(new, config->cfi, LT_TITLE,
4071	newLine = addLine(new, config->cfi, LT_MBMODULE,	config->secondaryIndent,
4072	config->secondaryIndent,	newKernelTitle);
4073	newKernelInitrd + strlen(prefix));	needs &= ~NEED_TITLE;
4074	} else {	}
4075	if (needs & KERNEL_KERNEL)	if ((needs & NEED_MB) && config->cfi->mbHyperFirst) {
4076	newLine = addLine(new, config->cfi, LT_KERNEL,	newLine = addLine(new, config->cfi, LT_HYPER,
4077	config->secondaryIndent,	config->secondaryIndent,
4078	newKernelPath + strlen(prefix));	newMBKernel + strlen(prefix));
4079	if (needs & KERNEL_TITLE)	needs &= ~NEED_MB;
4080	newLine = addLine(new, config->cfi, LT_TITLE,	}
4081	config->secondaryIndent,	if (needs & NEED_KERNEL) {
4082	newKernelTitle);	newLine = addLine(new, config->cfi,
4083	if (needs & KERNEL_INITRD && newKernelInitrd)	(new->multiboot && getKeywordByType(LT_MBMODULE,
4084	newLine = addLine(new, config->cfi, LT_INITRD,	config->cfi))
4085	config->secondaryIndent,	? LT_MBMODULE
4086	newKernelInitrd + strlen(prefix));	: preferredLineType(LT_KERNEL, config->cfi),
4087		config->secondaryIndent,
4088		newKernelPath + strlen(prefix));
4089		needs &= ~NEED_KERNEL;
4090		}
4091		if (needs & NEED_MB) {
4092		newLine = addLine(new, config->cfi, LT_HYPER,
4093		config->secondaryIndent,
4094		newMBKernel + strlen(prefix));
4095		needs &= ~NEED_MB;
4096		}
4097		if (needs & NEED_INITRD) {
4098		char *initrdVal;
4099		initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
4100		newLine = addLine(new, config->cfi,
4101		(new->multiboot && getKeywordByType(LT_MBMODULE,
4102		config->cfi))
4103		? LT_MBMODULE
4104		: preferredLineType(LT_INITRD, config->cfi),
4105		config->secondaryIndent,
4106		initrdVal);
4107		free(initrdVal);
4108		needs &= ~NEED_INITRD;
4109		}
4110		if (needs & NEED_DEVTREE) {
4111		newLine = addLine(new, config->cfi, LT_DEVTREE,
4112		config->secondaryIndent,
4113		newDevTreePath);
4114		needs &= ~NEED_DEVTREE;
4115		}
4116
4117		/* NEEDS_END must be last on bootloaders that need it... */
4118		if (needs & NEED_END) {
4119		newLine = addLine(new, config->cfi, LT_ENTRY_END,
4120		config->secondaryIndent, NULL);
4121		needs &= ~NEED_END;
4122		}
4123
4124		if (needs) {
4125		printf(_("grubby: needs=%d, aborting\n"), needs);
4126		abort();
4127	}	}
4128
4129	if (updateImage(config, "0", prefix, newKernelArgs, NULL,	if (updateImage(config, "0", prefix, newKernelArgs, NULL,
#	Line 2274  int addNewKernel(struct grubConfig * con	Line 4132  int addNewKernel(struct grubConfig * con
4132	return 0;	return 0;
4133	}	}
4134
4135		static void traceback(int signum)
4136		{
4137		void *array[40];
4138		size_t size;
4139
4140		signal(SIGSEGV, SIG_DFL);
4141		memset(array, '\0', sizeof (array));
4142		size = backtrace(array, 40);
4143
4144		fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
4145		(unsigned long)size);
4146		backtrace_symbols_fd(array, size, STDERR_FILENO);
4147		exit(1);
4148		}
4149
4150	int main(int argc, const char ** argv) {	int main(int argc, const char ** argv) {
4151	poptContext optCon;	poptContext optCon;
4152	char * grubConfig = NULL;	const char * grubConfig = NULL;
4153	char * outputFile = NULL;	char * outputFile = NULL;
4154	int arg = 0;	int arg = 0;
4155	int flags = 0;	int flags = 0;
4156	int badImageOkay = 0;	int badImageOkay = 0;
4157		int configureGrub2 = 0;
4158	int configureLilo = 0, configureELilo = 0, configureGrub = 0;	int configureLilo = 0, configureELilo = 0, configureGrub = 0;
4159	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;	int configureYaboot = 0, configureSilo = 0, configureZipl = 0;
4160		int configureExtLinux = 0;
4161	int bootloaderProbe = 0;	int bootloaderProbe = 0;
4162		int extraInitrdCount = 0;
4163	char * updateKernelPath = NULL;	char * updateKernelPath = NULL;
4164	char * newKernelPath = NULL;	char * newKernelPath = NULL;
4165	char * removeKernelPath = NULL;	char * removeKernelPath = NULL;
4166	char * newKernelArgs = NULL;	char * newKernelArgs = NULL;
4167	char * newKernelInitrd = NULL;	char * newKernelInitrd = NULL;
4168	char * newKernelTitle = NULL;	char * newKernelTitle = NULL;
4169	char * newKernelVersion = NULL;	char * newDevTreePath = NULL;
4170	char * newMBKernel = NULL;	char * newMBKernel = NULL;
4171	char * newMBKernelArgs = NULL;	char * newMBKernelArgs = NULL;
4172	char * removeMBKernelArgs = NULL;	char * removeMBKernelArgs = NULL;
#	Line 2299  int main(int argc, const char ** argv) {	Line 4175  int main(int argc, const char ** argv) {
4175	char * defaultKernel = NULL;	char * defaultKernel = NULL;
4176	char * removeArgs = NULL;	char * removeArgs = NULL;
4177	char * kernelInfo = NULL;	char * kernelInfo = NULL;
4178		char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
4179		char * envPath = NULL;
4180	const char * chptr = NULL;	const char * chptr = NULL;
4181	struct configFileInfo * cfi = NULL;	struct configFileInfo * cfi = NULL;
4182	struct grubConfig * config;	struct grubConfig * config;
4183	struct singleEntry * template = NULL;	struct singleEntry * template = NULL;
4184	int copyDefault = 0, makeDefault = 0;	int copyDefault = 0, makeDefault = 0;
4185	int displayDefault = 0;	int displayDefault = 0;
4186		int displayDefaultIndex = 0;
4187		int displayDefaultTitle = 0;
4188		int defaultIndex = -1;
4189	struct poptOption options[] = {	struct poptOption options[] = {
4190	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
4191	_("add an entry for the specified kernel"), _("kernel-path") },	_("add an entry for the specified kernel"), _("kernel-path") },
#	Line 2322  int main(int argc, const char ** argv) {	Line 4203  int main(int argc, const char ** argv) {
4203	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
4204	_("filestystem which contains /boot directory (for testing only)"),	_("filestystem which contains /boot directory (for testing only)"),
4205	_("bootfs") },	_("bootfs") },
4206	#if defined(__i386__) || defined(__x86_64__)	#if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
4207	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
4208	_("check if lilo is installed on lilo.conf boot sector") },	_("check which bootloader is installed on boot sector") },
4209	#endif	#endif
4210	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
4211	_("path to grub config file to update (\"-\" for stdin)"),	_("path to grub config file to update (\"-\" for stdin)"),
#	Line 2335  int main(int argc, const char ** argv) {	Line 4216  int main(int argc, const char ** argv) {
4216	"the kernel referenced by the default image does not exist, "	"the kernel referenced by the default image does not exist, "
4217	"the first linux entry whose kernel does exist is used as the "	"the first linux entry whose kernel does exist is used as the "
4218	"template"), NULL },	"template"), NULL },
4219		{ "debug", 0, 0, &debug, 0,
4220		_("print debugging information for failures") },
4221	{ "default-kernel", 0, 0, &displayDefault, 0,	{ "default-kernel", 0, 0, &displayDefault, 0,
4222	_("display the path of the default kernel") },	_("display the path of the default kernel") },
4223		{ "default-index", 0, 0, &displayDefaultIndex, 0,
4224		_("display the index of the default kernel") },
4225		{ "default-title", 0, 0, &displayDefaultTitle, 0,
4226		_("display the title of the default kernel") },
4227		{ "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4228		_("device tree file for new stanza"), _("dtb-path") },
4229	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4230	_("configure elilo bootloader") },	_("configure elilo bootloader") },
4231		{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
4232		_("force grub2 stanzas to use efi") },
4233		{ "env", 0, POPT_ARG_STRING, &envPath, 0,
4234		_("path for environment data"),
4235		_("path") },
4236		{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
4237		_("configure extlinux bootloader (from syslinux)") },
4238	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
4239	_("configure grub bootloader") },	_("configure grub bootloader") },
4240		{ "grub2", 0, POPT_ARG_NONE, &configureGrub2, 0,
4241		_("configure grub2 bootloader") },
4242	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,	{ "info", 0, POPT_ARG_STRING, &kernelInfo, 0,
4243	_("display boot information for specified kernel"),	_("display boot information for specified kernel"),
4244	_("kernel-path") },	_("kernel-path") },
4245	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,	{ "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
4246	_("initrd image for the new kernel"), _("initrd-path") },	_("initrd image for the new kernel"), _("initrd-path") },
4247		{ "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
4248		_("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
4249	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,	{ "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
4250	_("configure lilo bootloader") },	_("configure lilo bootloader") },
4251	{ "make-default", 0, 0, &makeDefault, 0,	{ "make-default", 0, 0, &makeDefault, 0,
#	Line 2365  int main(int argc, const char ** argv) {	Line 4265  int main(int argc, const char ** argv) {
4265	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
4266	_("make the first entry referencing the specified kernel "	_("make the first entry referencing the specified kernel "
4267	"the default"), _("kernel-path") },	"the default"), _("kernel-path") },
4268		{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
4269		_("make the given entry index the default entry"),
4270		_("entry-index") },
4271	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
4272	_("configure silo bootloader") },	_("configure silo bootloader") },
4273	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
#	Line 2382  int main(int argc, const char ** argv) {	Line 4285  int main(int argc, const char ** argv) {
4285	{ 0, 0, 0, 0, 0 }	{ 0, 0, 0, 0, 0 }
4286	};	};
4287
4288		useextlinuxmenu=0;
4289
4290		signal(SIGSEGV, traceback);
4291
4292		int i = 0;
4293		for (int j = 1; j < argc; j++)
4294		i += strlen(argv[j]) + 1;
4295		saved_command_line = malloc(i);
4296		if (!saved_command_line) {
4297		fprintf(stderr, "grubby: %m\n");
4298		exit(1);
4299		}
4300		saved_command_line[0] = '\0';
4301		for (int j = 1; j < argc; j++) {
4302		strcat(saved_command_line, argv[j]);
4303		strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
4304		}
4305
4306	optCon = poptGetContext("grubby", argc, argv, options, 0);	optCon = poptGetContext("grubby", argc, argv, options, 0);
4307	poptReadDefaultConfig(optCon, 1);	poptReadDefaultConfig(optCon, 1);
4308
#	Line 2391  int main(int argc, const char ** argv) {	Line 4312  int main(int argc, const char ** argv) {
4312	printf("grubby version %s\n", VERSION);	printf("grubby version %s\n", VERSION);
4313	exit(0);	exit(0);
4314	break;	break;
4315		case 'i':
4316		if (extraInitrdCount < MAX_EXTRA_INITRDS) {
4317		extraInitrds[extraInitrdCount++] = strdup(poptGetOptArg(optCon));
4318		} else {
4319		fprintf(stderr, _("grubby: extra initrd maximum is %d\n"), extraInitrdCount);
4320		return 1;
4321		}
4322		break;
4323	}	}
4324	}	}
4325
#	Line 2406  int main(int argc, const char ** argv) {	Line 4335  int main(int argc, const char ** argv) {
4335	return 1;	return 1;
4336	}	}
4337
4338	if ((configureLilo + configureGrub + configureELilo +	if ((configureLilo + configureGrub2 + configureGrub + configureELilo +
4339	configureYaboot + configureSilo + configureZipl) > 1) {	configureYaboot + configureSilo + configureZipl +
4340		configureExtLinux ) > 1) {
4341	fprintf(stderr, _("grubby: cannot specify multiple bootloaders\n"));	fprintf(stderr, _("grubby: cannot specify multiple bootloaders\n"));
4342	return 1;	return 1;
4343	} else if (bootloaderProbe && grubConfig) {	} else if (bootloaderProbe && grubConfig) {
4344	fprintf(stderr,	fprintf(stderr,
4345	_("grubby: cannot specify config file with --bootloader-probe\n"));	_("grubby: cannot specify config file with --bootloader-probe\n"));
4346	return 1;	return 1;
4347		} else if (configureGrub2) {
4348		cfi = &grub2ConfigType;
4349		if (envPath)
4350		cfi->envFile = envPath;
4351	} else if (configureLilo) {	} else if (configureLilo) {
4352	cfi = &liloConfigType;	cfi = &liloConfigType;
4353	} else if (configureGrub) {	} else if (configureGrub) {
#	Line 2426  int main(int argc, const char ** argv) {	Line 4360  int main(int argc, const char ** argv) {
4360	cfi = &siloConfigType;	cfi = &siloConfigType;
4361	} else if (configureZipl) {	} else if (configureZipl) {
4362	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4363		} else if (configureExtLinux) {
4364		cfi = &extlinuxConfigType;
4365		useextlinuxmenu=1;
4366	}	}
4367
4368	if (!cfi) {	if (!cfi) {
4369		if (grub2FindConfig(&grub2ConfigType))
4370		cfi = &grub2ConfigType;
4371		else
4372	#ifdef __ia64__	#ifdef __ia64__
4373	cfi = &eliloConfigType;	cfi = &eliloConfigType;
4374	#elif __powerpc__	#elif __powerpc__
4375	cfi = &yabootConfigType;	cfi = &yabootConfigType;
4376	#elif __sparc__	#elif __sparc__
4377	cfi = &siloConfigType;	cfi = &siloConfigType;
4378	#elif __s390__	#elif __s390__
4379	cfi = &ziplConfigType;	cfi = &ziplConfigType;
4380	#elif __s390x__	#elif __s390x__
4381	cfi = &ziplConfigtype;	cfi = &ziplConfigtype;
4382	#else	#else
4383	cfi = &grubConfigType;	cfi = &grubConfigType;
4384	#endif	#endif
4385	}	}
4386
4387	if (!grubConfig)	if (!grubConfig) {
4388	grubConfig = cfi->defaultConfig;	if (cfi->findConfig)
4389		grubConfig = cfi->findConfig(cfi);
4390		if (!grubConfig)
4391		grubConfig = cfi->defaultConfig;
4392		}
4393
4394	if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||	if (bootloaderProbe && (displayDefault || kernelInfo ||
4395	newKernelPath || removeKernelPath || makeDefault ||	newKernelPath || removeKernelPath || makeDefault ||
4396	defaultKernel)) {	defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4397		(defaultIndex >= 0))) {
4398	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
4399	"specified option"));	"specified option"));
4400	return 1;	return 1;
4401	}	}
4402
4403	if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||	if ((displayDefault || kernelInfo) && (newKernelPath ||
4404	removeKernelPath)) {	removeKernelPath)) {
4405	fprintf(stderr, _("grubby: --default-kernel and --info may not "	fprintf(stderr, _("grubby: --default-kernel and --info may not "
4406	"be used when adding or removing kernels\n"));	"be used when adding or removing kernels\n"));
#	Line 2465  int main(int argc, const char ** argv) {	Line 4410  int main(int argc, const char ** argv) {
4410	if (newKernelPath && !newKernelTitle) {	if (newKernelPath && !newKernelTitle) {
4411	fprintf(stderr, _("grubby: kernel title must be specified\n"));	fprintf(stderr, _("grubby: kernel title must be specified\n"));
4412	return 1;	return 1;
4413	} else if (!newKernelPath && (newKernelTitle  || newKernelInitrd ||	} else if (!newKernelPath && (newKernelTitle  || copyDefault ||
4414	newKernelInitrd || copyDefault     ||	(newKernelInitrd && !updateKernelPath)||
4415	makeDefault)) {	makeDefault || extraInitrdCount > 0)) {
4416	fprintf(stderr, _("grubby: kernel path expected\n"));	fprintf(stderr, _("grubby: kernel path expected\n"));
4417	return 1;	return 1;
4418	}	}
#	Line 2491  int main(int argc, const char ** argv) {	Line 4436  int main(int argc, const char ** argv) {
4436	makeDefault = 1;	makeDefault = 1;
4437	defaultKernel = NULL;	defaultKernel = NULL;
4438	}	}
4439		else if (defaultKernel && (defaultIndex >= 0)) {
4440		fprintf(stderr, _("grubby: --set-default and --set-default-index "
4441		"may not be used together\n"));
4442		return 1;
4443		}
4444
4445	if (!strcmp(grubConfig, "-") && !outputFile) {	if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
4446	fprintf(stderr, _("grubby: output file must be specified if stdin "	fprintf(stderr, _("grubby: output file must be specified if stdin "
4447	"is used\n"));	"is used\n"));
4448	return 1;	return 1;
4449	}	}
4450
4451	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel	if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
4452	&& !kernelInfo && !bootloaderProbe && !updateKernelPath	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
4453	&& !removeMBKernel) {	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
4454		&& (defaultIndex == -1)) {
4455	fprintf(stderr, _("grubby: no action specified\n"));	fprintf(stderr, _("grubby: no action specified\n"));
4456	return 1;	return 1;
4457	}	}
#	Line 2520  int main(int argc, const char ** argv) {	Line 4471  int main(int argc, const char ** argv) {
4471	bootPrefix = "";	bootPrefix = "";
4472	}	}
4473
4474		if (!cfi->mbAllowExtraInitRds &&
4475		extraInitrdCount > 0) {
4476		fprintf(stderr, _("grubby: %s doesn't allow multiple initrds\n"), cfi->defaultConfig);
4477		return 1;
4478		}
4479
4480	if (bootloaderProbe) {	if (bootloaderProbe) {
4481	int lrc = 0, grc = 0;	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
4482	struct grubConfig * lconfig, * gconfig;	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
4483
4484		const char *grub2config = grub2FindConfig(&grub2ConfigType);
4485		if (grub2config) {
4486		gconfig = readConfig(grub2config, &grub2ConfigType);
4487		if (!gconfig)
4488		gr2c = 1;
4489		else
4490		gr2c = checkForGrub2(gconfig);
4491		}
4492
4493	if (!access(grubConfigType.defaultConfig, F_OK)) {	const char *grubconfig = grubFindConfig(&grubConfigType);
4494	gconfig = readConfig(grubConfigType.defaultConfig, &grubConfigType);	if (!access(grubconfig, F_OK)) {
4495		gconfig = readConfig(grubconfig, &grubConfigType);
4496	if (!gconfig)	if (!gconfig)
4497	grc = 1;	grc = 1;
4498	else	else
#	Line 2540  int main(int argc, const char ** argv) {	Line 4507  int main(int argc, const char ** argv) {
4507	lrc = checkForLilo(lconfig);	lrc = checkForLilo(lconfig);
4508	}	}
4509
4510	if (lrc == 1 || grc == 1) return 1;	if (!access(eliloConfigType.defaultConfig, F_OK)) {
4511		econfig = readConfig(eliloConfigType.defaultConfig,
4512		&eliloConfigType);
4513		if (!econfig)
4514		erc = 1;
4515		else
4516		erc = checkForElilo(econfig);
4517		}
4518
4519		if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
4520		lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
4521		if (!lconfig)
4522		extrc = 1;
4523		else
4524		extrc = checkForExtLinux(lconfig);
4525		}
4526
4527
4528		if (!access(yabootConfigType.defaultConfig, F_OK)) {
4529		yconfig = readConfig(yabootConfigType.defaultConfig,
4530		&yabootConfigType);
4531		if (!yconfig)
4532		yrc = 1;
4533		else
4534		yrc = checkForYaboot(yconfig);
4535		}
4536
4537		if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
4538		erc == 1)
4539		return 1;
4540
4541	if (lrc == 2) printf("lilo\n");	if (lrc == 2) printf("lilo\n");
4542		if (gr2c == 2) printf("grub2\n");
4543	if (grc == 2) printf("grub\n");	if (grc == 2) printf("grub\n");
4544		if (extrc == 2) printf("extlinux\n");
4545		if (yrc == 2) printf("yaboot\n");
4546		if (erc == 2) printf("elilo\n");
4547
4548	return 0;	return 0;
4549	}	}
4550
4551		if (grubConfig == NULL) {
4552		printf("Could not find bootloader configuration file.\n");
4553		exit(1);
4554		}
4555
4556	config = readConfig(grubConfig, cfi);	config = readConfig(grubConfig, cfi);
4557	if (!config) return 1;	if (!config) return 1;
4558
#	Line 2557  int main(int argc, const char ** argv) {	Line 4562  int main(int argc, const char ** argv) {
4562	char * rootspec;	char * rootspec;
4563
4564	if (config->defaultImage == -1) return 0;	if (config->defaultImage == -1) return 0;
4565		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4566		cfi->defaultIsSaved)
4567		config->defaultImage = 0;
4568	entry = findEntryByIndex(config, config->defaultImage);	entry = findEntryByIndex(config, config->defaultImage);
4569	if (!entry) return 0;	if (!entry) return 0;
4570	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4571
4572	line = entry->lines;	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
	while (line && line->type != LT_KERNEL) line = line->next;
4573	if (!line) return 0;	if (!line) return 0;
4574
4575	rootspec = getRootSpecifier(line->elements[1].item);	rootspec = getRootSpecifier(line->elements[1].item);
#	Line 2570  int main(int argc, const char ** argv) {	Line 4577  int main(int argc, const char ** argv) {
4577	((rootspec != NULL) ? strlen(rootspec) : 0));	((rootspec != NULL) ? strlen(rootspec) : 0));
4578
4579	return 0;	return 0;
4580
4581		} else if (displayDefaultTitle) {
4582		struct singleLine * line;
4583		struct singleEntry * entry;
4584
4585		if (config->defaultImage == -1) return 0;
4586		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4587		cfi->defaultIsSaved)
4588		config->defaultImage = 0;
4589		entry = findEntryByIndex(config, config->defaultImage);
4590		if (!entry) return 0;
4591
4592		if (!configureGrub2) {
4593		line = getLineByType(LT_TITLE, entry->lines);
4594		if (!line) return 0;
4595		printf("%s\n", line->elements[1].item);
4596
4597		} else {
4598		char * title;
4599
4600		dbgPrintf("This is GRUB2, default title is embeded in menuentry\n");
4601		line = getLineByType(LT_MENUENTRY, entry->lines);
4602		if (!line) return 0;
4603		title = grub2ExtractTitle(line);
4604		if (title)
4605		printf("%s\n", title);
4606		}
4607		return 0;
4608
4609		} else if (displayDefaultIndex) {
4610		if (config->defaultImage == -1) return 0;
4611		if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
4612		cfi->defaultIsSaved)
4613		config->defaultImage = 0;
4614		printf("%i\n", config->defaultImage);
4615		return 0;
4616
4617	} else if (kernelInfo)	} else if (kernelInfo)
4618	return displayInfo(config, kernelInfo, bootPrefix);	return displayInfo(config, kernelInfo, bootPrefix);
4619
#	Line 2581  int main(int argc, const char ** argv) {	Line 4625  int main(int argc, const char ** argv) {
4625	markRemovedImage(config, removeKernelPath, bootPrefix);	markRemovedImage(config, removeKernelPath, bootPrefix);
4626	markRemovedImage(config, removeMBKernel, bootPrefix);	markRemovedImage(config, removeMBKernel, bootPrefix);
4627	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,	setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
4628	bootPrefix, flags);	bootPrefix, flags, defaultIndex);
4629	setFallbackImage(config, newKernelPath != NULL);	setFallbackImage(config, newKernelPath != NULL);
4630	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,	if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
4631	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;	removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
4632		if (updateKernelPath && newKernelInitrd) {
4633		if (newMBKernel) {
4634		if (addMBInitrd(config, newMBKernel, updateKernelPath,
4635		bootPrefix, newKernelInitrd))
4636		return 1;
4637		} else {
4638		if (updateInitrd(config, updateKernelPath, bootPrefix,
4639		newKernelInitrd))
4640		return 1;
4641		}
4642		}
4643	if (addNewKernel(config, template, bootPrefix, newKernelPath,	if (addNewKernel(config, template, bootPrefix, newKernelPath,
4644	newKernelTitle, newKernelArgs, newKernelInitrd,	newKernelTitle, newKernelArgs, newKernelInitrd,
4645	newMBKernel, newMBKernelArgs)) return 1;	(const char **)extraInitrds, extraInitrdCount,
4646		newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4647
4648
4649	if (numEntries(config) == 0) {	if (numEntries(config) == 0) {
#	Line 2597  int main(int argc, const char ** argv) {	Line 4653  int main(int argc, const char ** argv) {
4653	}	}
4654
4655	if (!outputFile)	if (!outputFile)
4656	outputFile = grubConfig;	outputFile = (char *)grubConfig;
4657
4658	return writeConfig(config, outputFile, bootPrefix);	return writeConfig(config, outputFile, bootPrefix);
4659	}	}

---

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

Legend: Removed from v.532   changed lines   Added in v.2957