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