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         fetch_ipv4_setting ( NULL, &tmp_setting, &server );
  99         if ( ! server.s_addr )
 100                 server.s_addr = INADDR_BROADCAST;
 101         tmp_setting.tag = DHCP_PXE_BOOT_MENU_PROMPT;
 102         fetch_setting ( NULL, &tmp_setting, &prompt, sizeof ( prompt ) );
 103         tmp_setting.tag = DHCP_PXE_BOOT_MENU;
 104         memset ( raw_menu, 0, sizeof ( raw_menu ) );
 105         if ( ( raw_menu_len = fetch_setting ( NULL, &tmp_setting, raw_menu,
 106                                               sizeof ( raw_menu ) ) ) < 0 ) {
 107                 rc = raw_menu_len;
 108                 DBG ( "Could not retrieve raw PXE boot menu: %s\n",
 109                       strerror ( rc ) );
 110                 return rc;
 111         }
 112         if ( raw_menu_len >= ( int ) sizeof ( raw_menu ) ) {
 113                 DBG ( "Raw PXE boot menu too large for buffer\n" );
 114                 return -ENOSPC;
 115         }
 116         raw_menu_end = ( raw_menu + raw_menu_len );
 117
 118         /* Count menu items */
 119         num_menu_items = 0;
 120         raw_menu_item = ( ( void * ) raw_menu );
 121         while ( 1 ) {
 122                 if ( ( ( ( void * ) raw_menu_item ) +
 123                        sizeof ( *raw_menu_item ) ) > raw_menu_end )
 124                         break;
 125                 if ( ( ( ( void * ) raw_menu_item ) +
 126                        sizeof ( *raw_menu_item ) +
 127                        raw_menu_item->desc_len ) > raw_menu_end )
 128                         break;
 129                 num_menu_items++;
 130                 raw_menu_item = ( ( ( void * ) raw_menu_item ) +
 131                                   sizeof ( *raw_menu_item ) +
 132                                   raw_menu_item->desc_len );
 133         }
 134
 135         /* Allocate space for parsed menu */
 136         *menu = zalloc ( sizeof ( **menu ) +
 137                          ( num_menu_items * sizeof ( (*menu)->items[0] ) ) +
 138                          raw_menu_len + 1 /* NUL */ );
 139         if ( ! *menu ) {
 140                 DBG ( "Could not allocate PXE boot menu\n" );
 141                 return -ENOMEM;
 142         }
 143
 144         /* Fill in parsed menu */
 145         (*menu)->server = server;
 146         (*menu)->timeout =
 147                 ( ( prompt.timeout == 0xff ) ? -1 : prompt.timeout );
 148         (*menu)->num_items = num_menu_items;
 149         raw_menu_item = ( ( ( void * ) (*menu) ) + sizeof ( **menu ) +
 150                           ( num_menu_items * sizeof ( (*menu)->items[0] ) ) );
 151         memcpy ( raw_menu_item, raw_menu, raw_menu_len );
 152         for ( i = 0 ; i < num_menu_items ; i++ ) {
 153                 (*menu)->items[i].type = ntohs ( raw_menu_item->type );
 154                 (*menu)->items[i].desc = raw_menu_item->desc;
 155                 /* Set type to 0; this ensures that the description
 156                  * for the previous menu item is NUL-terminated.
 157                  * (Final item is NUL-terminated anyway.)
 158                  */
 159                 raw_menu_item->type = 0;
 160                 raw_menu_item = ( ( ( void * ) raw_menu_item ) +
 161                                   sizeof ( *raw_menu_item ) +
 162                                   raw_menu_item->desc_len );
 163         }
 164
 165         return 0;
 166 }
 167
 168 /**
 169  * Draw PXE boot menu item
 170  *
 171  * @v menu              PXE boot menu
 172  * @v index             Index of item to draw
 173  */
 174 static void pxe_menu_draw_item ( struct pxe_menu *menu,
 175                                  unsigned int index ) {
 176         int selected = ( menu->selection == index );
 177         char buf[COLS+1];
 178         char *tmp = buf;
 179         ssize_t remaining = sizeof ( buf );
 180         size_t len;
 181         unsigned int row;
 182
 183         /* Prepare space-padded row content */
 184         len = ssnprintf ( tmp, remaining, " %c. %s",
 185                           ( 'A' + index ), menu->items[index].desc );
 186         tmp += len;
 187         remaining -= len;
 188         if ( selected && ( menu->timeout > 0 ) ) {
 189                 len = ssnprintf ( tmp, remaining, " (%d)", menu->timeout );
 190                 tmp += len;
 191                 remaining -= len;
 192         }
 193         for ( ; remaining > 1 ; tmp++, remaining-- )
 194                 *tmp = ' ';
 195         *tmp = '\0';
 196
 197         /* Draw row */
 198         row = ( LINES - menu->num_items + index );
 199         color_set ( ( selected ? CPAIR_SELECT : CPAIR_NORMAL ), NULL );
 200         mvprintw ( row, 0, "%s", buf );
 201         move ( row, 1 );
 202 }
 203
 204 /**
 205  * Make selection from PXE boot menu
 206  *
 207  * @v menu              PXE boot menu
 208  * @ret rc              Return status code
 209  */
 210 int pxe_menu_select ( struct pxe_menu *menu ) {
 211         unsigned long start = currticks();
 212         unsigned long now;
 213         unsigned long elapsed;
 214         unsigned int old_selection;
 215         int key;
 216         unsigned int key_selection;
 217         unsigned int i;
 218         int rc = 0;
 219
 220         /* Initialise UI */
 221         initscr();
 222         start_color();
 223         init_pair ( CPAIR_NORMAL, COLOR_WHITE, COLOR_BLACK );
 224         init_pair ( CPAIR_SELECT, COLOR_BLACK, COLOR_WHITE );
 225         color_set ( CPAIR_NORMAL, NULL );
 226
 227         /* Draw initial menu */
 228         for ( i = 0 ; i < menu->num_items ; i++ )
 229                 printf ( "\n" );
 230         for ( i = 0 ; i < menu->num_items ; i++ )
 231                 pxe_menu_draw_item ( menu, ( menu->num_items - i - 1 ) );
 232
 233         while ( 1 ) {
 234
 235                 /* Decrease timeout if necessary */
 236                 if ( menu->timeout > 0 ) {
 237                         now = currticks();
 238                         elapsed = ( now - start );
 239                         if ( elapsed >= TICKS_PER_SEC ) {
 240                                 start = now;
 241                                 menu->timeout--;
 242                                 pxe_menu_draw_item ( menu, menu->selection );
 243                         }
 244                 }
 245
 246                 /* Select current item if we have timed out */
 247                 if ( menu->timeout == 0 )
 248                         break;
 249
 250                 /* Check for keyboard input */
 251                 if ( ! iskey() )
 252                         continue;
 253                 key = getkey();
 254
 255                 /* Any keyboard input cancels the timeout */
 256                 menu->timeout = -1;
 257                 pxe_menu_draw_item ( menu, menu->selection );
 258
 259                 /* Act upon key */
 260                 old_selection = menu->selection;
 261                 if ( ( key == CR ) || ( key == LF ) ) {
 262                         break;
 263                 } else if ( key == CTRL_C ) {
 264                         rc = -ECANCELED;
 265                         break;
 266                 } else if ( key == KEY_UP ) {
 267                         if ( menu->selection > 0 )
 268                                 menu->selection--;
 269                 } else if ( key == KEY_DOWN ) {
 270                         if ( menu->selection < ( menu->num_items - 1 ) )
 271                                 menu->selection++;
 272                 } else if ( ( key < KEY_MIN ) &&
 273                             ( ( key_selection = ( toupper ( key ) - 'A' ) )
 274                               < menu->num_items ) ) {
 275                         menu->selection = key_selection;
 276                         menu->timeout = 0;
 277                 }
 278                 pxe_menu_draw_item ( menu, old_selection );
 279                 pxe_menu_draw_item ( menu, menu->selection );
 280         }
 281
 282         /* Shut down UI */
 283         endwin();
 284
 285         return rc;
 286 }
 287
 288 /**
 289  * Boot using PXE boot menu
 290  *
 291  * @ret rc              Return status code
 292  *
 293  * Note that a success return status indicates that a PXE boot menu
 294  * item has been selected, and that the DHCP session should perform a
 295  * boot server request/ack.
 296  */
 297 int pxe_menu_boot ( struct net_device *netdev ) {
 298         struct pxe_menu *menu;
 299         struct in_addr pxe_server;
 300         unsigned int pxe_type;
 301         struct settings *pxebs_settings;
 302         struct in_addr next_server;
 303         char filename[256];
 304         int rc;
 305
 306         /* Parse and allocate boot menu */
 307         if ( ( rc = pxe_menu_parse ( &menu ) ) != 0 )
 308                 return rc;
 309
 310         /* Make selection from boot menu */
 311         if ( ( rc = pxe_menu_select ( menu ) ) != 0 ) {
 312                 free ( menu );
 313                 return rc;
 314         }
 315         pxe_server = menu->server;
 316         pxe_type = menu->items[menu->selection].type;
 317
 318         /* Free boot menu */
 319         free ( menu );
 320
 321         /* Return immediately if local boot selected */
 322         if ( ! pxe_type )
 323                 return 0;
 324
 325         /* Attempt PXE Boot Server Discovery */
 326         if ( ( rc = pxebs ( netdev, pxe_server, pxe_type ) ) != 0 )
 327                 return rc;
 328
 329         /* Attempt boot */
 330         pxebs_settings = find_settings ( PXEBS_SETTINGS_NAME );
 331         assert ( pxebs_settings );
 332         fetch_ipv4_setting ( pxebs_settings, &next_server_setting,
 333                              &next_server );
 334         fetch_string_setting ( pxebs_settings, &filename_setting,
 335                                filename, sizeof ( filename ) );
 336         return boot_next_server_and_filename ( next_server, filename );
 337 }