src/usr/pxemenu.c

   1 /*
   2  * Copyright (C) 2009 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #include <stdint.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <ctype.h>
  25 #include <byteswap.h>
  26 #include <curses.h>
  27 #include <console.h>
  28 #include <gpxe/dhcp.h>
  29 #include <gpxe/vsprintf.h>
  30 #include <gpxe/keys.h>
  31 #include <gpxe/timer.h>
  32 #include <usr/dhcpmgmt.h>
  33 #include <usr/autoboot.h>
  34
  35 /** @file
  36  *
  37  * PXE Boot Menus
  38  *
  39  */
  40
  41 /* Colour pairs */
  42 #define CPAIR_NORMAL    1
  43 #define CPAIR_SELECT    2
  44
  45 /** A PXE boot menu item */
  46 struct pxe_menu_item {
  47         /** Boot Server type */
  48         unsigned int type;
  49         /** Description */
  50         char *desc;
  51 };
  52
  53 /**
  54  * A PXE boot menu
  55  *
  56  * This structure encapsulates the menu information provided via DHCP
  57  * options.
  58  */
  59 struct pxe_menu {
  60         /** Boot Server address */
  61         struct in_addr server;
  62         /** Timeout (in seconds)
  63          *
  64          * Negative indicates no timeout (i.e. wait indefinitely)
  65          */
  66         int timeout;
  67         /** Number of menu items */
  68         unsigned int num_items;
  69         /** Selected menu item */
  70         unsigned int selection;
  71         /** Menu items */
  72         struct pxe_menu_item items[0];
  73 };
  74
  75 /**
  76  * Parse and allocate PXE boot menu
  77  *
  78  * @v menu              PXE boot menu to fill in
  79  * @ret rc              Return status code
  80  *
  81  * It is the callers responsibility to eventually free the allocated
  82  * boot menu.
  83  */
  84 static int pxe_menu_parse ( struct pxe_menu **menu ) {
  85         struct setting tmp_setting = { .name = NULL };
  86         struct in_addr server;
  87         struct dhcp_pxe_boot_menu_prompt prompt = { .timeout = 0 };
  88         uint8_t raw_menu[256];
  89         int raw_menu_len;
  90         struct dhcp_pxe_boot_menu *raw_menu_item;
  91         void *raw_menu_end;
  92         unsigned int num_menu_items;
  93         unsigned int i;
  94         int rc;
  95
  96         /* Fetch relevant settings */
  97         tmp_setting.tag = DHCP_PXE_BOOT_SERVER_MCAST;
  98         server.s_addr = INADDR_BROADCAST;
  99         fetch_ipv4_setting ( NULL, &tmp_setting, &server );
 100         tmp_setting.tag = DHCP_PXE_BOOT_MENU_PROMPT;
 101         fetch_setting ( NULL, &tmp_setting, &prompt, sizeof ( prompt ) );
 102         tmp_setting.tag = DHCP_PXE_BOOT_MENU;
 103         memset ( raw_menu, 0, sizeof ( raw_menu ) );
 104         if ( ( raw_menu_len = fetch_setting ( NULL, &tmp_setting, raw_menu,
 105                                               sizeof ( raw_menu ) ) ) < 0 ) {
 106                 rc = raw_menu_len;
 107                 DBG ( "Could not retrieve raw PXE boot menu: %s\n",
 108                       strerror ( rc ) );
 109                 return rc;
 110         }
 111         if ( raw_menu_len >= ( int ) sizeof ( raw_menu ) ) {
 112                 DBG ( "Raw PXE boot menu too large for buffer\n" );
 113                 return -ENOSPC;
 114         }
 115         raw_menu_end = ( raw_menu + raw_menu_len );
 116
 117         /* Count menu items */
 118         num_menu_items = 0;
 119         raw_menu_item = ( ( void * ) raw_menu );
 120         while ( 1 ) {
 121                 if ( ( ( ( void * ) raw_menu_item ) +
 122                        sizeof ( *raw_menu_item ) ) > raw_menu_end )
 123                         break;
 124                 if ( ( ( ( void * ) raw_menu_item ) +
 125                        sizeof ( *raw_menu_item ) +
 126                        raw_menu_item->desc_len ) > raw_menu_end )
 127                         break;
 128                 num_menu_items++;
 129                 raw_menu_item = ( ( ( void * ) raw_menu_item ) +
 130                                   sizeof ( *raw_menu_item ) +
 131                                   raw_menu_item->desc_len );
 132         }
 133
 134         /* Allocate space for parsed menu */
 135         *menu = zalloc ( sizeof ( **menu ) +
 136                          ( num_menu_items * sizeof ( (*menu)->items[0] ) ) +
 137                          raw_menu_len + 1 /* NUL */ );
 138         if ( ! *menu ) {
 139                 DBG ( "Could not allocate PXE boot menu\n" );
 140                 return -ENOMEM;
 141         }
 142
 143         /* Fill in parsed menu */
 144         (*menu)->server = server;
 145         (*menu)->timeout =
 146                 ( ( prompt.timeout == 0xff ) ? -1 : prompt.timeout );
 147         (*menu)->num_items = num_menu_items;
 148         raw_menu_item = ( ( ( void * ) (*menu) ) + sizeof ( **menu ) +
 149                           ( num_menu_items * sizeof ( (*menu)->items[0] ) ) );
 150         memcpy ( raw_menu_item, raw_menu, raw_menu_len );
 151         for ( i = 0 ; i < num_menu_items ; i++ ) {
 152                 (*menu)->items[i].type = ntohs ( raw_menu_item->type );
 153                 (*menu)->items[i].desc = raw_menu_item->desc;
 154                 /* Set type to 0; this ensures that the description
 155                  * for the previous menu item is NUL-terminated.
 156                  * (Final item is NUL-terminated anyway.)
 157                  */
 158                 raw_menu_item->type = 0;
 159                 raw_menu_item = ( ( ( void * ) raw_menu_item ) +
 160                                   sizeof ( *raw_menu_item ) +
 161                                   raw_menu_item->desc_len );
 162         }
 163
 164         return 0;
 165 }
 166
 167 /**
 168  * Draw PXE boot menu item
 169  *
 170  * @v menu              PXE boot menu
 171  * @v index             Index of item to draw
 172  */
 173 static void pxe_menu_draw_item ( struct pxe_menu *menu,
 174                                  unsigned int index ) {
 175         int selected = ( menu->selection == index );
 176         char buf[COLS+1];
 177         char *tmp = buf;
 178         ssize_t remaining = sizeof ( buf );
 179         size_t len;
 180         unsigned int row;
 181
 182         /* Prepare space-padded row content */
 183         len = ssnprintf ( tmp, remaining, " %c. %s",
 184                           ( 'A' + index ), menu->items[index].desc );
 185         tmp += len;
 186         remaining -= len;
 187         if ( selected && ( menu->timeout > 0 ) ) {
 188                 len = ssnprintf ( tmp, remaining, " (%d)", menu->timeout );
 189                 tmp += len;
 190                 remaining -= len;
 191         }
 192         for ( ; remaining > 1 ; tmp++, remaining-- )
 193                 *tmp = ' ';
 194         *tmp = '\0';
 195
 196         /* Draw row */
 197         row = ( LINES - menu->num_items + index );
 198         color_set ( ( selected ? CPAIR_SELECT : CPAIR_NORMAL ), NULL );
 199         mvprintw ( row, 0, "%s", buf );
 200         move ( row, 1 );
 201 }
 202
 203 /**
 204  * Make selection from PXE boot menu
 205  *
 206  * @v menu              PXE boot menu
 207  * @ret rc              Return status code
 208  */
 209 int pxe_menu_select ( struct pxe_menu *menu ) {
 210         unsigned long start = currticks();
 211         unsigned long now;
 212         unsigned long elapsed;
 213         unsigned int old_selection;
 214         int key;
 215         unsigned int key_selection;
 216         unsigned int i;
 217         int rc = 0;
 218
 219         /* Initialise UI */
 220         initscr();
 221         start_color();
 222         init_pair ( CPAIR_NORMAL, COLOR_WHITE, COLOR_BLACK );
 223         init_pair ( CPAIR_SELECT, COLOR_BLACK, COLOR_WHITE );
 224         color_set ( CPAIR_NORMAL, NULL );
 225
 226         /* Draw initial menu */
 227         for ( i = 0 ; i < menu->num_items ; i++ )
 228                 printf ( "\n" );
 229         for ( i = 0 ; i < menu->num_items ; i++ )
 230                 pxe_menu_draw_item ( menu, ( menu->num_items - i - 1 ) );
 231
 232         while ( 1 ) {
 233
 234                 /* Decrease timeout if necessary */
 235                 if ( menu->timeout > 0 ) {
 236                         now = currticks();
 237                         elapsed = ( now - start );
 238                         if ( elapsed >= TICKS_PER_SEC ) {
 239                                 start = now;
 240                                 menu->timeout--;
 241                                 pxe_menu_draw_item ( menu, menu->selection );
 242                         }
 243                 }
 244
 245                 /* Select current item if we have timed out */
 246                 if ( menu->timeout == 0 )
 247                         break;
 248
 249                 /* Check for keyboard input */
 250                 if ( ! iskey() )
 251                         continue;
 252                 key = getkey();
 253
 254                 /* Any keyboard input cancels the timeout */
 255                 menu->timeout = -1;
 256                 pxe_menu_draw_item ( menu, menu->selection );
 257
 258                 /* Act upon key */
 259                 old_selection = menu->selection;
 260                 if ( ( key == CR ) || ( key == LF ) ) {
 261                         break;
 262                 } else if ( key == CTRL_C ) {
 263                         rc = -ECANCELED;
 264                         break;
 265                 } else if ( key == KEY_UP ) {
 266                         if ( menu->selection > 0 )
 267                                 menu->selection--;
 268                 } else if ( key == KEY_DOWN ) {
 269                         if ( menu->selection < ( menu->num_items - 1 ) )
 270                                 menu->selection++;
 271                 } else if ( ( key < KEY_MIN ) &&
 272                             ( ( key_selection = ( toupper ( key ) - 'A' ) )
 273                               < menu->num_items ) ) {
 274                         menu->selection = key_selection;
 275                         menu->timeout = 0;
 276                 }
 277                 pxe_menu_draw_item ( menu, old_selection );
 278                 pxe_menu_draw_item ( menu, menu->selection );
 279         }
 280
 281         /* Shut down UI */
 282         endwin();
 283
 284         return rc;
 285 }
 286
 287 /**
 288  * Boot using PXE boot menu
 289  *
 290  * @ret rc              Return status code
 291  *
 292  * Note that a success return status indicates that a PXE boot menu
 293  * item has been selected, and that the DHCP session should perform a
 294  * boot server request/ack.
 295  */
 296 int pxe_menu_boot ( struct net_device *netdev ) {
 297         struct pxe_menu *menu;
 298         struct in_addr pxe_server;
 299         unsigned int pxe_type;
 300         struct settings *pxebs_settings;
 301         struct in_addr next_server;
 302         char filename[256];
 303         int rc;
 304
 305         /* Parse and allocate boot menu */
 306         if ( ( rc = pxe_menu_parse ( &menu ) ) != 0 )
 307                 return rc;
 308
 309         /* Make selection from boot menu */
 310         if ( ( rc = pxe_menu_select ( menu ) ) != 0 ) {
 311                 free ( menu );
 312                 return rc;
 313         }
 314         pxe_server = menu->server;
 315         pxe_type = menu->items[menu->selection].type;
 316
 317         /* Free boot menu */
 318         free ( menu );
 319
 320         /* Return immediately if local boot selected */
 321         if ( ! pxe_type )
 322                 return 0;
 323
 324         /* Attempt PXE Boot Server Discovery */
 325         if ( ( rc = pxebs ( netdev, pxe_server, pxe_type ) ) != 0 )
 326                 return rc;
 327
 328         /* Attempt boot */
 329         pxebs_settings = find_settings ( PXEBS_SETTINGS_NAME );
 330         assert ( pxebs_settings );
 331         fetch_ipv4_setting ( pxebs_settings, &next_server_setting,
 332                              &next_server );
 333         fetch_string_setting ( pxebs_settings, &filename_setting,
 334                                filename, sizeof ( filename ) );
 335         return boot_next_server_and_filename ( next_server, filename );
 336 }