[pxe] Fall back to broadcast if no boot server multicast address exists
[people/mcb30/gpxe.git] / 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 }