stage2/stage2.c - grub4dos-solaris - Rivoreo Source Code Repositories

 /*
  *  GRUB  --  GRand Unified Bootloader
  *  Copyright (C) 2000,2001,2002,2004,2005  Free Software Foundation, Inc.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */

 #include <shared.h>
 #include <term.h>

 grub_jmp_buf restart_env;

 struct silentbuf silent;
 int reset_term;

 #if defined(PRESET_MENU_STRING) || defined(SUPPORT_DISKLESS)

 # if defined(PRESET_MENU_STRING)
 static const char *preset_menu = PRESET_MENU_STRING;
 # elif defined(SUPPORT_DISKLESS)
 /* Execute the command "bootp" automatically.  */
 static const char *preset_menu = "dhcp\n";
 # endif /* SUPPORT_DISKLESS */

 static int preset_menu_offset;

 static int
 open_preset_menu (void)
 {
 #ifdef GRUB_UTIL
   /* Unless the user explicitly requests to use the preset menu,
      always opening the preset menu fails in the grub shell.  */
   if (! use_preset_menu)
     return 0;
 #endif /* GRUB_UTIL */

   preset_menu_offset = 0;
   return preset_menu != 0;
 }

 static int
 read_from_preset_menu (char *buf, int maxlen)
 {
   int len = grub_strlen (preset_menu + preset_menu_offset);

   if (len > maxlen)
     len = maxlen;

   grub_memmove (buf, preset_menu + preset_menu_offset, len);
   preset_menu_offset += len;

   return len;
 }

 static void
 close_preset_menu (void)
 {
   /* Disable the preset menu.  */
   preset_menu = 0;
 }

 #else /* ! PRESET_MENU_STRING && ! SUPPORT_DISKLESS */

 #define open_preset_menu()	0
 #define read_from_preset_menu(buf, maxlen)	0
 #define close_preset_menu()

 #endif /* ! PRESET_MENU_STRING && ! SUPPORT_DISKLESS */

 static char *
 get_entry (char *list, int num, int nested)
 {
   int i;

   for (i = 0; i < num; i++)
     {
       do
 	{
 	  while (*(list++));
 	}
       while (nested && *(list++));
     }

   return list;
 }

 /* Print an entry in a line of the menu box.  */
 static void
 print_entry (int y, int highlight, char *entry)
 {
   int x;

   if (current_term->setcolorstate)
     current_term->setcolorstate (COLOR_STATE_NORMAL);

   if (highlight && current_term->setcolorstate)
     current_term->setcolorstate (COLOR_STATE_HIGHLIGHT);

   gotoxy (2, y);
   grub_putchar (' ');
   for (x = 3; x < 75; x++)
     {
       if (*entry && x <= 72)
 	{
 	  if (x == 72)
 	    grub_putchar (DISP_RIGHT);
 	  else
 	    grub_putchar (*entry++);
 	}
       else
 	grub_putchar (' ');
     }
   gotoxy (74, y);

   if (current_term->setcolorstate)
     current_term->setcolorstate (COLOR_STATE_STANDARD);
 }

 /* Print entries in the menu box.  */
 static void
 print_entries (int y, int size, int first, int entryno, char *menu_entries)
 {
   int i;

   gotoxy (77, y + 1);

   if (first)
     grub_putchar (DISP_UP);
   else
     grub_putchar (' ');

   menu_entries = get_entry (menu_entries, first, 0);

   for (i = 0; i < size; i++)
     {
       print_entry (y + i + 1, entryno == i, menu_entries);

       while (*menu_entries)
 	menu_entries++;

       if (*(menu_entries - 1))
 	menu_entries++;
     }

   gotoxy (77, y + size);

   if (*menu_entries)
     grub_putchar (DISP_DOWN);
   else
     grub_putchar (' ');

   gotoxy (74, y + entryno + 1);
 }

 static void
 print_entries_raw (int size, int first, char *menu_entries)
 {
   int i;

 #define LINE_LENGTH 67

   for (i = 0; i < LINE_LENGTH; i++)
     grub_putchar ('-');
   grub_putchar ('\n');

   for (i = first; i < size; i++)
     {
       /* grub's printf can't %02d so ... */
       if (i < 10)
 	grub_putchar (' ');
       grub_printf ("%d: %s\n", i, get_entry (menu_entries, i, 0));
     }

   for (i = 0; i < LINE_LENGTH; i++)
     grub_putchar ('-');
   grub_putchar ('\n');

 #undef LINE_LENGTH
 }


 static void
 print_border (int y, int size)
 {
   int i;

   if (current_term->setcolorstate)
     current_term->setcolorstate (COLOR_STATE_NORMAL);

   gotoxy (1, y);

   grub_putchar (DISP_UL);
   for (i = 0; i < 73; i++)
     grub_putchar (DISP_HORIZ);
   grub_putchar (DISP_UR);

   i = 1;
   while (1)
     {
       gotoxy (1, y + i);

       if (i > size)
 	break;

       grub_putchar (DISP_VERT);
       gotoxy (75, y + i);
       grub_putchar (DISP_VERT);

       i++;
     }

   grub_putchar (DISP_LL);
   for (i = 0; i < 73; i++)
     grub_putchar (DISP_HORIZ);
   grub_putchar (DISP_LR);

   if (current_term->setcolorstate)
     current_term->setcolorstate (COLOR_STATE_STANDARD);
 }

 static void
 run_menu (char *menu_entries, char *config_entries, int num_entries,
 	  char *heap, int entryno)
 {
   int c, time1, time2 = -1, first_entry = 0;
   char *cur_entry = 0;
   struct term_entry *prev_term = NULL;

   /*
    *  Main loop for menu UI.
    */

 restart:
   /* Dumb terminal always use all entries for display
      invariant for TERM_DUMB: first_entry == 0  */
   if (! (current_term->flags & TERM_DUMB))
     {
       while (entryno > 11)
 	{
 	  first_entry++;
 	  entryno--;
 	}
     }

   /* If the timeout was expired or wasn't set, force to show the menu
      interface. */
   if (grub_timeout < 0)
     show_menu = 1;

   /* If SHOW_MENU is false, don't display the menu until ESC is pressed.  */
   if (! show_menu)
     {
       /* Get current time.  */
       while ((time1 = getrtsecs ()) == 0xFF)
 	;

       while (1)
 	{
 	  /* Check if ESC is pressed.  */
 	  if (checkkey () != -1 && ASCII_CHAR (getkey ()) == '\e')
 	    {
 	      grub_timeout = -1;
 	      show_menu = 1;
 	      break;
 	    }

 	  /* If GRUB_TIMEOUT is expired, boot the default entry.  */
 	  if (grub_timeout >=0
 	      && (time1 = getrtsecs ()) != time2
 	      && time1 != 0xFF)
 	    {
 	      if (grub_timeout <= 0)
 		{
 		  grub_timeout = -1;
 		  goto boot_entry;
 		}

 	      time2 = time1;
 	      grub_timeout--;

 	      /* Print a message.  */
 	      grub_printf ("\rPress `ESC' to enter the menu... %d   ",
 			   grub_timeout);
 	    }
 	}
     }

   /* Only display the menu if the user wants to see it. */
   if (show_menu)
     {
       init_page ();
       setcursor (0);

       if (current_term->flags & TERM_DUMB)
 	print_entries_raw (num_entries, first_entry, menu_entries);
       else
 	print_border (3, 12);

       grub_printf ("\n\
       Use the %c and %c keys to select which entry is highlighted.\n",
 		   DISP_UP, DISP_DOWN);

       if (! auth && password)
 	{
 	  printf ("\
       Press enter to boot the selected OS or \'p\' to enter a\n\
       password to unlock the next set of features.");
 	}
       else
 	{
 	  if (config_entries)
 	    printf ("\
       Press enter to boot the selected OS, \'e\' to edit the\n\
       commands before booting, or \'c\' for a command-line.");
 	  else
 	    printf ("\
       Press \'b\' to boot, \'e\' to edit the selected command in the\n\
       boot sequence, \'c\' for a command-line, \'o\' to open a new line\n\
       after (\'O\' for before) the selected line, \'d\' to remove the\n\
       selected line, or escape to go back to the main menu.");
 	}

       if (current_term->flags & TERM_DUMB)
 	grub_printf ("\n\nThe selected entry is %d ", entryno);
       else
 	print_entries (3, 12, first_entry, entryno, menu_entries);
     }

   /* XX using RT clock now, need to initialize value */
   while ((time1 = getrtsecs()) == 0xFF);

   while (1)
     {
       /* Initialize to NULL just in case...  */
       cur_entry = NULL;

       if (grub_timeout >= 0 && (time1 = getrtsecs()) != time2 && time1 != 0xFF)
 	{
 	  if (grub_timeout <= 0)
 	    {
 	      grub_timeout = -1;
 	      break;
 	    }

 	  /* else not booting yet! */
 	  time2 = time1;

 	  if (current_term->flags & TERM_DUMB)
 	      grub_printf ("\r    Entry %d will be booted automatically in %d seconds.   ",
 			   entryno, grub_timeout);
 	  else
 	    {
 	      gotoxy (3, 22);
 	      grub_printf ("The highlighted entry will be booted automatically in %d seconds.    ",
 			   grub_timeout);
 	      gotoxy (74, 4 + entryno);
 	  }

 	  grub_timeout--;
 	}

       /* Check for a keypress, however if TIMEOUT has been expired
 	 (GRUB_TIMEOUT == -1) relax in GETKEY even if no key has been
 	 pressed.
 	 This avoids polling (relevant in the grub-shell and later on
 	 in grub if interrupt driven I/O is done).  */
       if (checkkey () >= 0 || grub_timeout < 0)
 	{
 	  /* Key was pressed, show which entry is selected before GETKEY,
 	     since we're comming in here also on GRUB_TIMEOUT == -1 and
 	     hang in GETKEY */
 	  if (current_term->flags & TERM_DUMB)
 	    grub_printf ("\r    Highlighted entry is %d: ", entryno);

 	  c = ASCII_CHAR (getkey ());

 	  if (grub_timeout >= 0)
 	    {
 	      if (current_term->flags & TERM_DUMB)
 		grub_putchar ('\r');
 	      else
 		gotoxy (3, 22);
 	      printf ("                                                                    ");
 	      grub_timeout = -1;
 	      fallback_entryno = -1;
 	      if (! (current_term->flags & TERM_DUMB))
 		gotoxy (74, 4 + entryno);
 	    }

 	  /* We told them above (at least in SUPPORT_SERIAL) to use
 	     '^' or 'v' so accept these keys.  */
 	  if (c == 16 || c == '^')
 	    {
 	      if (current_term->flags & TERM_DUMB)
 		{
 		  if (entryno > 0)
 		    entryno--;
 		}
 	      else
 		{
 		  if (entryno > 0)
 		    {
 		      print_entry (4 + entryno, 0,
 				   get_entry (menu_entries,
 					      first_entry + entryno,
 					      0));
 		      entryno--;
 		      print_entry (4 + entryno, 1,
 				   get_entry (menu_entries,
 					      first_entry + entryno,
 					      0));
 		    }
 		  else if (first_entry > 0)
 		    {
 		      first_entry--;
 		      print_entries (3, 12, first_entry, entryno,
 				     menu_entries);
 		    }
 		}
 	    }
 	  else if ((c == 14 || c == 'v')
 		   && first_entry + entryno + 1 < num_entries)
 	    {
 	      if (current_term->flags & TERM_DUMB)
 		entryno++;
 	      else
 		{
 		  if (entryno < 11)
 		    {
 		      print_entry (4 + entryno, 0,
 				   get_entry (menu_entries,
 					      first_entry + entryno,
 					      0));
 		      entryno++;
 		      print_entry (4 + entryno, 1,
 				   get_entry (menu_entries,
 					      first_entry + entryno,
 					      0));
 		  }
 		else if (num_entries > 12 + first_entry)
 		  {
 		    first_entry++;
 		    print_entries (3, 12, first_entry, entryno, menu_entries);
 		  }
 		}
 	    }
 	  else if (c == 7)
 	    {
 	      /* Page Up */
 	      first_entry -= 12;
 	      if (first_entry < 0)
 		{
 		  entryno += first_entry;
 		  first_entry = 0;
 		  if (entryno < 0)
 		    entryno = 0;
 		}
 	      print_entries (3, 12, first_entry, entryno, menu_entries);
 	    }
 	  else if (c == 3)
 	    {
 	      /* Page Down */
 	      first_entry += 12;
 	      if (first_entry + entryno + 1 >= num_entries)
 		{
 		  first_entry = num_entries - 12;
 		  if (first_entry < 0)
 		    first_entry = 0;
 		  entryno = num_entries - first_entry - 1;
 		}
 	      print_entries (3, 12, first_entry, entryno, menu_entries);
 	    }

 	  if (config_entries)
 	    {
 	      if ((c == '\n') || (c == '\r') || (c == 6))
 		break;
 	    }
 	  else
 	    {
 	      if ((c == 'd') || (c == 'o') || (c == 'O'))
 		{
 		  if (! (current_term->flags & TERM_DUMB))
 		    print_entry (4 + entryno, 0,
 				 get_entry (menu_entries,
 					    first_entry + entryno,
 					    0));

 		  /* insert after is almost exactly like insert before */
 		  if (c == 'o')
 		    {
 		      /* But `o' differs from `O', since it may causes
 			 the menu screen to scroll up.  */
 		      if (entryno < 11 || (current_term->flags & TERM_DUMB))
 			entryno++;
 		      else
 			first_entry++;

 		      c = 'O';
 		    }

 		  cur_entry = get_entry (menu_entries,
 					 first_entry + entryno,
 					 0);

 		  if (c == 'O')
 		    {
 		      grub_memmove (cur_entry + 2, cur_entry,
 				    ((int) heap) - ((int) cur_entry));

 		      cur_entry[0] = ' ';
 		      cur_entry[1] = 0;

 		      heap += 2;

 		      num_entries++;
 		    }
 		  else if (num_entries > 0)
 		    {
 		      char *ptr = get_entry(menu_entries,
 					    first_entry + entryno + 1,
 					    0);

 		      grub_memmove (cur_entry, ptr,
 				    ((int) heap) - ((int) ptr));
 		      heap -= (((int) ptr) - ((int) cur_entry));

 		      num_entries--;

 		      if (entryno >= num_entries)
 			entryno--;
 		      if (first_entry && num_entries < 12 + first_entry)
 			first_entry--;
 		    }

 		  if (current_term->flags & TERM_DUMB)
 		    {
 		      grub_printf ("\n\n");
 		      print_entries_raw (num_entries, first_entry,
 					 menu_entries);
 		      grub_printf ("\n");
 		    }
 		  else
 		    print_entries (3, 12, first_entry, entryno, menu_entries);
 		}

 	      cur_entry = menu_entries;
 	      if (c == 27)
 		return;
 	      if (c == 'b')
 		break;
 	    }

 	  if (! auth && password)
 	    {
 	      if (c == 'p')
 		{
 		  /* Do password check here! */
 		  char entered[32];
 		  char *pptr = password;

 		  if (current_term->flags & TERM_DUMB)
 		    grub_printf ("\r                                    ");
 		  else
 		    gotoxy (1, 21);

 		  /* Wipe out the previously entered password */
 		  grub_memset (entered, 0, sizeof (entered));
 		  get_cmdline (" Password: ", entered, 31, '*', 0);

 		  while (! isspace (*pptr) && *pptr)
 		    pptr++;

 		  /* Make sure that PASSWORD is NUL-terminated.  */
 		  *pptr++ = 0;

 		  if (! check_password (entered, password, password_type))
 		    {
 		      char *new_file = config_file;
 		      while (isspace (*pptr))
 			pptr++;

 		      /* If *PPTR is NUL, then allow the user to use
 			 privileged instructions, otherwise, load
 			 another configuration file.  */
 		      if (*pptr != 0)
 			{
 			  while ((*(new_file++) = *(pptr++)) != 0)
 			    ;

 			  /* Make sure that the user will not have
 			     authority in the next configuration.  */
 			  auth = 0;
 			  return;
 			}
 		      else
 			{
 			  /* Now the user is superhuman.  */
 			  auth = 1;
 			  goto restart;
 			}
 		    }
 		  else
 		    {
 		      grub_printf ("Failed!\n      Press any key to continue...");
 		      getkey ();
 		      goto restart;
 		    }
 		}
 	    }
 	  else
 	    {
 	      if (c == 'e')
 		{
 		  int new_num_entries = 0, i = 0;
 		  char *new_heap;

 		  if (config_entries)
 		    {
 		      new_heap = heap;
 		      cur_entry = get_entry (config_entries,
 					     first_entry + entryno,
 					     1);
 		    }
 		  else
 		    {
 		      /* safe area! */
 		      new_heap = heap + NEW_HEAPSIZE + 1;
 		      cur_entry = get_entry (menu_entries,
 					     first_entry + entryno,
 					     0);
 		    }

 		  do
 		    {
 		      while ((*(new_heap++) = cur_entry[i++]) != 0);
 		      new_num_entries++;
 		    }
 		  while (config_entries && cur_entry[i]);

 		  /* this only needs to be done if config_entries is non-NULL,
 		     but it doesn't hurt to do it always */
 		  *(new_heap++) = 0;

 		  if (config_entries)
 		    run_menu (heap, NULL, new_num_entries, new_heap, 0);
 		  else
 		    {
 		      cls ();
 		      print_cmdline_message (0);

 		      new_heap = heap + NEW_HEAPSIZE + 1;

 		      saved_drive = boot_drive;
 		      saved_partition = install_partition;
 		      current_drive = GRUB_INVALID_DRIVE;

 		      if (! get_cmdline (PACKAGE " edit> ", new_heap,
 					 NEW_HEAPSIZE + 1, 0, 1))
 			{
 			  int j = 0;

 			  /* get length of new command */
 			  while (new_heap[j++])
 			    ;

 			  if (j < 2)
 			    {
 			      j = 2;
 			      new_heap[0] = ' ';
 			      new_heap[1] = 0;
 			    }

 			  /* align rest of commands properly */
 			  grub_memmove (cur_entry + j, cur_entry + i,
 					(int) heap - ((int) cur_entry + i));

 			  /* copy command to correct area */
 			  grub_memmove (cur_entry, new_heap, j);

 			  heap += (j - i);
 			}
 		    }

 		  goto restart;
 		}
 	      if (c == 'c')
 		{
 		  enter_cmdline (heap, 0);
 		  goto restart;
 		}
 #ifdef GRUB_UTIL
 	      if (c == 'q')
 		{
 		  /* The same as ``quit''.  */
 		  stop ();
 		}
 #endif
 	    }
 	}
     }

   /* Attempt to boot an entry.  */

  boot_entry:

   if (silent.status != DEFER_VERBOSE)
     silent.status = SILENT;

   reset_term = 1;

   cls ();
   setcursor (1);

   /* if our terminal needed initialization, we should shut it down
    * before booting the kernel, but we want to save what it was so
    * we can come back if needed */
   prev_term = current_term;

   if (silent.status != SILENT)
     if (current_term->shutdown) {
       (*current_term->shutdown)();
       current_term = term_table; /* assumption: console is first */
     }

   while (1)
     {
       if (config_entries)
 	printf ("  Booting \'%s\'\n\n",
 		  get_entry (menu_entries, first_entry + entryno, 0));
       else
 	printf ("  Booting command-list\n\n");

       if (! cur_entry)
 	cur_entry = get_entry (config_entries, first_entry + entryno, 1);

       /* Set CURRENT_ENTRYNO for the command "savedefault".  */
       current_entryno = first_entry + entryno;

       if (run_script (cur_entry, heap))
 	{
 	  if (fallback_entryno >= 0)
 	    {
 	      cur_entry = NULL;
 	      first_entry = 0;
 	      entryno = fallback_entries[fallback_entryno];
 	      fallback_entryno++;
 	      if (fallback_entryno >= MAX_FALLBACK_ENTRIES
 		  || fallback_entries[fallback_entryno] < 0)
 		fallback_entryno = -1;
 	    }
 	  else
 	    break;
 	}
       else
 	break;
     }

   if (silent.status != SILENT) { /* don't reset if we never changed terms */
     /* if we get back here, we should go back to what our term was before */
     current_term = prev_term;
     if (current_term->startup)
         /* if our terminal fails to initialize, fall back to console since
          * it should always work */
         if ((*current_term->startup)() == 0)
             current_term = term_table; /* we know that console is first */
   }

   show_menu = 1;
   goto restart;
 }


 static int
 get_line_from_config (char *cmdline, int maxlen, int read_from_file)
 {
   int pos = 0, literal = 0, comment = 0;
   char c;  /* since we're loading it a byte at a time! */

   while (1)
     {
       if (read_from_file)
 	{
 	  if (! grub_read (&c, 1))
 	    break;
 	}
       else
 	{
 	  if (! read_from_preset_menu (&c, 1))
 	    break;
 	}

       /* Skip all carriage returns.  */
       if (c == '\r')
 	continue;

       /* Replace tabs with spaces.  */
       if (c == '\t')
 	c = ' ';

       /* The previous is a backslash, then...  */
       if (literal)
 	{
 	  /* If it is a newline, replace it with a space and continue.  */
 	  if (c == '\n')
 	    {
 	      c = ' ';

 	      /* Go back to overwrite a backslash.  */
 	      if (pos > 0)
 		pos--;
 	    }

 	  literal = 0;
 	}

       /* translate characters first! */
       if (c == '\\' && ! literal)
 	literal = 1;

       if (comment)
 	{
 	  if (c == '\n')
 	    comment = 0;
 	}
       else if (! pos)
 	{
 	  if (c == '#')
 	    comment = 1;
 	  else if ((c != ' ') && (c != '\n'))
 	    cmdline[pos++] = c;
 	}
       else
 	{
 	  if (c == '\n')
 	    break;

 	  if (pos < maxlen)
 	    cmdline[pos++] = c;
 	}
     }

   cmdline[pos] = 0;

   return pos;
 }

 extern int findroot_func (char *arg, int flags);

 /* This is the starting function in C.  */
 void
 cmain (void)
 {
   int config_len, menu_len, num_entries;
   char *config_entries, *menu_entries;
   char *kill_buf = (char *) KILL_BUF;

   silent.status = DEFER_SILENT;
   silent.looped = 0;
   silent.buffer_start = silent.buffer;

   auto void reset (void);
   void reset (void)
     {
       count_lines = -1;
       config_len = 0;
       menu_len = 0;
       num_entries = 0;
       config_entries = (char *) mbi.drives_addr + mbi.drives_length;
       menu_entries = (char *) MENU_BUF;
       init_config ();
     }

   /* Initialize the environment for restarting Stage 2.  */
   grub_setjmp (restart_env);

   /* Initialize the kill buffer.  */
   *kill_buf = 0;

   /* Never return.  */
   for (;;)
     {
       int is_opened, is_preset;

       reset ();

       /* Here load the configuration file.  */

 #ifdef GRUB_UTIL
       if (use_config_file)
 #endif /* GRUB_UTIL */
 	{
 	  char *default_file = (char *) DEFAULT_FILE_BUF;
 	  int i;

 	  /* Get a saved default entry if possible.  */
 	  saved_entryno = 0;
 	  grub_strcpy (default_file, config_file);
 	  for (i = grub_strlen(default_file); i >= 0; i--)
 	    if (default_file[i] == '/')
 	      {
 		i++;
 		break;
 	      }
 	  default_file[i] = 0;
 	  grub_strncat (default_file + i, "default", DEFAULT_FILE_BUFLEN - i);
 	  if (grub_open (default_file))
 	    {
 	      char buf[10]; /* This is good enough.  */
 	      char *p = buf;
 	      int len;

 	      len = grub_read (buf, sizeof (buf));
 	      if (len > 0)
 		{
 		  buf[sizeof (buf) - 1] = 0;
 		  safe_parse_maxint (&p, &saved_entryno);
 		}

 	      grub_close ();
 	    }
 	  errnum = ERR_NONE;

 	  do
 	    {
 	      /* STATE 0:  Before any title command.
 		 STATE 1:  In a title command.
 		 STATE >1: In a entry after a title command.  */
 	      int state = 0, prev_config_len = 0, prev_menu_len = 0;
 	      char *cmdline;

 	      /* Try the preset menu first. This will succeed at most once,
 		 because close_preset_menu disables the preset menu.  */
 	      is_opened = is_preset = open_preset_menu ();
 	      if (! is_opened)
 		{
 		  is_opened = grub_open (config_file);
 		}
 	      /*
 	       * we're not going to get very far if we weren't able to
 	       * open the config file and this isn't a valid filesystem,
 	       * so look for the config file somewhere else
 	       */
 	      if (!is_opened && errnum == ERR_FSYS_MOUNT &&
 		(findroot_func(config_file, 0) == 0)) {
 		  is_opened = grub_open (config_file);
 	      }

 	      if (! is_opened) {
 	        errnum = ERR_NONE;
 		break;
 	      }

 	      /* This is necessary, because the menu must be overrided.  */
 	      reset ();

 	      cmdline = (char *) CMDLINE_BUF;
 	      while (get_line_from_config (cmdline, NEW_HEAPSIZE,
 					   ! is_preset))
 		{
 		  struct builtin *builtin;

 		  /* Get the pointer to the builtin structure.  */
 		  builtin = find_command (cmdline);
 		  errnum = 0;
 		  if (! builtin)
 		    /* Unknown command. Just skip now.  */
 		    continue;

 		  if (builtin->flags & BUILTIN_TITLE)
 		    {
 		      char *ptr;

 		      /* the command "title" is specially treated.  */
 		      if (state > 1)
 			{
 			  /* The next title is found.  */
 			  num_entries++;
 			  config_entries[config_len++] = 0;
 			  prev_menu_len = menu_len;
 			  prev_config_len = config_len;
 			}
 		      else
 			{
 			  /* The first title is found.  */
 			  menu_len = prev_menu_len;
 			  config_len = prev_config_len;
 			}

 		      /* Reset the state.  */
 		      state = 1;

 		      /* Copy title into menu area.  */
 		      ptr = skip_to (1, cmdline);
 		      while ((menu_entries[menu_len++] = *(ptr++)) != 0)
 			;
 		    }
 		  else if (! state)
 		    {
 		      /* Run a command found is possible.  */
 		      if (builtin->flags & BUILTIN_MENU)
 			{
 			  char *arg = skip_to (1, cmdline);
 			  (builtin->func) (arg, BUILTIN_MENU);
 			  errnum = 0;
 			}
 		      else
 			/* Ignored.  */
 			continue;
 		    }
 		  else
 		    {
 		      char *ptr = cmdline;

 		      state++;
 		      /* Copy config file data to config area.  */
 		      while ((config_entries[config_len++] = *ptr++) != 0)
 			;
 		    }
 		}

 	      if (state > 1)
 		{
 		  /* Finish the last entry.  */
 		  num_entries++;
 		  config_entries[config_len++] = 0;
 		}
 	      else
 		{
 		  menu_len = prev_menu_len;
 		  config_len = prev_config_len;
 		}

 	      menu_entries[menu_len++] = 0;
 	      config_entries[config_len++] = 0;
 	      grub_memmove (config_entries + config_len, menu_entries,
 			    menu_len);
 	      menu_entries = config_entries + config_len;

 	      /* Make sure that all fallback entries are valid.  */
 	      if (fallback_entryno >= 0)
 		{
 		  for (i = 0; i < MAX_FALLBACK_ENTRIES; i++)
 		    {
 		      if (fallback_entries[i] < 0)
 			break;
 		      if (fallback_entries[i] >= num_entries)
 			{
 			  grub_memmove (fallback_entries + i,
 					fallback_entries + i + 1,
 					((MAX_FALLBACK_ENTRIES - i - 1)
 					 * sizeof (int)));
 			  i--;
 			}
 		    }

 		  if (fallback_entries[0] < 0)
 		    fallback_entryno = -1;
 		}
 	      /* Check if the default entry is present. Otherwise reset
 		 it to fallback if fallback is valid, or to DEFAULT_ENTRY
 		 if not.  */
 	      if (default_entry >= num_entries)
 		{
 		  if (fallback_entryno >= 0)
 		    {
 		      default_entry = fallback_entries[0];
 		      fallback_entryno++;
 		      if (fallback_entryno >= MAX_FALLBACK_ENTRIES
 			  || fallback_entries[fallback_entryno] < 0)
 			fallback_entryno = -1;
 		    }
 		  else
 		    default_entry = 0;
 		}

 	      if (is_preset)
 		close_preset_menu ();
 	      else
 		grub_close ();
 	    }
 	  while (is_preset);
 	}

       /* go ahead and make sure the terminal is setup */
       if (current_term->startup)
         (*current_term->startup)();

       if (! num_entries)
 	{
 	  /* If no acceptable config file, goto command-line, starting
 	     heap from where the config entries would have been stored
 	     if there were any.  */
 	  enter_cmdline (config_entries, 1);
 	}
       else
 	{
 	  /* Run menu interface.  */
 	  run_menu (menu_entries, config_entries, num_entries,
 		    menu_entries + menu_len, default_entry);
 	}
     }
 }
	/*
	* GRUB -- GRand Unified Bootloader
	* Copyright (C) 2000,2001,2002,2004,2005 Free Software Foundation, Inc.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	*/

	#include <shared.h>
	#include <term.h>

	grub_jmp_buf restart_env;

	struct silentbuf silent;
	int reset_term;

	#if defined(PRESET_MENU_STRING) \|\| defined(SUPPORT_DISKLESS)

	# if defined(PRESET_MENU_STRING)
	static const char *preset_menu = PRESET_MENU_STRING;
	# elif defined(SUPPORT_DISKLESS)
	/* Execute the command "bootp" automatically. */
	static const char *preset_menu = "dhcp\n";
	# endif /* SUPPORT_DISKLESS */

	static int preset_menu_offset;

	static int
	open_preset_menu (void)
	{
	#ifdef GRUB_UTIL
	/* Unless the user explicitly requests to use the preset menu,
	always opening the preset menu fails in the grub shell. */
	if (! use_preset_menu)
	return 0;
	#endif /* GRUB_UTIL */

	preset_menu_offset = 0;
	return preset_menu != 0;
	}

	static int
	read_from_preset_menu (char *buf, int maxlen)
	{
	int len = grub_strlen (preset_menu + preset_menu_offset);

	if (len > maxlen)
	len = maxlen;

	grub_memmove (buf, preset_menu + preset_menu_offset, len);
	preset_menu_offset += len;

	return len;
	}

	static void
	close_preset_menu (void)
	{
	/* Disable the preset menu. */
	preset_menu = 0;
	}

	#else /* ! PRESET_MENU_STRING && ! SUPPORT_DISKLESS */

	#define open_preset_menu() 0
	#define read_from_preset_menu(buf, maxlen) 0
	#define close_preset_menu()

	#endif /* ! PRESET_MENU_STRING && ! SUPPORT_DISKLESS */

	static char *
	get_entry (char *list, int num, int nested)
	{
	int i;

	for (i = 0; i < num; i++)
	{
	do
	{
	while (*(list++));
	}
	while (nested && *(list++));
	}

	return list;
	}

	/* Print an entry in a line of the menu box. */
	static void
	print_entry (int y, int highlight, char *entry)
	{
	int x;

	if (current_term->setcolorstate)
	current_term->setcolorstate (COLOR_STATE_NORMAL);

	if (highlight && current_term->setcolorstate)
	current_term->setcolorstate (COLOR_STATE_HIGHLIGHT);

	gotoxy (2, y);
	grub_putchar (' ');
	for (x = 3; x < 75; x++)
	{
	if (*entry && x <= 72)
	{
	if (x == 72)
	grub_putchar (DISP_RIGHT);
	else
	grub_putchar (*entry++);
	}
	else
	grub_putchar (' ');
	}
	gotoxy (74, y);

	if (current_term->setcolorstate)
	current_term->setcolorstate (COLOR_STATE_STANDARD);
	}

	/* Print entries in the menu box. */
	static void
	print_entries (int y, int size, int first, int entryno, char *menu_entries)
	{
	int i;

	gotoxy (77, y + 1);

	if (first)
	grub_putchar (DISP_UP);
	else
	grub_putchar (' ');

	menu_entries = get_entry (menu_entries, first, 0);

	for (i = 0; i < size; i++)
	{
	print_entry (y + i + 1, entryno == i, menu_entries);

	while (*menu_entries)
	menu_entries++;

	if (*(menu_entries - 1))
	menu_entries++;
	}

	gotoxy (77, y + size);

	if (*menu_entries)
	grub_putchar (DISP_DOWN);
	else
	grub_putchar (' ');

	gotoxy (74, y + entryno + 1);
	}

	static void
	print_entries_raw (int size, int first, char *menu_entries)
	{
	int i;

	#define LINE_LENGTH 67

	for (i = 0; i < LINE_LENGTH; i++)
	grub_putchar ('-');
	grub_putchar ('\n');

	for (i = first; i < size; i++)
	{
	/* grub's printf can't %02d so ... */
	if (i < 10)
	grub_putchar (' ');
	grub_printf ("%d: %s\n", i, get_entry (menu_entries, i, 0));
	}

	for (i = 0; i < LINE_LENGTH; i++)
	grub_putchar ('-');
	grub_putchar ('\n');

	#undef LINE_LENGTH
	}


	static void
	print_border (int y, int size)
	{
	int i;

	if (current_term->setcolorstate)
	current_term->setcolorstate (COLOR_STATE_NORMAL);

	gotoxy (1, y);

	grub_putchar (DISP_UL);
	for (i = 0; i < 73; i++)
	grub_putchar (DISP_HORIZ);
	grub_putchar (DISP_UR);

	i = 1;
	while (1)
	{
	gotoxy (1, y + i);

	if (i > size)
	break;

	grub_putchar (DISP_VERT);
	gotoxy (75, y + i);
	grub_putchar (DISP_VERT);

	i++;
	}

	grub_putchar (DISP_LL);
	for (i = 0; i < 73; i++)
	grub_putchar (DISP_HORIZ);
	grub_putchar (DISP_LR);

	if (current_term->setcolorstate)
	current_term->setcolorstate (COLOR_STATE_STANDARD);
	}

	static void
	run_menu (char menu_entries, char config_entries, int num_entries,
	char *heap, int entryno)
	{
	int c, time1, time2 = -1, first_entry = 0;
	char *cur_entry = 0;
	struct term_entry *prev_term = NULL;

	/*
	* Main loop for menu UI.
	*/

	restart:
	/* Dumb terminal always use all entries for display
	invariant for TERM_DUMB: first_entry == 0 */
	if (! (current_term->flags & TERM_DUMB))
	{
	while (entryno > 11)
	{
	first_entry++;
	entryno--;
	}
	}

	/* If the timeout was expired or wasn't set, force to show the menu
	interface. */
	if (grub_timeout < 0)
	show_menu = 1;

	/* If SHOW_MENU is false, don't display the menu until ESC is pressed. */
	if (! show_menu)
	{
	/* Get current time. */
	while ((time1 = getrtsecs ()) == 0xFF)
	;

	while (1)
	{
	/* Check if ESC is pressed. */
	if (checkkey () != -1 && ASCII_CHAR (getkey ()) == '\e')
	{
	grub_timeout = -1;
	show_menu = 1;
	break;
	}

	/* If GRUB_TIMEOUT is expired, boot the default entry. */
	if (grub_timeout >=0
	&& (time1 = getrtsecs ()) != time2
	&& time1 != 0xFF)
	{
	if (grub_timeout <= 0)
	{
	grub_timeout = -1;
	goto boot_entry;
	}

	time2 = time1;
	grub_timeout--;

	/* Print a message. */
	grub_printf ("\rPress `ESC' to enter the menu... %d ",
	grub_timeout);
	}
	}
	}

	/* Only display the menu if the user wants to see it. */
	if (show_menu)
	{
	init_page ();
	setcursor (0);

	if (current_term->flags & TERM_DUMB)
	print_entries_raw (num_entries, first_entry, menu_entries);
	else
	print_border (3, 12);

	grub_printf ("\n\
	Use the %c and %c keys to select which entry is highlighted.\n",
	DISP_UP, DISP_DOWN);

	if (! auth && password)
	{
	printf ("\
	Press enter to boot the selected OS or \'p\' to enter a\n\
	password to unlock the next set of features.");
	}
	else
	{
	if (config_entries)
	printf ("\
	Press enter to boot the selected OS, \'e\' to edit the\n\
	commands before booting, or \'c\' for a command-line.");
	else
	printf ("\
	Press \'b\' to boot, \'e\' to edit the selected command in the\n\
	boot sequence, \'c\' for a command-line, \'o\' to open a new line\n\
	after (\'O\' for before) the selected line, \'d\' to remove the\n\
	selected line, or escape to go back to the main menu.");
	}

	if (current_term->flags & TERM_DUMB)
	grub_printf ("\n\nThe selected entry is %d ", entryno);
	else
	print_entries (3, 12, first_entry, entryno, menu_entries);
	}

	/* XX using RT clock now, need to initialize value */
	while ((time1 = getrtsecs()) == 0xFF);

	while (1)
	{
	/* Initialize to NULL just in case... */
	cur_entry = NULL;

	if (grub_timeout >= 0 && (time1 = getrtsecs()) != time2 && time1 != 0xFF)
	{
	if (grub_timeout <= 0)
	{
	grub_timeout = -1;
	break;
	}

	/* else not booting yet! */
	time2 = time1;

	if (current_term->flags & TERM_DUMB)
	grub_printf ("\r Entry %d will be booted automatically in %d seconds. ",
	entryno, grub_timeout);
	else
	{
	gotoxy (3, 22);
	grub_printf ("The highlighted entry will be booted automatically in %d seconds. ",
	grub_timeout);
	gotoxy (74, 4 + entryno);
	}

	grub_timeout--;
	}

	/* Check for a keypress, however if TIMEOUT has been expired
	(GRUB_TIMEOUT == -1) relax in GETKEY even if no key has been
	pressed.
	This avoids polling (relevant in the grub-shell and later on
	in grub if interrupt driven I/O is done). */
	if (checkkey () >= 0 \|\| grub_timeout < 0)
	{
	/* Key was pressed, show which entry is selected before GETKEY,
	since we're comming in here also on GRUB_TIMEOUT == -1 and
	hang in GETKEY */
	if (current_term->flags & TERM_DUMB)
	grub_printf ("\r Highlighted entry is %d: ", entryno);

	c = ASCII_CHAR (getkey ());

	if (grub_timeout >= 0)
	{
	if (current_term->flags & TERM_DUMB)
	grub_putchar ('\r');
	else
	gotoxy (3, 22);
	printf (" ");
	grub_timeout = -1;
	fallback_entryno = -1;
	if (! (current_term->flags & TERM_DUMB))
	gotoxy (74, 4 + entryno);
	}

	/* We told them above (at least in SUPPORT_SERIAL) to use
	'^' or 'v' so accept these keys. */
	if (c == 16 \|\| c == '^')
	{
	if (current_term->flags & TERM_DUMB)
	{
	if (entryno > 0)
	entryno--;
	}
	else
	{
	if (entryno > 0)
	{
	print_entry (4 + entryno, 0,
	get_entry (menu_entries,
	first_entry + entryno,
	0));
	entryno--;
	print_entry (4 + entryno, 1,
	get_entry (menu_entries,
	first_entry + entryno,
	0));
	}
	else if (first_entry > 0)
	{
	first_entry--;
	print_entries (3, 12, first_entry, entryno,
	menu_entries);
	}
	}
	}
	else if ((c == 14 \|\| c == 'v')
	&& first_entry + entryno + 1 < num_entries)
	{
	if (current_term->flags & TERM_DUMB)
	entryno++;
	else
	{
	if (entryno < 11)
	{
	print_entry (4 + entryno, 0,
	get_entry (menu_entries,
	first_entry + entryno,
	0));
	entryno++;
	print_entry (4 + entryno, 1,
	get_entry (menu_entries,
	first_entry + entryno,
	0));
	}
	else if (num_entries > 12 + first_entry)
	{
	first_entry++;
	print_entries (3, 12, first_entry, entryno, menu_entries);
	}
	}
	}
	else if (c == 7)
	{
	/* Page Up */
	first_entry -= 12;
	if (first_entry < 0)
	{
	entryno += first_entry;
	first_entry = 0;
	if (entryno < 0)
	entryno = 0;
	}
	print_entries (3, 12, first_entry, entryno, menu_entries);
	}
	else if (c == 3)
	{
	/* Page Down */
	first_entry += 12;
	if (first_entry + entryno + 1 >= num_entries)
	{
	first_entry = num_entries - 12;
	if (first_entry < 0)
	first_entry = 0;
	entryno = num_entries - first_entry - 1;
	}
	print_entries (3, 12, first_entry, entryno, menu_entries);
	}

	if (config_entries)
	{
	if ((c == '\n') \|\| (c == '\r') \|\| (c == 6))
	break;
	}
	else
	{
	if ((c == 'd') \|\| (c == 'o') \|\| (c == 'O'))
	{
	if (! (current_term->flags & TERM_DUMB))
	print_entry (4 + entryno, 0,
	get_entry (menu_entries,
	first_entry + entryno,
	0));

	/* insert after is almost exactly like insert before */
	if (c == 'o')
	{
	/* But `o' differs from `O', since it may causes
	the menu screen to scroll up. */
	if (entryno < 11 \|\| (current_term->flags & TERM_DUMB))
	entryno++;
	else
	first_entry++;

	c = 'O';
	}

	cur_entry = get_entry (menu_entries,
	first_entry + entryno,
	0);

	if (c == 'O')
	{
	grub_memmove (cur_entry + 2, cur_entry,
	((int) heap) - ((int) cur_entry));

	cur_entry[0] = ' ';
	cur_entry[1] = 0;

	heap += 2;

	num_entries++;
	}
	else if (num_entries > 0)
	{
	char *ptr = get_entry(menu_entries,
	first_entry + entryno + 1,
	0);

	grub_memmove (cur_entry, ptr,
	((int) heap) - ((int) ptr));
	heap -= (((int) ptr) - ((int) cur_entry));

	num_entries--;

	if (entryno >= num_entries)
	entryno--;
	if (first_entry && num_entries < 12 + first_entry)
	first_entry--;
	}

	if (current_term->flags & TERM_DUMB)
	{
	grub_printf ("\n\n");
	print_entries_raw (num_entries, first_entry,
	menu_entries);
	grub_printf ("\n");
	}
	else
	print_entries (3, 12, first_entry, entryno, menu_entries);
	}

	cur_entry = menu_entries;
	if (c == 27)
	return;
	if (c == 'b')
	break;
	}

	if (! auth && password)
	{
	if (c == 'p')
	{
	/* Do password check here! */
	char entered[32];
	char *pptr = password;

	if (current_term->flags & TERM_DUMB)
	grub_printf ("\r ");
	else
	gotoxy (1, 21);

	/* Wipe out the previously entered password */
	grub_memset (entered, 0, sizeof (entered));
	get_cmdline (" Password: ", entered, 31, '*', 0);

	while (! isspace (pptr) && pptr)
	pptr++;

	/* Make sure that PASSWORD is NUL-terminated. */
	*pptr++ = 0;

	if (! check_password (entered, password, password_type))
	{
	char *new_file = config_file;
	while (isspace (*pptr))
	pptr++;

	/* If *PPTR is NUL, then allow the user to use
	privileged instructions, otherwise, load
	another configuration file. */
	if (*pptr != 0)
	{
	while (((new_file++) = (pptr++)) != 0)
	;

	/* Make sure that the user will not have
	authority in the next configuration. */
	auth = 0;
	return;
	}
	else
	{
	/* Now the user is superhuman. */
	auth = 1;
	goto restart;
	}
	}
	else
	{
	grub_printf ("Failed!\n Press any key to continue...");
	getkey ();
	goto restart;
	}
	}
	}
	else
	{
	if (c == 'e')
	{
	int new_num_entries = 0, i = 0;
	char *new_heap;

	if (config_entries)
	{
	new_heap = heap;
	cur_entry = get_entry (config_entries,
	first_entry + entryno,
	1);
	}
	else
	{
	/* safe area! */
	new_heap = heap + NEW_HEAPSIZE + 1;
	cur_entry = get_entry (menu_entries,
	first_entry + entryno,
	0);
	}

	do
	{
	while ((*(new_heap++) = cur_entry[i++]) != 0);
	new_num_entries++;
	}
	while (config_entries && cur_entry[i]);

	/* this only needs to be done if config_entries is non-NULL,
	but it doesn't hurt to do it always */
	*(new_heap++) = 0;

	if (config_entries)
	run_menu (heap, NULL, new_num_entries, new_heap, 0);
	else
	{
	cls ();
	print_cmdline_message (0);

	new_heap = heap + NEW_HEAPSIZE + 1;

	saved_drive = boot_drive;
	saved_partition = install_partition;
	current_drive = GRUB_INVALID_DRIVE;

	if (! get_cmdline (PACKAGE " edit> ", new_heap,
	NEW_HEAPSIZE + 1, 0, 1))
	{
	int j = 0;

	/* get length of new command */
	while (new_heap[j++])
	;

	if (j < 2)
	{
	j = 2;
	new_heap[0] = ' ';
	new_heap[1] = 0;
	}

	/* align rest of commands properly */
	grub_memmove (cur_entry + j, cur_entry + i,
	(int) heap - ((int) cur_entry + i));

	/* copy command to correct area */
	grub_memmove (cur_entry, new_heap, j);

	heap += (j - i);
	}
	}

	goto restart;
	}
	if (c == 'c')
	{
	enter_cmdline (heap, 0);
	goto restart;
	}
	#ifdef GRUB_UTIL
	if (c == 'q')
	{
	/* The same as ``quit''. */
	stop ();
	}
	#endif
	}
	}
	}

	/* Attempt to boot an entry. */

	boot_entry:

	if (silent.status != DEFER_VERBOSE)
	silent.status = SILENT;

	reset_term = 1;

	cls ();
	setcursor (1);

	/* if our terminal needed initialization, we should shut it down
	* before booting the kernel, but we want to save what it was so
	* we can come back if needed */
	prev_term = current_term;

	if (silent.status != SILENT)
	if (current_term->shutdown) {
	(*current_term->shutdown)();
	current_term = term_table; /* assumption: console is first */
	}

	while (1)
	{
	if (config_entries)
	printf (" Booting \'%s\'\n\n",
	get_entry (menu_entries, first_entry + entryno, 0));
	else
	printf (" Booting command-list\n\n");

	if (! cur_entry)
	cur_entry = get_entry (config_entries, first_entry + entryno, 1);

	/* Set CURRENT_ENTRYNO for the command "savedefault". */
	current_entryno = first_entry + entryno;

	if (run_script (cur_entry, heap))
	{
	if (fallback_entryno >= 0)
	{
	cur_entry = NULL;
	first_entry = 0;
	entryno = fallback_entries[fallback_entryno];
	fallback_entryno++;
	if (fallback_entryno >= MAX_FALLBACK_ENTRIES
	\|\| fallback_entries[fallback_entryno] < 0)
	fallback_entryno = -1;
	}
	else
	break;
	}
	else
	break;
	}

	if (silent.status != SILENT) { /* don't reset if we never changed terms */
	/* if we get back here, we should go back to what our term was before */
	current_term = prev_term;
	if (current_term->startup)
	/* if our terminal fails to initialize, fall back to console since
	* it should always work */
	if ((*current_term->startup)() == 0)
	current_term = term_table; /* we know that console is first */
	}

	show_menu = 1;
	goto restart;
	}


	static int
	get_line_from_config (char *cmdline, int maxlen, int read_from_file)
	{
	int pos = 0, literal = 0, comment = 0;
	char c; /* since we're loading it a byte at a time! */

	while (1)
	{
	if (read_from_file)
	{
	if (! grub_read (&c, 1))
	break;
	}
	else
	{
	if (! read_from_preset_menu (&c, 1))
	break;
	}

	/* Skip all carriage returns. */
	if (c == '\r')
	continue;

	/* Replace tabs with spaces. */
	if (c == '\t')
	c = ' ';

	/* The previous is a backslash, then... */
	if (literal)
	{
	/* If it is a newline, replace it with a space and continue. */
	if (c == '\n')
	{
	c = ' ';

	/* Go back to overwrite a backslash. */
	if (pos > 0)
	pos--;
	}

	literal = 0;
	}

	/* translate characters first! */
	if (c == '\\' && ! literal)
	literal = 1;

	if (comment)
	{
	if (c == '\n')
	comment = 0;
	}
	else if (! pos)
	{
	if (c == '#')
	comment = 1;
	else if ((c != ' ') && (c != '\n'))
	cmdline[pos++] = c;
	}
	else
	{
	if (c == '\n')
	break;

	if (pos < maxlen)
	cmdline[pos++] = c;
	}
	}

	cmdline[pos] = 0;

	return pos;
	}

	extern int findroot_func (char *arg, int flags);

	/* This is the starting function in C. */
	void
	cmain (void)
	{
	int config_len, menu_len, num_entries;
	char config_entries, menu_entries;
	char kill_buf = (char ) KILL_BUF;

	silent.status = DEFER_SILENT;
	silent.looped = 0;
	silent.buffer_start = silent.buffer;

	auto void reset (void);
	void reset (void)
	{
	count_lines = -1;
	config_len = 0;
	menu_len = 0;
	num_entries = 0;
	config_entries = (char *) mbi.drives_addr + mbi.drives_length;
	menu_entries = (char *) MENU_BUF;
	init_config ();
	}

	/* Initialize the environment for restarting Stage 2. */
	grub_setjmp (restart_env);

	/* Initialize the kill buffer. */
	*kill_buf = 0;

	/* Never return. */
	for (;;)
	{
	int is_opened, is_preset;

	reset ();

	/* Here load the configuration file. */

	#ifdef GRUB_UTIL
	if (use_config_file)
	#endif /* GRUB_UTIL */
	{
	char default_file = (char ) DEFAULT_FILE_BUF;
	int i;

	/* Get a saved default entry if possible. */
	saved_entryno = 0;
	grub_strcpy (default_file, config_file);
	for (i = grub_strlen(default_file); i >= 0; i--)
	if (default_file[i] == '/')
	{
	i++;
	break;
	}
	default_file[i] = 0;
	grub_strncat (default_file + i, "default", DEFAULT_FILE_BUFLEN - i);
	if (grub_open (default_file))
	{
	char buf[10]; /* This is good enough. */
	char *p = buf;
	int len;

	len = grub_read (buf, sizeof (buf));
	if (len > 0)
	{
	buf[sizeof (buf) - 1] = 0;
	safe_parse_maxint (&p, &saved_entryno);
	}

	grub_close ();
	}
	errnum = ERR_NONE;

	do
	{
	/* STATE 0: Before any title command.
	STATE 1: In a title command.
	STATE >1: In a entry after a title command. */
	int state = 0, prev_config_len = 0, prev_menu_len = 0;
	char *cmdline;

	/* Try the preset menu first. This will succeed at most once,
	because close_preset_menu disables the preset menu. */
	is_opened = is_preset = open_preset_menu ();
	if (! is_opened)
	{
	is_opened = grub_open (config_file);
	}
	/*
	* we're not going to get very far if we weren't able to
	* open the config file and this isn't a valid filesystem,
	* so look for the config file somewhere else
	*/
	if (!is_opened && errnum == ERR_FSYS_MOUNT &&
	(findroot_func(config_file, 0) == 0)) {
	is_opened = grub_open (config_file);
	}

	if (! is_opened) {
	errnum = ERR_NONE;
	break;
	}

	/* This is necessary, because the menu must be overrided. */
	reset ();

	cmdline = (char *) CMDLINE_BUF;
	while (get_line_from_config (cmdline, NEW_HEAPSIZE,
	! is_preset))
	{
	struct builtin *builtin;

	/* Get the pointer to the builtin structure. */
	builtin = find_command (cmdline);
	errnum = 0;
	if (! builtin)
	/* Unknown command. Just skip now. */
	continue;

	if (builtin->flags & BUILTIN_TITLE)
	{
	char *ptr;

	/* the command "title" is specially treated. */
	if (state > 1)
	{
	/* The next title is found. */
	num_entries++;
	config_entries[config_len++] = 0;
	prev_menu_len = menu_len;
	prev_config_len = config_len;
	}
	else
	{
	/* The first title is found. */
	menu_len = prev_menu_len;
	config_len = prev_config_len;
	}

	/* Reset the state. */
	state = 1;

	/* Copy title into menu area. */
	ptr = skip_to (1, cmdline);
	while ((menu_entries[menu_len++] = *(ptr++)) != 0)
	;
	}
	else if (! state)
	{
	/* Run a command found is possible. */
	if (builtin->flags & BUILTIN_MENU)
	{
	char *arg = skip_to (1, cmdline);
	(builtin->func) (arg, BUILTIN_MENU);
	errnum = 0;
	}
	else
	/* Ignored. */
	continue;
	}
	else
	{
	char *ptr = cmdline;

	state++;
	/* Copy config file data to config area. */
	while ((config_entries[config_len++] = *ptr++) != 0)
	;
	}
	}

	if (state > 1)
	{
	/* Finish the last entry. */
	num_entries++;
	config_entries[config_len++] = 0;
	}
	else
	{
	menu_len = prev_menu_len;
	config_len = prev_config_len;
	}

	menu_entries[menu_len++] = 0;
	config_entries[config_len++] = 0;
	grub_memmove (config_entries + config_len, menu_entries,
	menu_len);
	menu_entries = config_entries + config_len;

	/* Make sure that all fallback entries are valid. */
	if (fallback_entryno >= 0)
	{
	for (i = 0; i < MAX_FALLBACK_ENTRIES; i++)
	{
	if (fallback_entries[i] < 0)
	break;
	if (fallback_entries[i] >= num_entries)
	{
	grub_memmove (fallback_entries + i,
	fallback_entries + i + 1,
	((MAX_FALLBACK_ENTRIES - i - 1)
	* sizeof (int)));
	i--;
	}
	}

	if (fallback_entries[0] < 0)
	fallback_entryno = -1;
	}
	/* Check if the default entry is present. Otherwise reset
	it to fallback if fallback is valid, or to DEFAULT_ENTRY
	if not. */
	if (default_entry >= num_entries)
	{
	if (fallback_entryno >= 0)
	{
	default_entry = fallback_entries[0];
	fallback_entryno++;
	if (fallback_entryno >= MAX_FALLBACK_ENTRIES
	\|\| fallback_entries[fallback_entryno] < 0)
	fallback_entryno = -1;
	}
	else
	default_entry = 0;
	}

	if (is_preset)
	close_preset_menu ();
	else
	grub_close ();
	}
	while (is_preset);
	}

	/* go ahead and make sure the terminal is setup */
	if (current_term->startup)
	(*current_term->startup)();

	if (! num_entries)
	{
	/* If no acceptable config file, goto command-line, starting
	heap from where the config entries would have been stored
	if there were any. */
	enter_cmdline (config_entries, 1);
	}
	else
	{
	/* Run menu interface. */
	run_menu (menu_entries, config_entries, num_entries,
	menu_entries + menu_len, default_entry);
	}
	}
	}