[pxe] Add extra debug messages to the PXE UDP API calls
[people/balajirrao/gpxe.git] / src / interface / pxe / pxe_udp.c
1 /** @file
2  *
3  * PXE UDP API
4  *
5  */
6
7 #include <string.h>
8 #include <byteswap.h>
9 #include <gpxe/xfer.h>
10 #include <gpxe/udp.h>
11 #include <gpxe/uaccess.h>
12 #include <gpxe/process.h>
13 #include <pxe.h>
14
15 /*
16  * Copyright (C) 2004 Michael Brown <mbrown@fensystems.co.uk>.
17  *
18  * This program is free software; you can redistribute it and/or
19  * modify it under the terms of the GNU General Public License as
20  * published by the Free Software Foundation; either version 2 of the
21  * License, or any later version.
22  *
23  * This program is distributed in the hope that it will be useful, but
24  * WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
26  * General Public License for more details.
27  *
28  * You should have received a copy of the GNU General Public License
29  * along with this program; if not, write to the Free Software
30  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31  */
32
33 /** A PXE UDP connection */
34 struct pxe_udp_connection {
35         /** Data transfer interface to UDP stack */
36         struct xfer_interface xfer;
37         /** Local address */
38         struct sockaddr_in local;
39         /** Current PXENV_UDP_READ parameter block */
40         struct s_PXENV_UDP_READ *pxenv_udp_read;
41 };
42
43 /**
44  * Receive PXE UDP data
45  *
46  * @v xfer                      Data transfer interface
47  * @v iobuf                     I/O buffer
48  * @v meta                      Data transfer metadata
49  * @ret rc                      Return status code
50  *
51  * Receives a packet as part of the current pxenv_udp_read()
52  * operation.
53  */
54 static int pxe_udp_deliver_iob ( struct xfer_interface *xfer,
55                                  struct io_buffer *iobuf,
56                                  struct xfer_metadata *meta ) {
57         struct pxe_udp_connection *pxe_udp = 
58                 container_of ( xfer, struct pxe_udp_connection, xfer );
59         struct s_PXENV_UDP_READ *pxenv_udp_read = pxe_udp->pxenv_udp_read;
60         struct sockaddr_in *sin_src;
61         struct sockaddr_in *sin_dest;
62         userptr_t buffer;
63         size_t len;
64         int rc = 0;
65
66         if ( ! pxenv_udp_read ) {
67                 DBG ( "PXE discarded UDP packet\n" );
68                 rc = -ENOBUFS;
69                 goto done;
70         }
71
72         /* Copy packet to buffer and record length */
73         buffer = real_to_user ( pxenv_udp_read->buffer.segment,
74                                 pxenv_udp_read->buffer.offset );
75         len = iob_len ( iobuf );
76         if ( len > pxenv_udp_read->buffer_size )
77                 len = pxenv_udp_read->buffer_size;
78         copy_to_user ( buffer, 0, iobuf->data, len );
79         pxenv_udp_read->buffer_size = len;
80
81         /* Fill in source/dest information */
82         assert ( meta );
83         sin_src = ( struct sockaddr_in * ) meta->src;
84         assert ( sin_src );
85         assert ( sin_src->sin_family == AF_INET );
86         pxenv_udp_read->src_ip = sin_src->sin_addr.s_addr;
87         pxenv_udp_read->s_port = sin_src->sin_port;
88         sin_dest = ( struct sockaddr_in * ) meta->dest;
89         assert ( sin_dest );
90         assert ( sin_dest->sin_family == AF_INET );
91         pxenv_udp_read->dest_ip = sin_dest->sin_addr.s_addr;
92         pxenv_udp_read->d_port = sin_dest->sin_port;
93
94         /* Mark as received */
95         pxe_udp->pxenv_udp_read = NULL;
96
97  done:
98         free_iob ( iobuf );
99         return rc;
100 }
101
102 /** PXE UDP data transfer interface operations */
103 static struct xfer_interface_operations pxe_udp_xfer_operations = {
104         .close          = ignore_xfer_close,
105         .vredirect      = ignore_xfer_vredirect,
106         .window         = unlimited_xfer_window,
107         .alloc_iob      = default_xfer_alloc_iob,
108         .deliver_iob    = pxe_udp_deliver_iob,
109         .deliver_raw    = xfer_deliver_as_iob,
110 };
111
112 /** The PXE UDP connection */
113 static struct pxe_udp_connection pxe_udp = {
114         .xfer = XFER_INIT ( &pxe_udp_xfer_operations ),
115         .local = {
116                 .sin_family = AF_INET,
117         },
118 };
119
120 /**
121  * UDP OPEN
122  *
123  * @v pxenv_udp_open                    Pointer to a struct s_PXENV_UDP_OPEN
124  * @v s_PXENV_UDP_OPEN::src_ip          IP address of this station, or 0.0.0.0
125  * @ret #PXENV_EXIT_SUCCESS             Always
126  * @ret s_PXENV_UDP_OPEN::Status        PXE status code
127  * @err #PXENV_STATUS_UDP_OPEN          UDP connection already open
128  * @err #PXENV_STATUS_OUT_OF_RESOURCES  Could not open connection
129  *
130  * Prepares the PXE stack for communication using pxenv_udp_write()
131  * and pxenv_udp_read().
132  *
133  * The IP address supplied in s_PXENV_UDP_OPEN::src_ip will be
134  * recorded and used as the local station's IP address for all further
135  * communication, including communication by means other than
136  * pxenv_udp_write() and pxenv_udp_read().  (If
137  * s_PXENV_UDP_OPEN::src_ip is 0.0.0.0, the local station's IP address
138  * will remain unchanged.)
139  *
140  * You can only have one open UDP connection at a time.  This is not a
141  * meaningful restriction, since pxenv_udp_write() and
142  * pxenv_udp_read() allow you to specify arbitrary local and remote
143  * ports and an arbitrary remote address for each packet.  According
144  * to the PXE specifiation, you cannot have a UDP connection open at
145  * the same time as a TFTP connection; this restriction does not apply
146  * to Etherboot.
147  *
148  * On x86, you must set the s_PXE::StatusCallout field to a nonzero
149  * value before calling this function in protected mode.  You cannot
150  * call this function with a 32-bit stack segment.  (See the relevant
151  * @ref pxe_x86_pmode16 "implementation note" for more details.)
152  *
153  * @note The PXE specification does not make it clear whether the IP
154  * address supplied in s_PXENV_UDP_OPEN::src_ip should be used only
155  * for this UDP connection, or retained for all future communication.
156  * The latter seems more consistent with typical PXE stack behaviour.
157  *
158  * @note Etherboot currently ignores the s_PXENV_UDP_OPEN::src_ip
159  * parameter.
160  *
161  */
162 PXENV_EXIT_t pxenv_udp_open ( struct s_PXENV_UDP_OPEN *pxenv_udp_open ) {
163         int rc;
164
165         DBG ( "PXENV_UDP_OPEN" );
166
167         /* Record source IP address */
168         pxe_udp.local.sin_addr.s_addr = pxenv_udp_open->src_ip;
169         DBG ( " %s", inet_ntoa ( pxe_udp.local.sin_addr ) );
170
171         /* Open promiscuous UDP connection */
172         xfer_close ( &pxe_udp.xfer, 0 );
173         if ( ( rc = udp_open_promisc ( &pxe_udp.xfer ) ) != 0 ) {
174                 pxenv_udp_open->Status = PXENV_STATUS ( rc );
175                 return PXENV_EXIT_FAILURE;
176         }
177
178         pxenv_udp_open->Status = PXENV_STATUS_SUCCESS;
179         return PXENV_EXIT_SUCCESS;
180 }
181
182 /**
183  * UDP CLOSE
184  *
185  * @v pxenv_udp_close                   Pointer to a struct s_PXENV_UDP_CLOSE
186  * @ret #PXENV_EXIT_SUCCESS             Always
187  * @ret s_PXENV_UDP_CLOSE::Status       PXE status code
188  * @err None                            -
189  *
190  * Closes a UDP connection opened with pxenv_udp_open().
191  *
192  * You can only have one open UDP connection at a time.  You cannot
193  * have a UDP connection open at the same time as a TFTP connection.
194  * You cannot use pxenv_udp_close() to close a TFTP connection; use
195  * pxenv_tftp_close() instead.
196  *
197  * On x86, you must set the s_PXE::StatusCallout field to a nonzero
198  * value before calling this function in protected mode.  You cannot
199  * call this function with a 32-bit stack segment.  (See the relevant
200  * @ref pxe_x86_pmode16 "implementation note" for more details.)
201  *
202  */
203 PXENV_EXIT_t pxenv_udp_close ( struct s_PXENV_UDP_CLOSE *pxenv_udp_close ) {
204         DBG ( "PXENV_UDP_CLOSE" );
205
206         /* Close UDP connection */
207         xfer_close ( &pxe_udp.xfer, 0 );
208
209         pxenv_udp_close->Status = PXENV_STATUS_SUCCESS;
210         return PXENV_EXIT_SUCCESS;
211 }
212
213 /**
214  * UDP WRITE
215  *
216  * @v pxenv_udp_write                   Pointer to a struct s_PXENV_UDP_WRITE
217  * @v s_PXENV_UDP_WRITE::ip             Destination IP address
218  * @v s_PXENV_UDP_WRITE::gw             Relay agent IP address, or 0.0.0.0
219  * @v s_PXENV_UDP_WRITE::src_port       Source UDP port, or 0
220  * @v s_PXENV_UDP_WRITE::dst_port       Destination UDP port
221  * @v s_PXENV_UDP_WRITE::buffer_size    Length of the UDP payload
222  * @v s_PXENV_UDP_WRITE::buffer         Address of the UDP payload
223  * @ret #PXENV_EXIT_SUCCESS             Packet was transmitted successfully
224  * @ret #PXENV_EXIT_FAILURE             Packet could not be transmitted
225  * @ret s_PXENV_UDP_WRITE::Status       PXE status code
226  * @err #PXENV_STATUS_UDP_CLOSED        UDP connection is not open
227  * @err #PXENV_STATUS_UNDI_TRANSMIT_ERROR Could not transmit packet
228  *
229  * Transmits a single UDP packet.  A valid IP and UDP header will be
230  * prepended to the payload in s_PXENV_UDP_WRITE::buffer; the buffer
231  * should not contain precomputed IP and UDP headers, nor should it
232  * contain space allocated for these headers.  The first byte of the
233  * buffer will be transmitted as the first byte following the UDP
234  * header.
235  *
236  * If s_PXENV_UDP_WRITE::gw is 0.0.0.0, normal IP routing will take
237  * place.  See the relevant @ref pxe_routing "implementation note" for
238  * more details.
239  *
240  * If s_PXENV_UDP_WRITE::src_port is 0, port 2069 will be used.
241  *
242  * You must have opened a UDP connection with pxenv_udp_open() before
243  * calling pxenv_udp_write().
244  *
245  * On x86, you must set the s_PXE::StatusCallout field to a nonzero
246  * value before calling this function in protected mode.  You cannot
247  * call this function with a 32-bit stack segment.  (See the relevant
248  * @ref pxe_x86_pmode16 "implementation note" for more details.)
249  *
250  * @note Etherboot currently ignores the s_PXENV_UDP_WRITE::gw
251  * parameter.
252  *
253  */
254 PXENV_EXIT_t pxenv_udp_write ( struct s_PXENV_UDP_WRITE *pxenv_udp_write ) {
255         struct sockaddr_in dest;
256         struct xfer_metadata meta = {
257                 .src = ( struct sockaddr * ) &pxe_udp.local,
258                 .dest = ( struct sockaddr * ) &dest,
259                 .netdev = pxe_netdev,
260         };
261         size_t len;
262         struct io_buffer *iobuf;
263         userptr_t buffer;
264         int rc;
265
266         DBG ( "PXENV_UDP_WRITE" );
267
268         /* Construct destination socket address */
269         memset ( &dest, 0, sizeof ( dest ) );
270         dest.sin_family = AF_INET;
271         dest.sin_addr.s_addr = pxenv_udp_write->ip;
272         dest.sin_port = pxenv_udp_write->dst_port;
273
274         /* Set local (source) port.  PXE spec says source port is 2069
275          * if not specified.  Really, this ought to be set at UDP open
276          * time but hey, we didn't design this API.
277          */
278         pxe_udp.local.sin_port = pxenv_udp_write->src_port;
279         if ( ! pxe_udp.local.sin_port )
280                 pxe_udp.local.sin_port = htons ( 2069 );
281
282         /* FIXME: we ignore the gateway specified, since we're
283          * confident of being able to do our own routing.  We should
284          * probably allow for multiple gateways.
285          */
286
287         /* Allocate and fill data buffer */
288         len = pxenv_udp_write->buffer_size;
289         iobuf = xfer_alloc_iob ( &pxe_udp.xfer, len );
290         if ( ! iobuf ) {
291                 pxenv_udp_write->Status = PXENV_STATUS_OUT_OF_RESOURCES;
292                 return PXENV_EXIT_FAILURE;
293         }
294         buffer = real_to_user ( pxenv_udp_write->buffer.segment,
295                                 pxenv_udp_write->buffer.offset );
296         copy_from_user ( iob_put ( iobuf, len ), buffer, 0, len );
297
298         DBG ( " %04x:%04x+%x %d->%s:%d", pxenv_udp_write->buffer.segment,
299               pxenv_udp_write->buffer.offset, pxenv_udp_write->buffer_size,
300               ntohs ( pxenv_udp_write->src_port ),
301               inet_ntoa ( dest.sin_addr ),
302               ntohs ( pxenv_udp_write->dst_port ) );
303         
304         /* Transmit packet */
305         if ( ( rc = xfer_deliver_iob_meta ( &pxe_udp.xfer, iobuf,
306                                             &meta ) ) != 0 ) {
307                 pxenv_udp_write->Status = PXENV_STATUS ( rc );
308                 return PXENV_EXIT_FAILURE;
309         }
310
311         pxenv_udp_write->Status = PXENV_STATUS_SUCCESS;
312         return PXENV_EXIT_SUCCESS;
313 }
314
315 /**
316  * UDP READ
317  *
318  * @v pxenv_udp_read                    Pointer to a struct s_PXENV_UDP_READ
319  * @v s_PXENV_UDP_READ::dest_ip         Destination IP address, or 0.0.0.0
320  * @v s_PXENV_UDP_READ::d_port          Destination UDP port, or 0
321  * @v s_PXENV_UDP_READ::buffer_size     Size of the UDP payload buffer
322  * @v s_PXENV_UDP_READ::buffer          Address of the UDP payload buffer
323  * @ret #PXENV_EXIT_SUCCESS             A packet has been received
324  * @ret #PXENV_EXIT_FAILURE             No packet has been received
325  * @ret s_PXENV_UDP_READ::Status        PXE status code
326  * @ret s_PXENV_UDP_READ::src_ip        Source IP address
327  * @ret s_PXENV_UDP_READ::dest_ip       Destination IP address
328  * @ret s_PXENV_UDP_READ::s_port        Source UDP port
329  * @ret s_PXENV_UDP_READ::d_port        Destination UDP port
330  * @ret s_PXENV_UDP_READ::buffer_size   Length of UDP payload
331  * @err #PXENV_STATUS_UDP_CLOSED        UDP connection is not open
332  * @err #PXENV_STATUS_FAILURE           No packet was ready to read
333  *
334  * Receive a single UDP packet.  This is a non-blocking call; if no
335  * packet is ready to read, the call will return instantly with
336  * s_PXENV_UDP_READ::Status==PXENV_STATUS_FAILURE.
337  *
338  * If s_PXENV_UDP_READ::dest_ip is 0.0.0.0, UDP packets addressed to
339  * any IP address will be accepted and may be returned to the caller.
340  *
341  * If s_PXENV_UDP_READ::d_port is 0, UDP packets addressed to any UDP
342  * port will be accepted and may be returned to the caller.
343  *
344  * You must have opened a UDP connection with pxenv_udp_open() before
345  * calling pxenv_udp_read().
346  *
347  * On x86, you must set the s_PXE::StatusCallout field to a nonzero
348  * value before calling this function in protected mode.  You cannot
349  * call this function with a 32-bit stack segment.  (See the relevant
350  * @ref pxe_x86_pmode16 "implementation note" for more details.)
351  *
352  * @note The PXE specification (version 2.1) does not state that we
353  * should fill in s_PXENV_UDP_READ::dest_ip and
354  * s_PXENV_UDP_READ::d_port, but Microsoft Windows' NTLDR program
355  * expects us to do so, and will fail if we don't.
356  *
357  */
358 PXENV_EXIT_t pxenv_udp_read ( struct s_PXENV_UDP_READ *pxenv_udp_read ) {
359         struct in_addr dest_ip_wanted = { .s_addr = pxenv_udp_read->dest_ip };
360         struct in_addr dest_ip;
361         uint16_t d_port_wanted = pxenv_udp_read->d_port;
362         uint16_t d_port;
363
364         DBG ( "PXENV_UDP_READ" );
365
366         /* Try receiving a packet */
367         pxe_udp.pxenv_udp_read = pxenv_udp_read;
368         step();
369         if ( pxe_udp.pxenv_udp_read ) {
370                 /* No packet received */
371                 pxe_udp.pxenv_udp_read = NULL;
372                 goto no_packet;
373         }
374         dest_ip.s_addr = pxenv_udp_read->dest_ip;
375         d_port = pxenv_udp_read->d_port;
376
377         /* Filter on destination address and/or port */
378         if ( dest_ip_wanted.s_addr &&
379              ( dest_ip_wanted.s_addr != dest_ip.s_addr ) ) {
380                 DBG ( " wrong IP %s", inet_ntoa ( dest_ip ) );
381                 DBG ( " (wanted %s)", inet_ntoa ( dest_ip_wanted ) );
382                 goto no_packet;
383         }
384         if ( d_port_wanted && ( d_port_wanted != d_port ) ) {
385                 DBG ( " wrong port %d ", htons ( d_port ) );
386                 DBG ( " (wanted %d)", htons ( d_port_wanted ) );
387                 goto no_packet;
388         }
389
390         DBG ( " %04x:%04x+%x %s:", pxenv_udp_read->buffer.segment,
391               pxenv_udp_read->buffer.offset, pxenv_udp_read->buffer_size,
392               inet_ntoa ( *( ( struct in_addr * ) &pxenv_udp_read->src_ip ) ));
393         DBG ( "%d<-%s:%d",  ntohs ( pxenv_udp_read->s_port ),
394               inet_ntoa ( *( ( struct in_addr * ) &pxenv_udp_read->dest_ip ) ),
395               ntohs ( pxenv_udp_read->d_port ) );
396
397         pxenv_udp_read->Status = PXENV_STATUS_SUCCESS;
398         return PXENV_EXIT_SUCCESS;
399
400  no_packet:
401         pxenv_udp_read->Status = PXENV_STATUS_FAILURE;
402         return PXENV_EXIT_FAILURE;
403 }