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