Magellan Linux

Diff of /trunk/grubby/grubby.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

Legend:
Removed from v.1693  
changed lines
  Added in v.3024