Do not fill in the BufferLimit field in struct
[people/dverkamp/gpxe.git] / src / interface / pxe / pxe_preboot.c
1 /** @file
2  *
3  * PXE Preboot API
4  *
5  */
6
7 /* PXE API interface for Etherboot.
8  *
9  * Copyright (C) 2004 Michael Brown <mbrown@fensystems.co.uk>.
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License as
13  * published by the Free Software Foundation; either version 2 of the
14  * License, or any later version.
15  *
16  * This program is distributed in the hope that it will be useful, but
17  * WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24  */
25
26 #include <stdint.h>
27 #include <string.h>
28 #include <stdlib.h>
29 #include <gpxe/uaccess.h>
30 #include <gpxe/dhcp.h>
31 #include <gpxe/device.h>
32 #include <gpxe/netdevice.h>
33 #include <gpxe/isapnp.h>
34 #include <gpxe/init.h>
35 #include <basemem_packet.h>
36 #include "pxe.h"
37 #include "pxe_call.h"
38
39 /** Filename used for last TFTP request
40  *
41  * This is a bug-for-bug compatibility hack needed in order to work
42  * with Microsoft Remote Installation Services (RIS).  The filename
43  * used in a call to PXENV_RESTART_TFTP must be returned as the DHCP
44  * filename in subsequent calls to PXENV_GET_CACHED_INFO.
45  */
46 static char *pxe_ris_filename = NULL;
47
48 /* Avoid dragging in isapnp.o unnecessarily */
49 uint16_t isapnp_read_port;
50
51 /**
52  * UNLOAD BASE CODE STACK
53  *
54  * @v None                              -
55  * @ret ...
56  *
57  */
58 PXENV_EXIT_t pxenv_unload_stack ( struct s_PXENV_UNLOAD_STACK *unload_stack ) {
59         DBG ( "PXENV_UNLOAD_STACK" );
60
61         unload_stack->Status = PXENV_STATUS_SUCCESS;
62         return PXENV_EXIT_SUCCESS;
63 }
64
65 /* PXENV_GET_CACHED_INFO
66  *
67  * Status: working
68  */
69 PXENV_EXIT_t pxenv_get_cached_info ( struct s_PXENV_GET_CACHED_INFO
70                                      *get_cached_info ) {
71         struct dhcp_packet dhcppkt;
72         int ( * dhcp_packet_creator ) ( struct net_device *, int,
73                                         struct dhcp_option_block *, void *,
74                                         size_t, struct dhcp_packet * );
75         unsigned int msgtype;
76         void *data = NULL;
77         size_t len;
78         userptr_t buffer;
79         int rc;
80
81         DBG ( "PXENV_GET_CACHED_INFO %d", get_cached_info->PacketType );
82
83         DBG ( " to %04x:%04x+%x", get_cached_info->Buffer.segment,
84               get_cached_info->Buffer.offset, get_cached_info->BufferSize );
85
86         /* The case in which the caller doesn't supply a buffer is
87          * really awkward to support given that we have multiple
88          * sources of options, and that we don't actually store the
89          * DHCP packets.  (We may not even have performed DHCP; we may
90          * have obtained all configuration from non-volatile stored
91          * options or from the command line.)  We provide the caller
92          * with our base-memory temporary packet buffer and construct
93          * the packet in there.
94          *
95          * To add to the fun, Intel decided at some point in the
96          * evolution of the PXE specification to add the BufferLimit
97          * field, which we are meant to fill in with the length of our
98          * packet buffer, so that the caller can safely modify the
99          * boot server reply packet stored therein.  However, this
100          * field was not present in earlier versions of the PXE spec,
101          * and there is at least one PXE NBP (Altiris) which allocates
102          * only exactly enough space for this earlier, shorter version
103          * of the structure.  If we actually fill in the BufferLimit
104          * field, we therefore risk trashing random areas of the
105          * caller's memory.  If we *don't* fill it in, then the caller
106          * is at liberty to assume that whatever random value happened
107          * to be in that location represents the length of the buffer
108          * we've just passed back to it.
109          *
110          * Since older PXE stacks won't fill this field in anyway,
111          * it's probably safe to assume that no callers actually rely
112          * on it, so we choose to not fill it in.
113          */
114         len = get_cached_info->BufferSize;
115         if ( len == 0 ) {
116                 len = sizeof ( basemem_packet );
117                 get_cached_info->Buffer.segment = rm_ds;
118                 get_cached_info->Buffer.offset =
119                         ( unsigned int ) ( & __from_data16 ( basemem_packet ) );
120                 DBG ( " using %04x:%04x+'%x'", get_cached_info->Buffer.segment,
121                       get_cached_info->Buffer.offset,
122                       get_cached_info->BufferLimit );
123         }
124
125         /* Allocate space for temporary copy */
126         data = malloc ( len );
127         if ( ! data ) {
128                 DBG ( " out of memory" );
129                 goto err;
130         }
131
132         /* Construct DHCP packet */
133         if ( get_cached_info->PacketType == PXENV_PACKET_TYPE_DHCP_DISCOVER ) {
134                 dhcp_packet_creator = create_dhcp_request;
135                 msgtype = DHCPDISCOVER;
136         } else {
137                 dhcp_packet_creator = create_dhcp_response;
138                 msgtype = DHCPACK;
139         }
140         if ( ( rc = dhcp_packet_creator ( pxe_netdev, msgtype, NULL,
141                                           data, len, &dhcppkt ) ) != 0 ) {
142                 DBG ( " failed to build packet" );
143                 goto err;
144         }
145
146         /* Overwrite filename to work around Microsoft RIS bug */
147         if ( pxe_ris_filename ) {
148                 DBG ( " applying RIS hack" );
149                 strncpy ( dhcppkt.dhcphdr->file, pxe_ris_filename,
150                           sizeof ( dhcppkt.dhcphdr->file ) );
151         }
152
153         /* Copy packet to client buffer */
154         buffer = real_to_user ( get_cached_info->Buffer.segment,
155                                 get_cached_info->Buffer.offset );
156         len = dhcppkt.len;
157         DBG ( " length %x", len );
158         copy_to_user ( buffer, 0, data, len );
159         get_cached_info->BufferSize = len;
160
161         free ( data );
162         get_cached_info->Status = PXENV_STATUS_SUCCESS;
163         return PXENV_EXIT_SUCCESS;
164
165  err:
166         if ( data )
167                 free ( data );
168         get_cached_info->Status = PXENV_STATUS_OUT_OF_RESOURCES;
169         return PXENV_EXIT_FAILURE;
170 }
171
172 /* PXENV_RESTART_TFTP
173  *
174  * Status: working
175  */
176 PXENV_EXIT_t pxenv_restart_tftp ( struct s_PXENV_TFTP_READ_FILE
177                                   *restart_tftp ) {
178         PXENV_EXIT_t tftp_exit;
179
180         DBG ( "PXENV_RESTART_TFTP " );
181
182         /* Work around Microsoft RIS bug */
183         free ( pxe_ris_filename );
184         pxe_ris_filename = strdup ( ( char * ) restart_tftp->FileName );
185         if ( ! pxe_ris_filename ) {
186                 restart_tftp->Status = PXENV_STATUS_OUT_OF_RESOURCES;
187                 return PXENV_EXIT_FAILURE;
188         }
189
190         /* Words cannot describe the complete mismatch between the PXE
191          * specification and any possible version of reality...
192          */
193         restart_tftp->Buffer = PXE_LOAD_PHYS; /* Fixed by spec, apparently */
194         restart_tftp->BufferSize = ( 0xa0000 - PXE_LOAD_PHYS ); /* Near enough */
195         tftp_exit = pxenv_tftp_read_file ( restart_tftp );
196         if ( tftp_exit != PXENV_EXIT_SUCCESS )
197                 return tftp_exit;
198
199         /* Fire up the new NBP */
200         restart_tftp->Status = pxe_start_nbp();
201
202         /* Not sure what "SUCCESS" actually means, since we can only
203          * return if the new NBP failed to boot...
204          */
205         return PXENV_EXIT_SUCCESS;
206 }
207
208 /* PXENV_START_UNDI
209  *
210  * Status: working
211  */
212 PXENV_EXIT_t pxenv_start_undi ( struct s_PXENV_START_UNDI *start_undi ) {
213         unsigned int bus_type;
214         unsigned int location;
215         struct net_device *netdev;
216
217         DBG ( "PXENV_START_UNDI %04x:%04x:%04x",
218               start_undi->AX, start_undi->BX, start_undi->DX );
219
220         /* Determine bus type and location.  Use a heuristic to decide
221          * whether we are PCI or ISAPnP
222          */
223         if ( ( start_undi->DX >= ISAPNP_READ_PORT_MIN ) &&
224              ( start_undi->DX <= ISAPNP_READ_PORT_MAX ) &&
225              ( start_undi->BX >= ISAPNP_CSN_MIN ) &&
226              ( start_undi->BX <= ISAPNP_CSN_MAX ) ) {
227                 bus_type = BUS_TYPE_ISAPNP;
228                 location = start_undi->BX;
229                 /* Record ISAPnP read port for use by isapnp.c */
230                 isapnp_read_port = start_undi->DX;
231         } else {
232                 bus_type = BUS_TYPE_PCI;
233                 location = start_undi->AX;
234         }
235
236         /* Probe for devices, etc. */
237         startup();
238
239         /* Look for a matching net device */
240         netdev = find_netdev_by_location ( bus_type, location );
241         if ( ! netdev ) {
242                 DBG ( " no net device found" );
243                 start_undi->Status = PXENV_STATUS_UNDI_CANNOT_INITIALIZE_NIC;
244                 return PXENV_EXIT_FAILURE;
245         }
246         DBG ( " using netdev %s", netdev->name );
247
248         /* Save as PXE net device */
249         pxe_set_netdev ( netdev );
250
251         /* Hook INT 1A */
252         pxe_hook_int1a();
253
254         start_undi->Status = PXENV_STATUS_SUCCESS;
255         return PXENV_EXIT_SUCCESS;
256 }
257
258 /* PXENV_STOP_UNDI
259  *
260  * Status: working
261  */
262 PXENV_EXIT_t pxenv_stop_undi ( struct s_PXENV_STOP_UNDI *stop_undi ) {
263         DBG ( "PXENV_STOP_UNDI" );
264
265         /* Unhook INT 1A */
266         pxe_unhook_int1a();
267
268         /* Clear PXE net device */
269         pxe_set_netdev ( NULL );
270
271         /* Prepare for unload */
272         shutdown();
273
274         stop_undi->Status = PXENV_STATUS_SUCCESS;
275         return PXENV_EXIT_SUCCESS;
276 }
277
278 /* PXENV_START_BASE
279  *
280  * Status: won't implement (requires major structural changes)
281  */
282 PXENV_EXIT_t pxenv_start_base ( struct s_PXENV_START_BASE *start_base ) {
283         DBG ( "PXENV_START_BASE" );
284
285         start_base->Status = PXENV_STATUS_UNSUPPORTED;
286         return PXENV_EXIT_FAILURE;
287 }
288
289 /* PXENV_STOP_BASE
290  *
291  * Status: working
292  */
293 PXENV_EXIT_t pxenv_stop_base ( struct s_PXENV_STOP_BASE *stop_base ) {
294         DBG ( "PXENV_STOP_BASE" );
295
296         /* The only time we will be called is when the NBP is trying
297          * to shut down the PXE stack.  There's nothing we need to do
298          * in this call.
299          */
300
301         stop_base->Status = PXENV_STATUS_SUCCESS;
302         return PXENV_EXIT_SUCCESS;
303 }