Use otherwise-useless byte in DHCP feature option as a version number
[people/xl0/gpxe.git] / src / net / tcp / http.c
1 /*
2  * Copyright (C) 2007 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 /**
20  * @file
21  *
22  * Hyper Text Transfer Protocol (HTTP)
23  *
24  */
25
26 #include <stdint.h>
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <strings.h>
31 #include <byteswap.h>
32 #include <errno.h>
33 #include <assert.h>
34 #include <gpxe/uri.h>
35 #include <gpxe/refcnt.h>
36 #include <gpxe/iobuf.h>
37 #include <gpxe/xfer.h>
38 #include <gpxe/open.h>
39 #include <gpxe/socket.h>
40 #include <gpxe/tcpip.h>
41 #include <gpxe/process.h>
42 #include <gpxe/linebuf.h>
43 #include <gpxe/features.h>
44 #include <gpxe/http.h>
45
46 FEATURE ( "HTTP", DHCP_EB_FEATURE_HTTP, 1 );
47
48 /** HTTP receive state */
49 enum http_rx_state {
50         HTTP_RX_RESPONSE = 0,
51         HTTP_RX_HEADER,
52         HTTP_RX_DATA,
53         HTTP_RX_DEAD,
54 };
55
56 /**
57  * An HTTP request
58  *
59  */
60 struct http_request {
61         /** Reference count */
62         struct refcnt refcnt;
63         /** Data transfer interface */
64         struct xfer_interface xfer;
65
66         /** URI being fetched */
67         struct uri *uri;
68         /** Transport layer interface */
69         struct xfer_interface socket;
70
71         /** TX process */
72         struct process process;
73
74         /** HTTP response code */
75         unsigned int response;
76         /** HTTP Content-Length */
77         size_t content_length;
78         /** Received length */
79         size_t rx_len;
80         /** RX state */
81         enum http_rx_state rx_state;
82         /** Line buffer for received header lines */
83         struct line_buffer linebuf;
84 };
85
86 /**
87  * Free HTTP request
88  *
89  * @v refcnt            Reference counter
90  */
91 static void http_free ( struct refcnt *refcnt ) {
92         struct http_request *http =
93                 container_of ( refcnt, struct http_request, refcnt );
94
95         uri_put ( http->uri );
96         empty_line_buffer ( &http->linebuf );
97         free ( http );
98 };
99
100 /**
101  * Mark HTTP request as complete
102  *
103  * @v http              HTTP request
104  * @v rc                Return status code
105  */
106 static void http_done ( struct http_request *http, int rc ) {
107
108         /* Prevent further processing of any current packet */
109         http->rx_state = HTTP_RX_DEAD;
110
111         /* If we had a Content-Length, and the received content length
112          * isn't correct, flag an error
113          */
114         if ( http->content_length &&
115              ( http->content_length != http->rx_len ) ) {
116                 DBGC ( http, "HTTP %p incorrect length %zd, should be %zd\n",
117                        http, http->rx_len, http->content_length );
118                 rc = -EIO;
119         }
120
121         /* Remove process */
122         process_del ( &http->process );
123
124         /* Close all data transfer interfaces */
125         xfer_nullify ( &http->socket );
126         xfer_close ( &http->socket, rc );
127         xfer_nullify ( &http->xfer );
128         xfer_close ( &http->xfer, rc );
129 }
130
131 /**
132  * Convert HTTP response code to return status code
133  *
134  * @v response          HTTP response code
135  * @ret rc              Return status code
136  */
137 static int http_response_to_rc ( unsigned int response ) {
138         switch ( response ) {
139         case 200:
140                 return 0;
141         case 404:
142                 return -ENOENT;
143         case 403:
144                 return -EPERM;
145         default:
146                 return -EIO;
147         }
148 }
149
150 /**
151  * Handle HTTP response
152  *
153  * @v http              HTTP request
154  * @v response          HTTP response
155  * @ret rc              Return status code
156  */
157 static int http_rx_response ( struct http_request *http, char *response ) {
158         char *spc;
159         int rc;
160
161         DBGC ( http, "HTTP %p response \"%s\"\n", http, response );
162
163         /* Check response starts with "HTTP/" */
164         if ( strncmp ( response, "HTTP/", 5 ) != 0 )
165                 return -EIO;
166
167         /* Locate and check response code */
168         spc = strchr ( response, ' ' );
169         if ( ! spc )
170                 return -EIO;
171         http->response = strtoul ( spc, NULL, 10 );
172         if ( ( rc = http_response_to_rc ( http->response ) ) != 0 )
173                 return rc;
174
175         /* Move to received headers */
176         http->rx_state = HTTP_RX_HEADER;
177         return 0;
178 }
179
180 /**
181  * Handle HTTP Content-Length header
182  *
183  * @v http              HTTP request
184  * @v value             HTTP header value
185  * @ret rc              Return status code
186  */
187 static int http_rx_content_length ( struct http_request *http,
188                                     const char *value ) {
189         char *endp;
190
191         http->content_length = strtoul ( value, &endp, 10 );
192         if ( *endp != '\0' ) {
193                 DBGC ( http, "HTTP %p invalid Content-Length \"%s\"\n",
194                        http, value );
195                 return -EIO;
196         }
197
198         /* Use seek() to notify recipient of filesize */
199         xfer_seek ( &http->xfer, http->content_length, SEEK_SET );
200         xfer_seek ( &http->xfer, 0, SEEK_SET );
201
202         return 0;
203 }
204
205 /** An HTTP header handler */
206 struct http_header_handler {
207         /** Name (e.g. "Content-Length") */
208         const char *header;
209         /** Handle received header
210          *
211          * @v http      HTTP request
212          * @v value     HTTP header value
213          * @ret rc      Return status code
214          *
215          * If an error is returned, the download will be aborted.
216          */
217         int ( * rx ) ( struct http_request *http, const char *value );
218 };
219
220 /** List of HTTP header handlers */
221 static struct http_header_handler http_header_handlers[] = {
222         {
223                 .header = "Content-Length",
224                 .rx = http_rx_content_length,
225         },
226         { NULL, NULL }
227 };
228
229 /**
230  * Handle HTTP header
231  *
232  * @v http              HTTP request
233  * @v header            HTTP header
234  * @ret rc              Return status code
235  */
236 static int http_rx_header ( struct http_request *http, char *header ) {
237         struct http_header_handler *handler;
238         char *separator;
239         char *value;
240         int rc;
241
242         /* An empty header line marks the transition to the data phase */
243         if ( ! header[0] ) {
244                 DBGC ( http, "HTTP %p start of data\n", http );
245                 empty_line_buffer ( &http->linebuf );
246                 http->rx_state = HTTP_RX_DATA;
247                 return 0;
248         }
249
250         DBGC ( http, "HTTP %p header \"%s\"\n", http, header );
251
252         /* Split header at the ": " */
253         separator = strstr ( header, ": " );
254         if ( ! separator ) {
255                 DBGC ( http, "HTTP %p malformed header\n", http );
256                 return -EIO;
257         }
258         *separator = '\0';
259         value = ( separator + 2 );
260
261         /* Hand off to header handler, if one exists */
262         for ( handler = http_header_handlers ; handler->header ; handler++ ) {
263                 if ( strcasecmp ( header, handler->header ) == 0 ) {
264                         if ( ( rc = handler->rx ( http, value ) ) != 0 )
265                                 return rc;
266                         break;
267                 }
268         }
269         return 0;
270 }
271
272 /** An HTTP line-based data handler */
273 struct http_line_handler {
274         /** Handle line
275          *
276          * @v http      HTTP request
277          * @v line      Line to handle
278          * @ret rc      Return status code
279          */
280         int ( * rx ) ( struct http_request *http, char *line );
281 };
282
283 /** List of HTTP line-based data handlers */
284 static struct http_line_handler http_line_handlers[] = {
285         [HTTP_RX_RESPONSE]      = { .rx = http_rx_response },
286         [HTTP_RX_HEADER]        = { .rx = http_rx_header },
287 };
288
289 /**
290  * Handle new data arriving via HTTP connection in the data phase
291  *
292  * @v http              HTTP request
293  * @v iobuf             I/O buffer
294  * @ret rc              Return status code
295  */
296 static int http_rx_data ( struct http_request *http,
297                           struct io_buffer *iobuf ) {
298         int rc;
299
300         /* Update received length */
301         http->rx_len += iob_len ( iobuf );
302
303         /* Hand off data buffer */
304         if ( ( rc = xfer_deliver_iob ( &http->xfer, iobuf ) ) != 0 )
305                 return rc;
306
307         /* If we have reached the content-length, stop now */
308         if ( http->content_length &&
309              ( http->rx_len >= http->content_length ) ) {
310                 http_done ( http, 0 );
311         }
312
313         return 0;
314 }
315
316 /**
317  * Handle new data arriving via HTTP connection
318  *
319  * @v socket            Transport layer interface
320  * @v iobuf             I/O buffer
321  * @v meta              Data transfer metadata, or NULL
322  * @ret rc              Return status code
323  */
324 static int http_socket_deliver_iob ( struct xfer_interface *socket,
325                                      struct io_buffer *iobuf,
326                                      struct xfer_metadata *meta __unused ) {
327         struct http_request *http =
328                 container_of ( socket, struct http_request, socket );
329         struct http_line_handler *lh;
330         char *line;
331         ssize_t len;
332         int rc = 0;
333
334         while ( iob_len ( iobuf ) ) {
335                 switch ( http->rx_state ) {
336                 case HTTP_RX_DEAD:
337                         /* Do no further processing */
338                         goto done;
339                 case HTTP_RX_DATA:
340                         /* Once we're into the data phase, just fill
341                          * the data buffer
342                          */
343                         rc = http_rx_data ( http, iobuf );
344                         iobuf = NULL;
345                         goto done;
346                 case HTTP_RX_RESPONSE:
347                 case HTTP_RX_HEADER:
348                         /* In the other phases, buffer and process a
349                          * line at a time
350                          */
351                         len = line_buffer ( &http->linebuf, iobuf->data,
352                                             iob_len ( iobuf ) );
353                         if ( len < 0 ) {
354                                 rc = len;
355                                 DBGC ( http, "HTTP %p could not buffer line: "
356                                        "%s\n", http, strerror ( rc ) );
357                                 goto done;
358                         }
359                         iob_pull ( iobuf, len );
360                         line = buffered_line ( &http->linebuf );
361                         if ( line ) {
362                                 lh = &http_line_handlers[http->rx_state];
363                                 if ( ( rc = lh->rx ( http, line ) ) != 0 )
364                                         goto done;
365                         }
366                         break;
367                 default:
368                         assert ( 0 );
369                         break;
370                 }
371         }
372
373  done:
374         if ( rc )
375                 http_done ( http, rc );
376         free_iob ( iobuf );
377         return rc;
378 }
379
380 /**
381  * HTTP process
382  *
383  * @v process           Process
384  */
385 static void http_step ( struct process *process ) {
386         struct http_request *http =
387                 container_of ( process, struct http_request, process );
388         const char *path = http->uri->path;
389         const char *host = http->uri->host;
390         const char *query = http->uri->query;
391         int rc;
392
393         if ( xfer_window ( &http->socket ) ) {
394                 process_del ( &http->process );
395                 if ( ( rc = xfer_printf ( &http->socket,
396                                           "GET %s%s%s HTTP/1.1\r\n"
397                                           "User-Agent: gPXE/" VERSION "\r\n"
398                                           "Host: %s\r\n"
399                                           "\r\n",
400                                           ( path ? path : "/" ),
401                                           ( query ? "?" : "" ),
402                                           ( query ? query : "" ),
403                                           host ) ) != 0 ) {
404                         http_done ( http, rc );
405                 }
406         }
407 }
408
409 /**
410  * HTTP connection closed by network stack
411  *
412  * @v socket            Transport layer interface
413  * @v rc                Reason for close
414  */
415 static void http_socket_close ( struct xfer_interface *socket, int rc ) {
416         struct http_request *http =
417                 container_of ( socket, struct http_request, socket );
418
419         DBGC ( http, "HTTP %p socket closed: %s\n",
420                http, strerror ( rc ) );
421         
422         http_done ( http, rc );
423 }
424
425 /** HTTP socket operations */
426 static struct xfer_interface_operations http_socket_operations = {
427         .close          = http_socket_close,
428         .vredirect      = xfer_vopen,
429         .seek           = ignore_xfer_seek,
430         .window         = unlimited_xfer_window,
431         .alloc_iob      = default_xfer_alloc_iob,
432         .deliver_iob    = http_socket_deliver_iob,
433         .deliver_raw    = xfer_deliver_as_iob,
434 };
435
436 /**
437  * Close HTTP data transfer interface
438  *
439  * @v xfer              Data transfer interface
440  * @v rc                Reason for close
441  */
442 static void http_xfer_close ( struct xfer_interface *xfer, int rc ) {
443         struct http_request *http =
444                 container_of ( xfer, struct http_request, xfer );
445
446         DBGC ( http, "HTTP %p interface closed: %s\n",
447                http, strerror ( rc ) );
448
449         http_done ( http, rc );
450 }
451
452 /** HTTP data transfer interface operations */
453 static struct xfer_interface_operations http_xfer_operations = {
454         .close          = http_xfer_close,
455         .vredirect      = ignore_xfer_vredirect,
456         .seek           = ignore_xfer_seek,
457         .window         = unlimited_xfer_window,
458         .alloc_iob      = default_xfer_alloc_iob,
459         .deliver_iob    = xfer_deliver_as_raw,
460         .deliver_raw    = ignore_xfer_deliver_raw,
461 };
462
463 /**
464  * Initiate an HTTP connection, with optional filter
465  *
466  * @v xfer              Data transfer interface
467  * @v uri               Uniform Resource Identifier
468  * @v default_port      Default port number
469  * @v filter            Filter to apply to socket, or NULL
470  * @ret rc              Return status code
471  */
472 int http_open_filter ( struct xfer_interface *xfer, struct uri *uri,
473                        unsigned int default_port,
474                        int ( * filter ) ( struct xfer_interface *xfer,
475                                           struct xfer_interface **next ) ) {
476         struct http_request *http;
477         struct sockaddr_tcpip server;
478         struct xfer_interface *socket;
479         int rc;
480
481         /* Sanity checks */
482         if ( ! uri->host )
483                 return -EINVAL;
484
485         /* Allocate and populate HTTP structure */
486         http = zalloc ( sizeof ( *http ) );
487         if ( ! http )
488                 return -ENOMEM;
489         http->refcnt.free = http_free;
490         xfer_init ( &http->xfer, &http_xfer_operations, &http->refcnt );
491         http->uri = uri_get ( uri );
492         xfer_init ( &http->socket, &http_socket_operations, &http->refcnt );
493         process_init ( &http->process, http_step, &http->refcnt );
494
495         /* Open socket */
496         memset ( &server, 0, sizeof ( server ) );
497         server.st_port = htons ( uri_port ( http->uri, default_port ) );
498         socket = &http->socket;
499         if ( filter ) {
500                 if ( ( rc = filter ( socket, &socket ) ) != 0 )
501                         goto err;
502         }
503         if ( ( rc = xfer_open_named_socket ( socket, SOCK_STREAM,
504                                              ( struct sockaddr * ) &server,
505                                              uri->host, NULL ) ) != 0 )
506                 goto err;
507
508         /* Attach to parent interface, mortalise self, and return */
509         xfer_plug_plug ( &http->xfer, xfer );
510         ref_put ( &http->refcnt );
511         return 0;
512
513  err:
514         DBGC ( http, "HTTP %p could not create request: %s\n", 
515                http, strerror ( rc ) );
516         http_done ( http, rc );
517         ref_put ( &http->refcnt );
518         return rc;
519 }
520
521 /**
522  * Initiate an HTTP connection
523  *
524  * @v xfer              Data transfer interface
525  * @v uri               Uniform Resource Identifier
526  * @ret rc              Return status code
527  */
528 static int http_open ( struct xfer_interface *xfer, struct uri *uri ) {
529         return http_open_filter ( xfer, uri, HTTP_PORT, NULL );
530 }
531
532 /** HTTP URI opener */
533 struct uri_opener http_uri_opener __uri_opener = {
534         .scheme = "http",
535         .open   = http_open,
536 };