Magellan Linux

Diff of /trunk/grubby/grubby.c

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

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

Legend:
Removed from v.1736  
changed lines
  Added in v.3025