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