3f5bfc88a474f4f092c3a4394f85eac5e7ee5ee9
[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         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 }