iPXE - Open Source Boot Firmware

[peerdist] Allow PeerDist to be globally enabled or disabled
[ipxe.git] / src / net / tcp / httpcore.c
1 /*
2  * Copyright (C) 2015 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., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301, USA.
18  *
19  * You can also choose to distribute this program under the terms of
20  * the Unmodified Binary Distribution Licence (as given in the file
21  * COPYING.UBDL), provided that you have satisfied its requirements.
22  */
23
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25
26 /**
27  * @file
28  *
29  * Hyper Text Transfer Protocol (HTTP) core functionality
30  *
31  */
32
33 #include <stdint.h>
34 #include <stdlib.h>
35 #include <stdio.h>
36 #include <string.h>
37 #include <strings.h>
38 #include <byteswap.h>
39 #include <errno.h>
40 #include <ctype.h>
41 #include <assert.h>
42 #include <ipxe/uri.h>
43 #include <ipxe/refcnt.h>
44 #include <ipxe/iobuf.h>
45 #include <ipxe/xfer.h>
46 #include <ipxe/open.h>
47 #include <ipxe/process.h>
48 #include <ipxe/retry.h>
49 #include <ipxe/timer.h>
50 #include <ipxe/linebuf.h>
51 #include <ipxe/xferbuf.h>
52 #include <ipxe/blockdev.h>
53 #include <ipxe/acpi.h>
54 #include <ipxe/version.h>
55 #include <ipxe/params.h>
56 #include <ipxe/profile.h>
57 #include <ipxe/vsprintf.h>
58 #include <ipxe/errortab.h>
59 #include <ipxe/http.h>
60
61 /* Disambiguate the various error causes */
62 #define EACCES_401 __einfo_error ( EINFO_EACCES_401 )
63 #define EINFO_EACCES_401 \
64         __einfo_uniqify ( EINFO_EACCES, 0x01, "HTTP 401 Unauthorized" )
65 #define EINVAL_STATUS __einfo_error ( EINFO_EINVAL_STATUS )
66 #define EINFO_EINVAL_STATUS \
67         __einfo_uniqify ( EINFO_EINVAL, 0x01, "Invalid status line" )
68 #define EINVAL_HEADER __einfo_error ( EINFO_EINVAL_HEADER )
69 #define EINFO_EINVAL_HEADER \
70         __einfo_uniqify ( EINFO_EINVAL, 0x02, "Invalid header" )
71 #define EINVAL_CONTENT_LENGTH __einfo_error ( EINFO_EINVAL_CONTENT_LENGTH )
72 #define EINFO_EINVAL_CONTENT_LENGTH \
73         __einfo_uniqify ( EINFO_EINVAL, 0x03, "Invalid content length" )
74 #define EINVAL_CHUNK_LENGTH __einfo_error ( EINFO_EINVAL_CHUNK_LENGTH )
75 #define EINFO_EINVAL_CHUNK_LENGTH \
76         __einfo_uniqify ( EINFO_EINVAL, 0x04, "Invalid chunk length" )
77 #define EIO_OTHER __einfo_error ( EINFO_EIO_OTHER )
78 #define EINFO_EIO_OTHER \
79         __einfo_uniqify ( EINFO_EIO, 0x01, "Unrecognised HTTP response code" )
80 #define EIO_CONTENT_LENGTH __einfo_error ( EINFO_EIO_CONTENT_LENGTH )
81 #define EINFO_EIO_CONTENT_LENGTH \
82         __einfo_uniqify ( EINFO_EIO, 0x02, "Content length mismatch" )
83 #define EIO_4XX __einfo_error ( EINFO_EIO_4XX )
84 #define EINFO_EIO_4XX \
85         __einfo_uniqify ( EINFO_EIO, 0x04, "HTTP 4xx Client Error" )
86 #define EIO_5XX __einfo_error ( EINFO_EIO_5XX )
87 #define EINFO_EIO_5XX \
88         __einfo_uniqify ( EINFO_EIO, 0x05, "HTTP 5xx Server Error" )
89 #define ENOENT_404 __einfo_error ( EINFO_ENOENT_404 )
90 #define EINFO_ENOENT_404 \
91         __einfo_uniqify ( EINFO_ENOENT, 0x01, "HTTP 404 Not Found" )
92 #define ENOTSUP_CONNECTION __einfo_error ( EINFO_ENOTSUP_CONNECTION )
93 #define EINFO_ENOTSUP_CONNECTION \
94         __einfo_uniqify ( EINFO_ENOTSUP, 0x01, "Unsupported connection header" )
95 #define ENOTSUP_TRANSFER __einfo_error ( EINFO_ENOTSUP_TRANSFER )
96 #define EINFO_ENOTSUP_TRANSFER \
97         __einfo_uniqify ( EINFO_ENOTSUP, 0x02, "Unsupported transfer encoding" )
98 #define EPERM_403 __einfo_error ( EINFO_EPERM_403 )
99 #define EINFO_EPERM_403 \
100         __einfo_uniqify ( EINFO_EPERM, 0x01, "HTTP 403 Forbidden" )
101 #define EPROTO_UNSOLICITED __einfo_error ( EINFO_EPROTO_UNSOLICITED )
102 #define EINFO_EPROTO_UNSOLICITED \
103         __einfo_uniqify ( EINFO_EPROTO, 0x01, "Unsolicited data" )
104
105 /** Retry delay used when we cannot understand the Retry-After header */
106 #define HTTP_RETRY_SECONDS 5
107
108 /** Receive profiler */
109 static struct profiler http_rx_profiler __profiler = { .name = "http.rx" };
110
111 /** Data transfer profiler */
112 static struct profiler http_xfer_profiler __profiler = { .name = "http.xfer" };
113
114 /** Human-readable error messages */
115 struct errortab http_errors[] __errortab = {
116         __einfo_errortab ( EINFO_EIO_4XX ),
117         __einfo_errortab ( EINFO_EIO_5XX ),
118 };
119
120 static struct http_state http_request;
121 static struct http_state http_headers;
122 static struct http_state http_trailers;
123 static struct http_transfer_encoding http_transfer_identity;
124
125 /******************************************************************************
126  *
127  * Methods
128  *
129  ******************************************************************************
130  */
131
132 /** HTTP HEAD method */
133 struct http_method http_head = {
134         .name = "HEAD",
135 };
136
137 /** HTTP GET method */
138 struct http_method http_get = {
139         .name = "GET",
140 };
141
142 /** HTTP POST method */
143 struct http_method http_post = {
144         .name = "POST",
145 };
146
147 /******************************************************************************
148  *
149  * Utility functions
150  *
151  ******************************************************************************
152  */
153
154 /**
155  * Handle received HTTP line-buffered data
156  *
157  * @v http              HTTP transaction
158  * @v iobuf             I/O buffer
159  * @v linebuf           Line buffer
160  * @ret rc              Return status code
161  */
162 static int http_rx_linebuf ( struct http_transaction *http,
163                              struct io_buffer *iobuf,
164                              struct line_buffer *linebuf ) {
165         int consumed;
166         int rc;
167
168         /* Buffer received line */
169         consumed = line_buffer ( linebuf, iobuf->data, iob_len ( iobuf ) );
170         if ( consumed < 0 ) {
171                 rc = consumed;
172                 DBGC ( http, "HTTP %p could not buffer line: %s\n",
173                        http, strerror ( rc ) );
174                 return rc;
175         }
176
177         /* Consume line */
178         iob_pull ( iobuf, consumed );
179
180         return 0;
181 }
182
183 /**
184  * Get HTTP response token
185  *
186  * @v line              Line position
187  * @v value             Token value to fill in (if any)
188  * @ret token           Token, or NULL
189  */
190 char * http_token ( char **line, char **value ) {
191         char *token;
192         char quote = '\0';
193         char c;
194
195         /* Avoid returning uninitialised data */
196         if ( value )
197                 *value = NULL;
198
199         /* Skip any initial whitespace or commas */
200         while ( ( isspace ( **line ) ) || ( **line == ',' ) )
201                 (*line)++;
202
203         /* Check for end of line and record token position */
204         if ( ! **line )
205                 return NULL;
206         token = *line;
207
208         /* Scan for end of token */
209         while ( ( c = **line ) ) {
210
211                 /* Terminate if we hit an unquoted whitespace or comma */
212                 if ( ( isspace ( c ) || ( c == ',' ) ) && ! quote )
213                         break;
214
215                 /* Terminate if we hit a closing quote */
216                 if ( c == quote )
217                         break;
218
219                 /* Check for value separator */
220                 if ( value && ( ! *value ) && ( c == '=' ) ) {
221
222                         /* Terminate key portion of token */
223                         *((*line)++) = '\0';
224
225                         /* Check for quote character */
226                         c = **line;
227                         if ( ( c == '"' ) || ( c == '\'' ) ) {
228                                 quote = c;
229                                 (*line)++;
230                         }
231
232                         /* Record value portion of token */
233                         *value = *line;
234
235                 } else {
236
237                         /* Move to next character */
238                         (*line)++;
239                 }
240         }
241
242         /* Terminate token, if applicable */
243         if ( c )
244                 *((*line)++) = '\0';
245
246         return token;
247 }
248
249 /******************************************************************************
250  *
251  * Transactions
252  *
253  ******************************************************************************
254  */
255
256 /**
257  * Free HTTP transaction
258  *
259  * @v refcnt            Reference count
260  */
261 static void http_free ( struct refcnt *refcnt ) {
262         struct http_transaction *http =
263                 container_of ( refcnt, struct http_transaction, refcnt );
264
265         empty_line_buffer ( &http->response.headers );
266         empty_line_buffer ( &http->linebuf );
267         uri_put ( http->uri );
268         free ( http );
269 }
270
271 /**
272  * Close HTTP transaction
273  *
274  * @v http              HTTP transaction
275  * @v rc                Reason for close
276  */
277 static void http_close ( struct http_transaction *http, int rc ) {
278
279         /* Stop process */
280         process_del ( &http->process );
281
282         /* Stop timer */
283         stop_timer ( &http->timer );
284
285         /* Close all interfaces */
286         intfs_shutdown ( rc, &http->conn, &http->transfer, &http->content,
287                          &http->xfer, NULL );
288 }
289
290 /**
291  * Close HTTP transaction with error (even if none specified)
292  *
293  * @v http              HTTP transaction
294  * @v rc                Reason for close
295  */
296 static void http_close_error ( struct http_transaction *http, int rc ) {
297
298         /* Treat any close as an error */
299         http_close ( http, ( rc ? rc : -EPIPE ) );
300 }
301
302 /**
303  * Reopen stale HTTP connection
304  *
305  * @v http              HTTP transaction
306  */
307 static void http_reopen ( struct http_transaction *http ) {
308         int rc;
309
310         /* Close existing connection */
311         intf_restart ( &http->conn, -ECANCELED );
312
313         /* Reopen connection */
314         if ( ( rc = http_connect ( &http->conn, http->uri ) ) != 0 ) {
315                 DBGC ( http, "HTTP %p could not reconnect: %s\n",
316                        http, strerror ( rc ) );
317                 goto err_connect;
318         }
319
320         /* Reset state */
321         http->state = &http_request;
322
323         /* Reschedule transmission process */
324         process_add ( &http->process );
325
326         return;
327
328  err_connect:
329         http_close ( http, rc );
330 }
331
332 /**
333  * Handle retry timer expiry
334  *
335  * @v timer             Retry timer
336  * @v over              Failure indicator
337  */
338 static void http_expired ( struct retry_timer *timer, int over __unused ) {
339         struct http_transaction *http =
340                 container_of ( timer, struct http_transaction, timer );
341
342         /* Reopen connection */
343         http_reopen ( http );
344 }
345
346 /**
347  * HTTP transmit process
348  *
349  * @v http              HTTP transaction
350  */
351 static void http_step ( struct http_transaction *http ) {
352         int rc;
353
354         /* Do nothing if we have nothing to transmit */
355         if ( ! http->state->tx )
356                 return;
357
358         /* Do nothing until connection is ready */
359         if ( ! xfer_window ( &http->conn ) )
360                 return;
361
362         /* Notify data transfer interface that window may have changed */
363         xfer_window_changed ( &http->xfer );
364
365         /* Do nothing until data transfer interface is ready */
366         if ( ! xfer_window ( &http->xfer ) )
367                 return;
368
369         /* Transmit data */
370         if ( ( rc = http->state->tx ( http ) ) != 0 )
371                 goto err;
372
373         return;
374
375  err:
376         http_close ( http, rc );
377 }
378
379 /**
380  * Handle received HTTP data
381  *
382  * @v http              HTTP transaction
383  * @v iobuf             I/O buffer
384  * @v meta              Transfer metadata
385  * @ret rc              Return status code
386  *
387  * This function takes ownership of the I/O buffer.
388  */
389 static int http_conn_deliver ( struct http_transaction *http,
390                                struct io_buffer *iobuf,
391                                struct xfer_metadata *meta __unused ) {
392         int rc;
393
394         /* Handle received data */
395         profile_start ( &http_rx_profiler );
396         while ( iobuf && iob_len ( iobuf ) ) {
397
398                 /* Sanity check */
399                 if ( ( ! http->state ) || ( ! http->state->rx ) ) {
400                         DBGC ( http, "HTTP %p unexpected data\n", http );
401                         rc = -EPROTO_UNSOLICITED;
402                         goto err;
403                 }
404
405                 /* Receive (some) data */
406                 if ( ( rc = http->state->rx ( http, &iobuf ) ) != 0 )
407                         goto err;
408         }
409
410         /* Free I/O buffer, if applicable */
411         free_iob ( iobuf );
412
413         profile_stop ( &http_rx_profiler );
414         return 0;
415
416  err:
417         free_iob ( iobuf );
418         http_close ( http, rc );
419         return rc;
420 }
421
422 /**
423  * Handle server connection close
424  *
425  * @v http              HTTP transaction
426  * @v rc                Reason for close
427  */
428 static void http_conn_close ( struct http_transaction *http, int rc ) {
429
430         /* Sanity checks */
431         assert ( http->state != NULL );
432         assert ( http->state->close != NULL );
433
434         /* Restart server connection interface */
435         intf_restart ( &http->conn, rc );
436
437         /* Hand off to state-specific method */
438         http->state->close ( http, rc );
439 }
440
441 /**
442  * Handle received content-decoded data
443  *
444  * @v http              HTTP transaction
445  * @v iobuf             I/O buffer
446  * @v meta              Data transfer metadata
447  */
448 static int http_content_deliver ( struct http_transaction *http,
449                                   struct io_buffer *iobuf,
450                                   struct xfer_metadata *meta ) {
451         int rc;
452
453         /* Ignore content if this is anything other than a successful
454          * transfer.
455          */
456         if ( http->response.rc != 0 ) {
457                 free_iob ( iobuf );
458                 return 0;
459         }
460
461         /* Deliver to data transfer interface */
462         profile_start ( &http_xfer_profiler );
463         if ( ( rc = xfer_deliver ( &http->xfer, iob_disown ( iobuf ),
464                                    meta ) ) != 0 )
465                 return rc;
466         profile_stop ( &http_xfer_profiler );
467
468         return 0;
469 }
470
471 /**
472  * Get underlying data transfer buffer
473  *
474  * @v http              HTTP transaction
475  * @ret xferbuf         Data transfer buffer, or NULL on error
476  */
477 static struct xfer_buffer *
478 http_content_buffer ( struct http_transaction *http ) {
479
480         /* Deny access to the data transfer buffer if this is anything
481          * other than a successful transfer.
482          */
483         if ( http->response.rc != 0 )
484                 return NULL;
485
486         /* Hand off to data transfer interface */
487         return xfer_buffer ( &http->xfer );
488 }
489
490 /**
491  * Read from block device (when HTTP block device support is not present)
492  *
493  * @v http              HTTP transaction
494  * @v data              Data interface
495  * @v lba               Starting logical block address
496  * @v count             Number of logical blocks
497  * @v buffer            Data buffer
498  * @v len               Length of data buffer
499  * @ret rc              Return status code
500  */
501 __weak int http_block_read ( struct http_transaction *http __unused,
502                              struct interface *data __unused,
503                              uint64_t lba __unused, unsigned int count __unused,
504                              userptr_t buffer __unused, size_t len __unused ) {
505
506         return -ENOTSUP;
507 }
508
509 /**
510  * Read block device capacity (when HTTP block device support is not present)
511  *
512  * @v control           Control interface
513  * @v data              Data interface
514  * @ret rc              Return status code
515  */
516 __weak int http_block_read_capacity ( struct http_transaction *http __unused,
517                                       struct interface *data __unused ) {
518
519         return -ENOTSUP;
520 }
521
522 /** HTTP data transfer interface operations */
523 static struct interface_operation http_xfer_operations[] = {
524         INTF_OP ( block_read, struct http_transaction *, http_block_read ),
525         INTF_OP ( block_read_capacity, struct http_transaction *,
526                   http_block_read_capacity ),
527         INTF_OP ( xfer_window_changed, struct http_transaction *, http_step ),
528         INTF_OP ( intf_close, struct http_transaction *, http_close ),
529 };
530
531 /** HTTP data transfer interface descriptor */
532 static struct interface_descriptor http_xfer_desc =
533         INTF_DESC_PASSTHRU ( struct http_transaction, xfer,
534                              http_xfer_operations, content );
535
536 /** HTTP content-decoded interface operations */
537 static struct interface_operation http_content_operations[] = {
538         INTF_OP ( xfer_deliver, struct http_transaction *,
539                   http_content_deliver ),
540         INTF_OP ( xfer_buffer, struct http_transaction *, http_content_buffer ),
541         INTF_OP ( intf_close, struct http_transaction *, http_close ),
542 };
543
544 /** HTTP content-decoded interface descriptor */
545 static struct interface_descriptor http_content_desc =
546         INTF_DESC_PASSTHRU ( struct http_transaction, content,
547                              http_content_operations, xfer );
548
549 /** HTTP transfer-decoded interface operations */
550 static struct interface_operation http_transfer_operations[] = {
551         INTF_OP ( intf_close, struct http_transaction *, http_close ),
552 };
553
554 /** HTTP transfer-decoded interface descriptor */
555 static struct interface_descriptor http_transfer_desc =
556         INTF_DESC_PASSTHRU ( struct http_transaction, transfer,
557                              http_transfer_operations, conn );
558
559 /** HTTP server connection interface operations */
560 static struct interface_operation http_conn_operations[] = {
561         INTF_OP ( xfer_deliver, struct http_transaction *, http_conn_deliver ),
562         INTF_OP ( xfer_window_changed, struct http_transaction *, http_step ),
563         INTF_OP ( pool_reopen, struct http_transaction *, http_reopen ),
564         INTF_OP ( intf_close, struct http_transaction *, http_conn_close ),
565 };
566
567 /** HTTP server connection interface descriptor */
568 static struct interface_descriptor http_conn_desc =
569         INTF_DESC_PASSTHRU ( struct http_transaction, conn,
570                              http_conn_operations, transfer );
571
572 /** HTTP process descriptor */
573 static struct process_descriptor http_process_desc =
574         PROC_DESC_ONCE ( struct http_transaction, process, http_step );
575
576 /**
577  * Open HTTP transaction
578  *
579  * @v xfer              Data transfer interface
580  * @v method            Request method
581  * @v uri               Request URI
582  * @v range             Content range (if any)
583  * @v content           Request content (if any)
584  * @ret rc              Return status code
585  */
586 int http_open ( struct interface *xfer, struct http_method *method,
587                 struct uri *uri, struct http_request_range *range,
588                 struct http_request_content *content ) {
589         struct http_transaction *http;
590         struct uri request_uri;
591         struct uri request_host;
592         size_t request_uri_len;
593         size_t request_host_len;
594         size_t content_len;
595         char *request_uri_string;
596         char *request_host_string;
597         void *content_data;
598         int rc;
599
600         /* Calculate request URI length */
601         memset ( &request_uri, 0, sizeof ( request_uri ) );
602         request_uri.path = ( uri->path ? uri->path : "/" );
603         request_uri.query = uri->query;
604         request_uri_len =
605                 ( format_uri ( &request_uri, NULL, 0 ) + 1 /* NUL */);
606
607         /* Calculate host name length */
608         memset ( &request_host, 0, sizeof ( request_host ) );
609         request_host.host = uri->host;
610         request_host.port = uri->port;
611         request_host_len =
612                 ( format_uri ( &request_host, NULL, 0 ) + 1 /* NUL */ );
613
614         /* Calculate request content length */
615         content_len = ( content ? content->len : 0 );
616
617         /* Allocate and initialise structure */
618         http = zalloc ( sizeof ( *http ) + request_uri_len + request_host_len +
619                         content_len );
620         if ( ! http ) {
621                 rc = -ENOMEM;
622                 goto err_alloc;
623         }
624         request_uri_string = ( ( ( void * ) http ) + sizeof ( *http ) );
625         request_host_string = ( request_uri_string + request_uri_len );
626         content_data = ( request_host_string + request_host_len );
627         format_uri ( &request_uri, request_uri_string, request_uri_len );
628         format_uri ( &request_host, request_host_string, request_host_len );
629         ref_init ( &http->refcnt, http_free );
630         intf_init ( &http->xfer, &http_xfer_desc, &http->refcnt );
631         intf_init ( &http->content, &http_content_desc, &http->refcnt );
632         intf_init ( &http->transfer, &http_transfer_desc, &http->refcnt );
633         intf_init ( &http->conn, &http_conn_desc, &http->refcnt );
634         intf_plug_plug ( &http->transfer, &http->content );
635         process_init ( &http->process, &http_process_desc, &http->refcnt );
636         timer_init ( &http->timer, http_expired, &http->refcnt );
637         http->uri = uri_get ( uri );
638         http->request.method = method;
639         http->request.uri = request_uri_string;
640         http->request.host = request_host_string;
641         if ( range ) {
642                 memcpy ( &http->request.range, range,
643                          sizeof ( http->request.range ) );
644         }
645         if ( content ) {
646                 http->request.content.type = content->type;
647                 http->request.content.data = content_data;
648                 http->request.content.len = content_len;
649                 memcpy ( content_data, content->data, content_len );
650         }
651         http->state = &http_request;
652         DBGC2 ( http, "HTTP %p %s://%s%s\n", http, http->uri->scheme,
653                 http->request.host, http->request.uri );
654
655         /* Open connection */
656         if ( ( rc = http_connect ( &http->conn, uri ) ) != 0 ) {
657                 DBGC ( http, "HTTP %p could not connect: %s\n",
658                        http, strerror ( rc ) );
659                 goto err_connect;
660         }
661
662         /* Attach to parent interface, mortalise self, and return */
663         intf_plug_plug ( &http->xfer, xfer );
664         ref_put ( &http->refcnt );
665         return 0;
666
667  err_connect:
668         http_close ( http, rc );
669         ref_put ( &http->refcnt );
670  err_alloc:
671         return rc;
672 }
673
674 /**
675  * Redirect HTTP transaction
676  *
677  * @v http              HTTP transaction
678  * @v location          New location
679  * @ret rc              Return status code
680  */
681 static int http_redirect ( struct http_transaction *http,
682                            const char *location ) {
683         struct uri *location_uri;
684         struct uri *resolved_uri;
685         int rc;
686
687         DBGC2 ( http, "HTTP %p redirecting to \"%s\"\n", http, location );
688
689         /* Parse location URI */
690         location_uri = parse_uri ( location );
691         if ( ! location_uri ) {
692                 rc = -ENOMEM;
693                 goto err_parse_uri;
694         }
695
696         /* Resolve as relative to original URI */
697         resolved_uri = resolve_uri ( http->uri, location_uri );
698         if ( ! resolved_uri ) {
699                 rc = -ENOMEM;
700                 goto err_resolve_uri;
701         }
702
703         /* Redirect to new URI */
704         if ( ( rc = xfer_redirect ( &http->xfer, LOCATION_URI,
705                                     resolved_uri ) ) != 0 ) {
706                 DBGC ( http, "HTTP %p could not redirect: %s\n",
707                        http, strerror ( rc ) );
708                 goto err_redirect;
709         }
710
711  err_redirect:
712         uri_put ( resolved_uri );
713  err_resolve_uri:
714         uri_put ( location_uri );
715  err_parse_uri:
716         return rc;
717 }
718
719 /**
720  * Handle successful transfer completion
721  *
722  * @v http              HTTP transaction
723  * @ret rc              Return status code
724  */
725 static int http_transfer_complete ( struct http_transaction *http ) {
726         struct http_authentication *auth;
727         const char *location;
728         int rc;
729
730         /* Keep connection alive if applicable */
731         if ( http->response.flags & HTTP_RESPONSE_KEEPALIVE )
732                 pool_recycle ( &http->conn );
733
734         /* Restart server connection interface */
735         intf_restart ( &http->conn, 0 );
736
737         /* No more data is expected */
738         http->state = NULL;
739
740         /* If transaction is successful, then close the
741          * transfer-decoded interface.  The content encoding may
742          * choose whether or not to immediately terminate the
743          * transaction.
744          */
745         if ( http->response.rc == 0 ) {
746                 intf_shutdown ( &http->transfer, 0 );
747                 return 0;
748         }
749
750         /* Perform redirection, if applicable */
751         if ( ( location = http->response.location ) ) {
752                 if ( ( rc = http_redirect ( http, location ) ) != 0 )
753                         return rc;
754                 http_close ( http, 0 );
755                 return 0;
756         }
757
758         /* Fail unless a retry is permitted */
759         if ( ! ( http->response.flags & HTTP_RESPONSE_RETRY ) )
760                 return http->response.rc;
761
762         /* Perform authentication, if applicable */
763         if ( ( auth = http->response.auth.auth ) ) {
764                 http->request.auth.auth = auth;
765                 DBGC2 ( http, "HTTP %p performing %s authentication\n",
766                         http, auth->name );
767                 if ( ( rc = auth->authenticate ( http ) ) != 0 ) {
768                         DBGC ( http, "HTTP %p could not authenticate: %s\n",
769                                http, strerror ( rc ) );
770                         return rc;
771                 }
772         }
773
774         /* Restart content decoding interfaces */
775         intfs_restart ( http->response.rc, &http->content, &http->transfer,
776                         NULL );
777         intf_plug_plug ( &http->transfer, &http->content );
778         http->len = 0;
779         assert ( http->remaining == 0 );
780
781         /* Retry immediately if applicable.  We cannot rely on an
782          * immediate timer expiry, since certain Microsoft-designed
783          * HTTP extensions such as NTLM break the fundamentally
784          * stateless nature of HTTP and rely on the same connection
785          * being reused for authentication.  See RFC7230 section 2.3
786          * for further details.
787          */
788         if ( ! http->response.retry_after ) {
789                 http_reopen ( http );
790                 return 0;
791         }
792
793         /* Start timer to initiate retry */
794         DBGC2 ( http, "HTTP %p retrying after %d seconds\n",
795                 http, http->response.retry_after );
796         start_timer_fixed ( &http->timer,
797                             ( http->response.retry_after * TICKS_PER_SEC ) );
798         return 0;
799 }
800
801 /******************************************************************************
802  *
803  * Requests
804  *
805  ******************************************************************************
806  */
807
808 /**
809  * Construct HTTP request headers
810  *
811  * @v http              HTTP transaction
812  * @v buf               Buffer
813  * @v len               Length of buffer
814  * @ret len             Length, or negative error
815  */
816 static int http_format_headers ( struct http_transaction *http, char *buf,
817                                  size_t len ) {
818         struct http_request_header *header;
819         size_t used;
820         size_t remaining;
821         char *line;
822         int value_len;
823         int rc;
824
825         /* Construct request line */
826         used = ssnprintf ( buf, len, "%s %s HTTP/1.1",
827                            http->request.method->name, http->request.uri );
828         if ( used < len )
829                 DBGC2 ( http, "HTTP %p TX %s\n", http, buf );
830         used += ssnprintf ( ( buf + used ), ( len - used ), "\r\n" );
831
832         /* Construct all headers */
833         for_each_table_entry ( header, HTTP_REQUEST_HEADERS ) {
834
835                 /* Determine header value length */
836                 value_len = header->format ( http, NULL, 0 );
837                 if ( value_len < 0 ) {
838                         rc = value_len;
839                         return rc;
840                 }
841
842                 /* Skip zero-length headers */
843                 if ( ! value_len )
844                         continue;
845
846                 /* Construct header */
847                 line = ( buf + used );
848                 used += ssnprintf ( ( buf + used ), ( len - used ), "%s: ",
849                                     header->name );
850                 remaining = ( ( used < len ) ? ( len - used ) : 0 );
851                 used += header->format ( http, ( buf + used ), remaining );
852                 if ( used < len )
853                         DBGC2 ( http, "HTTP %p TX %s\n", http, line );
854                 used += ssnprintf ( ( buf + used ), ( len - used ), "\r\n" );
855         }
856
857         /* Construct terminating newline */
858         used += ssnprintf ( ( buf + used ), ( len - used ), "\r\n" );
859
860         return used;
861 }
862
863 /**
864  * Construct HTTP "Host" header
865  *
866  * @v http              HTTP transaction
867  * @v buf               Buffer
868  * @v len               Length of buffer
869  * @ret len             Length of header value, or negative error
870  */
871 static int http_format_host ( struct http_transaction *http, char *buf,
872                               size_t len ) {
873
874         /* Construct host URI */
875         return snprintf ( buf, len, "%s", http->request.host );
876 }
877
878 /** HTTP "Host" header "*/
879 struct http_request_header http_request_host __http_request_header = {
880         .name = "Host",
881         .format = http_format_host,
882 };
883
884 /**
885  * Construct HTTP "User-Agent" header
886  *
887  * @v http              HTTP transaction
888  * @v buf               Buffer
889  * @v len               Length of buffer
890  * @ret len             Length of header value, or negative error
891  */
892 static int http_format_user_agent ( struct http_transaction *http __unused,
893                                     char *buf, size_t len ) {
894
895         /* Construct user agent */
896         return snprintf ( buf, len, "iPXE/%s", product_version );
897 }
898
899 /** HTTP "User-Agent" header */
900 struct http_request_header http_request_user_agent __http_request_header = {
901         .name = "User-Agent",
902         .format = http_format_user_agent,
903 };
904
905 /**
906  * Construct HTTP "Connection" header
907  *
908  * @v http              HTTP transaction
909  * @v buf               Buffer
910  * @v len               Length of buffer
911  * @ret len             Length of header value, or negative error
912  */
913 static int http_format_connection ( struct http_transaction *http __unused,
914                                     char *buf, size_t len ) {
915
916         /* Always request keep-alive */
917         return snprintf ( buf, len, "keep-alive" );
918 }
919
920 /** HTTP "Connection" header */
921 struct http_request_header http_request_connection __http_request_header = {
922         .name = "Connection",
923         .format = http_format_connection,
924 };
925
926 /**
927  * Construct HTTP "Range" header
928  *
929  * @v http              HTTP transaction
930  * @v buf               Buffer
931  * @v len               Length of buffer
932  * @ret len             Length of header value, or negative error
933  */
934 static int http_format_range ( struct http_transaction *http,
935                                char *buf, size_t len ) {
936
937         /* Construct range, if applicable */
938         if ( http->request.range.len ) {
939                 return snprintf ( buf, len, "bytes=%zd-%zd",
940                                   http->request.range.start,
941                                   ( http->request.range.start +
942                                     http->request.range.len - 1 ) );
943         } else {
944                 return 0;
945         }
946 }
947
948 /** HTTP "Range" header */
949 struct http_request_header http_request_range __http_request_header = {
950         .name = "Range",
951         .format = http_format_range,
952 };
953
954 /**
955  * Construct HTTP "Content-Type" header
956  *
957  * @v http              HTTP transaction
958  * @v buf               Buffer
959  * @v len               Length of buffer
960  * @ret len             Length of header value, or negative error
961  */
962 static int http_format_content_type ( struct http_transaction *http,
963                                       char *buf, size_t len ) {
964
965         /* Construct content type, if applicable */
966         if ( http->request.content.type ) {
967                 return snprintf ( buf, len, "%s", http->request.content.type );
968         } else {
969                 return 0;
970         }
971 }
972
973 /** HTTP "Content-Type" header */
974 struct http_request_header http_request_content_type __http_request_header = {
975         .name = "Content-Type",
976         .format = http_format_content_type,
977 };
978
979 /**
980  * Construct HTTP "Content-Length" header
981  *
982  * @v http              HTTP transaction
983  * @v buf               Buffer
984  * @v len               Length of buffer
985  * @ret len             Length of header value, or negative error
986  */
987 static int http_format_content_length ( struct http_transaction *http,
988                                         char *buf, size_t len ) {
989
990         /* Construct content length, if applicable */
991         if ( http->request.content.len ) {
992                 return snprintf ( buf, len, "%zd", http->request.content.len );
993         } else {
994                 return 0;
995         }
996 }
997
998 /** HTTP "Content-Length" header */
999 struct http_request_header http_request_content_length __http_request_header = {
1000         .name = "Content-Length",
1001         .format = http_format_content_length,
1002 };
1003
1004 /**
1005  * Construct HTTP "Accept-Encoding" header
1006  *
1007  * @v http              HTTP transaction
1008  * @v buf               Buffer
1009  * @v len               Length of buffer
1010  * @ret len             Length of header value, or negative error
1011  */
1012 static int http_format_accept_encoding ( struct http_transaction *http,
1013                                          char *buf, size_t len ) {
1014         struct http_content_encoding *encoding;
1015         const char *sep = "";
1016         size_t used = 0;
1017
1018         /* Construct list of content encodings */
1019         for_each_table_entry ( encoding, HTTP_CONTENT_ENCODINGS ) {
1020                 if ( encoding->supported && ( ! encoding->supported ( http ) ) )
1021                         continue;
1022                 used += ssnprintf ( ( buf + used ), ( len - used ),
1023                                     "%s%s", sep, encoding->name );
1024                 sep = ", ";
1025         }
1026
1027         return used;
1028 }
1029
1030 /** HTTP "Accept-Encoding" header */
1031 struct http_request_header http_request_accept_encoding __http_request_header ={
1032         .name = "Accept-Encoding",
1033         .format = http_format_accept_encoding,
1034 };
1035
1036 /**
1037  * Transmit request
1038  *
1039  * @v http              HTTP transaction
1040  * @ret rc              Return status code
1041  */
1042 static int http_tx_request ( struct http_transaction *http ) {
1043         struct io_buffer *iobuf;
1044         int len;
1045         int check_len;
1046         int rc;
1047
1048         /* Calculate request length */
1049         len = http_format_headers ( http, NULL, 0 );
1050         if ( len < 0 ) {
1051                 rc = len;
1052                 DBGC ( http, "HTTP %p could not construct request: %s\n",
1053                        http, strerror ( rc ) );
1054                 goto err_len;
1055         }
1056
1057         /* Allocate I/O buffer */
1058         iobuf = alloc_iob ( len + 1 /* NUL */ + http->request.content.len );
1059         if ( ! iobuf ) {
1060                 rc = -ENOMEM;
1061                 goto err_alloc;
1062         }
1063
1064         /* Construct request */
1065         check_len = http_format_headers ( http, iob_put ( iobuf, len ),
1066                                           ( len + 1 /* NUL */ ) );
1067         assert ( check_len == len );
1068         memcpy ( iob_put ( iobuf, http->request.content.len ),
1069                  http->request.content.data, http->request.content.len );
1070
1071         /* Deliver request */
1072         if ( ( rc = xfer_deliver_iob ( &http->conn,
1073                                        iob_disown ( iobuf ) ) ) != 0 ) {
1074                 DBGC ( http, "HTTP %p could not deliver request: %s\n",
1075                        http, strerror ( rc ) );
1076                 goto err_deliver;
1077         }
1078
1079         /* Clear any previous response */
1080         empty_line_buffer ( &http->response.headers );
1081         memset ( &http->response, 0, sizeof ( http->response ) );
1082
1083         /* Move to response headers state */
1084         http->state = &http_headers;
1085
1086         return 0;
1087
1088  err_deliver:
1089         free_iob ( iobuf );
1090  err_alloc:
1091  err_len:
1092         return rc;
1093 }
1094
1095 /** HTTP request state */
1096 static struct http_state http_request = {
1097         .tx = http_tx_request,
1098         .close = http_close_error,
1099 };
1100
1101 /******************************************************************************
1102  *
1103  * Response headers
1104  *
1105  ******************************************************************************
1106  */
1107
1108 /**
1109  * Parse HTTP status line
1110  *
1111  * @v http              HTTP transaction
1112  * @v line              Status line
1113  * @ret rc              Return status code
1114  */
1115 static int http_parse_status ( struct http_transaction *http, char *line ) {
1116         char *endp;
1117         char *version;
1118         char *vernum;
1119         char *status;
1120         int response_rc;
1121
1122         DBGC2 ( http, "HTTP %p RX %s\n", http, line );
1123
1124         /* Parse HTTP version */
1125         version = http_token ( &line, NULL );
1126         if ( ( ! version ) || ( strncmp ( version, "HTTP/", 5 ) != 0 ) ) {
1127                 DBGC ( http, "HTTP %p malformed version \"%s\"\n", http, line );
1128                 return -EINVAL_STATUS;
1129         }
1130
1131         /* Keepalive is enabled by default for anything newer than HTTP/1.0 */
1132         vernum = ( version + 5 /* "HTTP/" (presence already checked) */ );
1133         if ( vernum[0] == '0' ) {
1134                 /* HTTP/0.x : keepalive not enabled by default */
1135         } else if ( strncmp ( vernum, "1.0", 3 ) == 0 ) {
1136                 /* HTTP/1.0 : keepalive not enabled by default */
1137         } else {
1138                 /* HTTP/1.1 or newer: keepalive enabled by default */
1139                 http->response.flags |= HTTP_RESPONSE_KEEPALIVE;
1140         }
1141
1142         /* Parse status code */
1143         status = line;
1144         http->response.status = strtoul ( status, &endp, 10 );
1145         if ( *endp != ' ' ) {
1146                 DBGC ( http, "HTTP %p malformed status code \"%s\"\n",
1147                        http, status );
1148                 return -EINVAL_STATUS;
1149         }
1150
1151         /* Convert HTTP status code to iPXE return status code */
1152         if ( status[0] == '2' ) {
1153                 /* 2xx Success */
1154                 response_rc = 0;
1155         } else if ( status[0] == '3' ) {
1156                 /* 3xx Redirection */
1157                 response_rc = -EXDEV;
1158         } else if ( http->response.status == 401 ) {
1159                 /* 401 Unauthorized */
1160                 response_rc = -EACCES_401;
1161         } else if ( http->response.status == 403 ) {
1162                 /* 403 Forbidden */
1163                 response_rc = -EPERM_403;
1164         } else if ( http->response.status == 404 ) {
1165                 /* 404 Not Found */
1166                 response_rc = -ENOENT_404;
1167         } else if ( status[0] == '4' ) {
1168                 /* 4xx Client Error (not already specified) */
1169                 response_rc = -EIO_4XX;
1170         } else if ( status[0] == '5' ) {
1171                 /* 5xx Server Error */
1172                 response_rc = -EIO_5XX;
1173         } else {
1174                 /* Unrecognised */
1175                 response_rc = -EIO_OTHER;
1176         }
1177         http->response.rc = response_rc;
1178         if ( response_rc )
1179                 DBGC ( http, "HTTP %p status %s\n", http, status );
1180
1181         return 0;
1182 }
1183
1184 /**
1185  * Parse HTTP header
1186  *
1187  * @v http              HTTP transaction
1188  * @v line              Header line
1189  * @ret rc              Return status code
1190  */
1191 static int http_parse_header ( struct http_transaction *http, char *line ) {
1192         struct http_response_header *header;
1193         char *name = line;
1194         char *sep;
1195
1196         DBGC2 ( http, "HTTP %p RX %s\n", http, line );
1197
1198         /* Extract header name */
1199         sep = strchr ( line, ':' );
1200         if ( ! sep ) {
1201                 DBGC ( http, "HTTP %p malformed header \"%s\"\n", http, line );
1202                 return -EINVAL_HEADER;
1203         }
1204         *sep = '\0';
1205
1206         /* Extract remainder of line */
1207         line = ( sep + 1 );
1208         while ( isspace ( *line ) )
1209                 line++;
1210
1211         /* Process header, if recognised */
1212         for_each_table_entry ( header, HTTP_RESPONSE_HEADERS ) {
1213                 if ( strcasecmp ( name, header->name ) == 0 )
1214                         return header->parse ( http, line );
1215         }
1216
1217         /* Unrecognised headers should be ignored */
1218         return 0;
1219 }
1220
1221 /**
1222  * Parse HTTP response headers
1223  *
1224  * @v http              HTTP transaction
1225  * @ret rc              Return status code
1226  */
1227 static int http_parse_headers ( struct http_transaction *http ) {
1228         char *line;
1229         char *next;
1230         int rc;
1231
1232         /* Get status line */
1233         line = http->response.headers.data;
1234         assert ( line != NULL );
1235         next = ( line + strlen ( line ) + 1 /* NUL */ );
1236
1237         /* Parse status line */
1238         if ( ( rc = http_parse_status ( http, line ) ) != 0 )
1239                 return rc;
1240
1241         /* Process header lines */
1242         while ( 1 ) {
1243
1244                 /* Move to next line */
1245                 line = next;
1246                 next = ( line + strlen ( line ) + 1 /* NUL */ );
1247
1248                 /* Stop on terminating blank line */
1249                 if ( ! line[0] )
1250                         return 0;
1251
1252                 /* Process header line */
1253                 if ( ( rc = http_parse_header ( http, line ) ) != 0 )
1254                         return rc;
1255         }
1256 }
1257
1258 /**
1259  * Parse HTTP "Location" header
1260  *
1261  * @v http              HTTP transaction
1262  * @v line              Remaining header line
1263  * @ret rc              Return status code
1264  */
1265 static int http_parse_location ( struct http_transaction *http, char *line ) {
1266
1267         /* Store location */
1268         http->response.location = line;
1269         return 0;
1270 }
1271
1272 /** HTTP "Location" header */
1273 struct http_response_header http_response_location __http_response_header = {
1274         .name = "Location",
1275         .parse = http_parse_location,
1276 };
1277
1278 /**
1279  * Parse HTTP "Transfer-Encoding" header
1280  *
1281  * @v http              HTTP transaction
1282  * @v line              Remaining header line
1283  * @ret rc              Return status code
1284  */
1285 static int http_parse_transfer_encoding ( struct http_transaction *http,
1286                                           char *line ) {
1287         struct http_transfer_encoding *encoding;
1288
1289         /* Check for known transfer encodings */
1290         for_each_table_entry ( encoding, HTTP_TRANSFER_ENCODINGS ) {
1291                 if ( strcasecmp ( line, encoding->name ) == 0 ) {
1292                         http->response.transfer.encoding = encoding;
1293                         return 0;
1294                 }
1295         }
1296
1297         DBGC ( http, "HTTP %p unrecognised Transfer-Encoding \"%s\"\n",
1298                http, line );
1299         return -ENOTSUP_TRANSFER;
1300 }
1301
1302 /** HTTP "Transfer-Encoding" header */
1303 struct http_response_header
1304 http_response_transfer_encoding __http_response_header = {
1305         .name = "Transfer-Encoding",
1306         .parse = http_parse_transfer_encoding,
1307 };
1308
1309 /**
1310  * Parse HTTP "Connection" header
1311  *
1312  * @v http              HTTP transaction
1313  * @v line              Remaining header line
1314  * @ret rc              Return status code
1315  */
1316 static int http_parse_connection ( struct http_transaction *http, char *line ) {
1317         char *token;
1318
1319         /* Check for known connection intentions */
1320         while ( ( token = http_token ( &line, NULL ) ) ) {
1321                 if ( strcasecmp ( token, "keep-alive" ) == 0 )
1322                         http->response.flags |= HTTP_RESPONSE_KEEPALIVE;
1323                 if ( strcasecmp ( token, "close" ) == 0 )
1324                         http->response.flags &= ~HTTP_RESPONSE_KEEPALIVE;
1325         }
1326
1327         return 0;
1328 }
1329
1330 /** HTTP "Connection" header */
1331 struct http_response_header http_response_connection __http_response_header = {
1332         .name = "Connection",
1333         .parse = http_parse_connection,
1334 };
1335
1336 /**
1337  * Parse HTTP "Content-Length" header
1338  *
1339  * @v http              HTTP transaction
1340  * @v line              Remaining header line
1341  * @ret rc              Return status code
1342  */
1343 static int http_parse_content_length ( struct http_transaction *http,
1344                                        char *line ) {
1345         char *endp;
1346
1347         /* Parse length */
1348         http->response.content.len = strtoul ( line, &endp, 10 );
1349         if ( *endp != '\0' ) {
1350                 DBGC ( http, "HTTP %p invalid Content-Length \"%s\"\n",
1351                        http, line );
1352                 return -EINVAL_CONTENT_LENGTH;
1353         }
1354
1355         /* Record that we have a content length (since it may be zero) */
1356         http->response.flags |= HTTP_RESPONSE_CONTENT_LEN;
1357
1358         return 0;
1359 }
1360
1361 /** HTTP "Content-Length" header */
1362 struct http_response_header
1363 http_response_content_length __http_response_header = {
1364         .name = "Content-Length",
1365         .parse = http_parse_content_length,
1366 };
1367
1368 /**
1369  * Parse HTTP "Content-Encoding" header
1370  *
1371  * @v http              HTTP transaction
1372  * @v line              Remaining header line
1373  * @ret rc              Return status code
1374  */
1375 static int http_parse_content_encoding ( struct http_transaction *http,
1376                                          char *line ) {
1377         struct http_content_encoding *encoding;
1378
1379         /* Check for known content encodings */
1380         for_each_table_entry ( encoding, HTTP_CONTENT_ENCODINGS ) {
1381                 if ( encoding->supported && ( ! encoding->supported ( http ) ) )
1382                         continue;
1383                 if ( strcasecmp ( line, encoding->name ) == 0 ) {
1384                         http->response.content.encoding = encoding;
1385                         return 0;
1386                 }
1387         }
1388
1389         /* Some servers (e.g. Apache) have a habit of specifying
1390          * unwarranted content encodings.  For example, if Apache
1391          * detects (via /etc/httpd/conf/magic) that a file's contents
1392          * are gzip-compressed, it will set "Content-Encoding: x-gzip"
1393          * regardless of the client's Accept-Encoding header.  The
1394          * only viable way to handle such servers is to treat unknown
1395          * content encodings as equivalent to "identity".
1396          */
1397         DBGC ( http, "HTTP %p unrecognised Content-Encoding \"%s\"\n",
1398                http, line );
1399         return 0;
1400 }
1401
1402 /** HTTP "Content-Encoding" header */
1403 struct http_response_header
1404 http_response_content_encoding __http_response_header = {
1405         .name = "Content-Encoding",
1406         .parse = http_parse_content_encoding,
1407 };
1408
1409 /**
1410  * Parse HTTP "Retry-After" header
1411  *
1412  * @v http              HTTP transaction
1413  * @v line              Remaining header line
1414  * @ret rc              Return status code
1415  */
1416 static int http_parse_retry_after ( struct http_transaction *http,
1417                                     char *line ) {
1418         char *endp;
1419
1420         /* Try to parse value as a simple number of seconds */
1421         http->response.retry_after = strtoul ( line, &endp, 10 );
1422         if ( *endp != '\0' ) {
1423                 /* For any value which is not a simple number of
1424                  * seconds (e.g. a full HTTP date), just retry after a
1425                  * fixed delay, since we don't have code able to parse
1426                  * full HTTP dates.
1427                  */
1428                 http->response.retry_after = HTTP_RETRY_SECONDS;
1429                 DBGC ( http, "HTTP %p cannot understand Retry-After \"%s\"; "
1430                        "using %d seconds\n", http, line, HTTP_RETRY_SECONDS );
1431         }
1432
1433         /* Allow HTTP request to be retried after specified delay */
1434         http->response.flags |= HTTP_RESPONSE_RETRY;
1435
1436         return 0;
1437 }
1438
1439 /** HTTP "Retry-After" header */
1440 struct http_response_header http_response_retry_after __http_response_header = {
1441         .name = "Retry-After",
1442         .parse = http_parse_retry_after,
1443 };
1444
1445 /**
1446  * Handle received HTTP headers
1447  *
1448  * @v http              HTTP transaction
1449  * @v iobuf             I/O buffer (may be claimed)
1450  * @ret rc              Return status code
1451  */
1452 static int http_rx_headers ( struct http_transaction *http,
1453                              struct io_buffer **iobuf ) {
1454         struct http_transfer_encoding *transfer;
1455         struct http_content_encoding *content;
1456         char *line;
1457         int rc;
1458
1459         /* Buffer header line */
1460         if ( ( rc = http_rx_linebuf ( http, *iobuf,
1461                                       &http->response.headers ) ) != 0 )
1462                 return rc;
1463
1464         /* Wait until we see the empty line marking end of headers */
1465         line = buffered_line ( &http->response.headers );
1466         if ( ( line == NULL ) || ( line[0] != '\0' ) )
1467                 return 0;
1468
1469         /* Process headers */
1470         if ( ( rc = http_parse_headers ( http ) ) != 0 )
1471                 return rc;
1472
1473         /* Initialise content encoding, if applicable */
1474         if ( ( content = http->response.content.encoding ) &&
1475              ( ( rc = content->init ( http ) ) != 0 ) ) {
1476                 DBGC ( http, "HTTP %p could not initialise %s content "
1477                        "encoding: %s\n", http, content->name, strerror ( rc ) );
1478                 return rc;
1479         }
1480
1481         /* Presize receive buffer, if we have a content length */
1482         if ( http->response.content.len ) {
1483                 xfer_seek ( &http->transfer, http->response.content.len );
1484                 xfer_seek ( &http->transfer, 0 );
1485         }
1486
1487         /* Complete transfer if this is a HEAD request */
1488         if ( http->request.method == &http_head ) {
1489                 if ( ( rc = http_transfer_complete ( http ) ) != 0 )
1490                         return rc;
1491                 return 0;
1492         }
1493
1494         /* Default to identity transfer encoding, if none specified */
1495         if ( ! http->response.transfer.encoding )
1496                 http->response.transfer.encoding = &http_transfer_identity;
1497
1498         /* Move to transfer encoding-specific data state */
1499         transfer = http->response.transfer.encoding;
1500         http->state = &transfer->state;
1501
1502         /* Initialise transfer encoding */
1503         if ( ( rc = transfer->init ( http ) ) != 0 ) {
1504                 DBGC ( http, "HTTP %p could not initialise %s transfer "
1505                        "encoding: %s\n", http, transfer->name, strerror ( rc ));
1506                 return rc;
1507         }
1508
1509         return 0;
1510 }
1511
1512 /** HTTP response headers state */
1513 static struct http_state http_headers = {
1514         .rx = http_rx_headers,
1515         .close = http_close_error,
1516 };
1517
1518 /******************************************************************************
1519  *
1520  * Identity transfer encoding
1521  *
1522  ******************************************************************************
1523  */
1524
1525 /**
1526  * Initialise transfer encoding
1527  *
1528  * @v http              HTTP transaction
1529  * @ret rc              Return status code
1530  */
1531 static int http_init_transfer_identity ( struct http_transaction *http ) {
1532         int rc;
1533
1534         /* Complete transfer immediately if we have a zero content length */
1535         if ( ( http->response.flags & HTTP_RESPONSE_CONTENT_LEN ) &&
1536              ( http->response.content.len == 0 ) &&
1537              ( ( rc = http_transfer_complete ( http ) ) != 0 ) )
1538                 return rc;
1539
1540         return 0;
1541 }
1542
1543 /**
1544  * Handle received data
1545  *
1546  * @v http              HTTP transaction
1547  * @v iobuf             I/O buffer (may be claimed)
1548  * @ret rc              Return status code
1549  */
1550 static int http_rx_transfer_identity ( struct http_transaction *http,
1551                                        struct io_buffer **iobuf ) {
1552         size_t len = iob_len ( *iobuf );
1553         int rc;
1554
1555         /* Update lengths */
1556         http->len += len;
1557
1558         /* Fail if this transfer would overrun the expected content
1559          * length (if any).
1560          */
1561         if ( ( http->response.flags & HTTP_RESPONSE_CONTENT_LEN ) &&
1562              ( http->len > http->response.content.len ) ) {
1563                 DBGC ( http, "HTTP %p content length overrun\n", http );
1564                 return -EIO_CONTENT_LENGTH;
1565         }
1566
1567         /* Hand off to content encoding */
1568         if ( ( rc = xfer_deliver_iob ( &http->transfer,
1569                                        iob_disown ( *iobuf ) ) ) != 0 )
1570                 return rc;
1571
1572         /* Complete transfer if we have received the expected content
1573          * length (if any).
1574          */
1575         if ( ( http->response.flags & HTTP_RESPONSE_CONTENT_LEN ) &&
1576              ( http->len == http->response.content.len ) &&
1577              ( ( rc = http_transfer_complete ( http ) ) != 0 ) )
1578                 return rc;
1579
1580         return 0;
1581 }
1582
1583 /**
1584  * Handle server connection close
1585  *
1586  * @v http              HTTP transaction
1587  * @v rc                Reason for close
1588  */
1589 static void http_close_transfer_identity ( struct http_transaction *http,
1590                                            int rc ) {
1591
1592         /* Fail if any error occurred */
1593         if ( rc != 0 )
1594                 goto err;
1595
1596         /* Fail if we have a content length (since we would have
1597          * already closed the connection if we had received the
1598          * correct content length).
1599          */
1600         if ( http->response.flags & HTTP_RESPONSE_CONTENT_LEN ) {
1601                 DBGC ( http, "HTTP %p content length underrun\n", http );
1602                 rc = EIO_CONTENT_LENGTH;
1603                 goto err;
1604         }
1605
1606         /* Indicate that transfer is complete */
1607         if ( ( rc = http_transfer_complete ( http ) ) != 0 )
1608                 goto err;
1609
1610         return;
1611
1612  err:
1613         http_close ( http, rc );
1614 }
1615
1616 /** Identity transfer encoding */
1617 static struct http_transfer_encoding http_transfer_identity = {
1618         .name = "identity",
1619         .init = http_init_transfer_identity,
1620         .state = {
1621                 .rx = http_rx_transfer_identity,
1622                 .close = http_close_transfer_identity,
1623         },
1624 };
1625
1626 /******************************************************************************
1627  *
1628  * Chunked transfer encoding
1629  *
1630  ******************************************************************************
1631  */
1632
1633 /**
1634  * Initialise transfer encoding
1635  *
1636  * @v http              HTTP transaction
1637  * @ret rc              Return status code
1638  */
1639 static int http_init_transfer_chunked ( struct http_transaction *http ) {
1640
1641         /* Sanity checks */
1642         assert ( http->remaining == 0 );
1643         assert ( http->linebuf.len == 0 );
1644
1645         return 0;
1646 }
1647
1648 /**
1649  * Handle received chunk length
1650  *
1651  * @v http              HTTP transaction
1652  * @v iobuf             I/O buffer (may be claimed)
1653  * @ret rc              Return status code
1654  */
1655 static int http_rx_chunk_len ( struct http_transaction *http,
1656                                struct io_buffer **iobuf ) {
1657         char *line;
1658         char *endp;
1659         size_t len;
1660         int rc;
1661
1662         /* Receive into temporary line buffer */
1663         if ( ( rc = http_rx_linebuf ( http, *iobuf, &http->linebuf ) ) != 0 )
1664                 return rc;
1665
1666         /* Wait until we receive a non-empty line */
1667         line = buffered_line ( &http->linebuf );
1668         if ( ( line == NULL ) || ( line[0] == '\0' ) )
1669                 return 0;
1670
1671         /* Parse chunk length */
1672         http->remaining = strtoul ( line, &endp, 16 );
1673         if ( *endp != '\0' ) {
1674                 DBGC ( http, "HTTP %p invalid chunk length \"%s\"\n",
1675                        http, line );
1676                 return -EINVAL_CHUNK_LENGTH;
1677         }
1678
1679         /* Empty line buffer */
1680         empty_line_buffer ( &http->linebuf );
1681
1682         /* Update expected length */
1683         len = ( http->len + http->remaining );
1684         xfer_seek ( &http->transfer, len );
1685         xfer_seek ( &http->transfer, http->len );
1686
1687         /* If chunk length is zero, then move to response trailers state */
1688         if ( ! http->remaining )
1689                 http->state = &http_trailers;
1690
1691         return 0;
1692 }
1693
1694 /**
1695  * Handle received chunk data
1696  *
1697  * @v http              HTTP transaction
1698  * @v iobuf             I/O buffer (may be claimed)
1699  * @ret rc              Return status code
1700  */
1701 static int http_rx_chunk_data ( struct http_transaction *http,
1702                                 struct io_buffer **iobuf ) {
1703         struct io_buffer *payload;
1704         uint8_t *crlf;
1705         size_t len;
1706         int rc;
1707
1708         /* In the common case of a final chunk in a packet which also
1709          * includes the terminating CRLF, strip the terminating CRLF
1710          * (which we would ignore anyway) and hence avoid
1711          * unnecessarily copying the data.
1712          */
1713         if ( iob_len ( *iobuf ) == ( http->remaining + 2 /* CRLF */ ) ) {
1714                 crlf = ( (*iobuf)->data + http->remaining );
1715                 if ( ( crlf[0] == '\r' ) && ( crlf[1] == '\n' ) )
1716                         iob_unput ( (*iobuf), 2 /* CRLF */ );
1717         }
1718         len = iob_len ( *iobuf );
1719
1720         /* Use whole/partial buffer as applicable */
1721         if ( len <= http->remaining ) {
1722
1723                 /* Whole buffer is to be consumed: decrease remaining
1724                  * length and use original I/O buffer as payload.
1725                  */
1726                 payload = iob_disown ( *iobuf );
1727                 http->len += len;
1728                 http->remaining -= len;
1729
1730         } else {
1731
1732                 /* Partial buffer is to be consumed: copy data to a
1733                  * temporary I/O buffer.
1734                  */
1735                 payload = alloc_iob ( http->remaining );
1736                 if ( ! payload ) {
1737                         rc = -ENOMEM;
1738                         goto err;
1739                 }
1740                 memcpy ( iob_put ( payload, http->remaining ), (*iobuf)->data,
1741                          http->remaining );
1742                 iob_pull ( *iobuf, http->remaining );
1743                 http->len += http->remaining;
1744                 http->remaining = 0;
1745         }
1746
1747         /* Hand off to content encoding */
1748         if ( ( rc = xfer_deliver_iob ( &http->transfer,
1749                                        iob_disown ( payload ) ) ) != 0 )
1750                 goto err;
1751
1752         return 0;
1753
1754  err:
1755         assert ( payload == NULL );
1756         return rc;
1757 }
1758
1759 /**
1760  * Handle received chunked data
1761  *
1762  * @v http              HTTP transaction
1763  * @v iobuf             I/O buffer (may be claimed)
1764  * @ret rc              Return status code
1765  */
1766 static int http_rx_transfer_chunked ( struct http_transaction *http,
1767                                       struct io_buffer **iobuf ) {
1768
1769         /* Handle as chunk length or chunk data as appropriate */
1770         if ( http->remaining ) {
1771                 return http_rx_chunk_data ( http, iobuf );
1772         } else {
1773                 return http_rx_chunk_len ( http, iobuf );
1774         }
1775 }
1776
1777 /** Chunked transfer encoding */
1778 struct http_transfer_encoding http_transfer_chunked __http_transfer_encoding = {
1779         .name = "chunked",
1780         .init = http_init_transfer_chunked,
1781         .state = {
1782                 .rx = http_rx_transfer_chunked,
1783                 .close = http_close_error,
1784         },
1785 };
1786
1787 /******************************************************************************
1788  *
1789  * Response trailers
1790  *
1791  ******************************************************************************
1792  */
1793
1794 /**
1795  * Handle received HTTP trailer
1796  *
1797  * @v http              HTTP transaction
1798  * @v iobuf             I/O buffer (may be claimed)
1799  * @ret rc              Return status code
1800  */
1801 static int http_rx_trailers ( struct http_transaction *http,
1802                               struct io_buffer **iobuf ) {
1803         char *line;
1804         int rc;
1805
1806         /* Buffer trailer line */
1807         if ( ( rc = http_rx_linebuf ( http, *iobuf, &http->linebuf ) ) != 0 )
1808                 return rc;
1809
1810         /* Wait until we see the empty line marking end of trailers */
1811         line = buffered_line ( &http->linebuf );
1812         if ( ( line == NULL ) || ( line[0] != '\0' ) )
1813                 return 0;
1814
1815         /* Empty line buffer */
1816         empty_line_buffer ( &http->linebuf );
1817
1818         /* Transfer is complete */
1819         if ( ( rc = http_transfer_complete ( http ) ) != 0 )
1820                 return rc;
1821
1822         return 0;
1823 }
1824
1825 /** HTTP response trailers state */
1826 static struct http_state http_trailers = {
1827         .rx = http_rx_trailers,
1828         .close = http_close_error,
1829 };
1830
1831 /******************************************************************************
1832  *
1833  * Simple URI openers
1834  *
1835  ******************************************************************************
1836  */
1837
1838 /**
1839  * Construct HTTP parameter list
1840  *
1841  * @v params            Parameter list
1842  * @v buf               Buffer to contain HTTP POST parameters
1843  * @v len               Length of buffer
1844  * @ret len             Length of parameter list (excluding terminating NUL)
1845  */
1846 static size_t http_params ( struct parameters *params, char *buf, size_t len ) {
1847         struct parameter *param;
1848         ssize_t remaining = len;
1849         size_t frag_len;
1850
1851         /* Add each parameter in the form "key=value", joined with "&" */
1852         len = 0;
1853         for_each_param ( param, params ) {
1854
1855                 /* Add the "&", if applicable */
1856                 if ( len ) {
1857                         if ( remaining > 0 )
1858                                 *buf = '&';
1859                         buf++;
1860                         len++;
1861                         remaining--;
1862                 }
1863
1864                 /* URI-encode the key */
1865                 frag_len = uri_encode_string ( 0, param->key, buf, remaining );
1866                 buf += frag_len;
1867                 len += frag_len;
1868                 remaining -= frag_len;
1869
1870                 /* Add the "=" */
1871                 if ( remaining > 0 )
1872                         *buf = '=';
1873                 buf++;
1874                 len++;
1875                 remaining--;
1876
1877                 /* URI-encode the value */
1878                 frag_len = uri_encode_string ( 0, param->value, buf, remaining);
1879                 buf += frag_len;
1880                 len += frag_len;
1881                 remaining -= frag_len;
1882         }
1883
1884         /* Ensure string is NUL-terminated even if no parameters are present */
1885         if ( remaining > 0 )
1886                 *buf = '\0';
1887
1888         return len;
1889 }
1890
1891 /**
1892  * Open HTTP transaction for simple GET URI
1893  *
1894  * @v xfer              Data transfer interface
1895  * @v uri               Request URI
1896  * @ret rc              Return status code
1897  */
1898 static int http_open_get_uri ( struct interface *xfer, struct uri *uri ) {
1899
1900         return http_open ( xfer, &http_get, uri, NULL, NULL );
1901 }
1902
1903 /**
1904  * Open HTTP transaction for simple POST URI
1905  *
1906  * @v xfer              Data transfer interface
1907  * @v uri               Request URI
1908  * @ret rc              Return status code
1909  */
1910 static int http_open_post_uri ( struct interface *xfer, struct uri *uri ) {
1911         struct parameters *params = uri->params;
1912         struct http_request_content content;
1913         void *data;
1914         size_t len;
1915         size_t check_len;
1916         int rc;
1917
1918         /* Calculate length of parameter list */
1919         len = http_params ( params, NULL, 0 );
1920
1921         /* Allocate temporary parameter list */
1922         data = zalloc ( len + 1 /* NUL */ );
1923         if ( ! data ) {
1924                 rc = -ENOMEM;
1925                 goto err_alloc;
1926         }
1927
1928         /* Construct temporary parameter list */
1929         check_len = http_params ( params, data, ( len + 1 /* NUL */ ) );
1930         assert ( check_len == len );
1931
1932         /* Construct request content */
1933         content.type = "application/x-www-form-urlencoded";
1934         content.data = data;
1935         content.len = len;
1936
1937         /* Open HTTP transaction */
1938         if ( ( rc = http_open ( xfer, &http_post, uri, NULL, &content ) ) != 0 )
1939                 goto err_open;
1940
1941  err_open:
1942         free ( data );
1943  err_alloc:
1944         return rc;
1945 }
1946
1947 /**
1948  * Open HTTP transaction for simple URI
1949  *
1950  * @v xfer              Data transfer interface
1951  * @v uri               Request URI
1952  * @ret rc              Return status code
1953  */
1954 int http_open_uri ( struct interface *xfer, struct uri *uri ) {
1955
1956         /* Open GET/POST URI as applicable */
1957         if ( uri->params ) {
1958                 return http_open_post_uri ( xfer, uri );
1959         } else {
1960                 return http_open_get_uri ( xfer, uri );
1961         }
1962 }
1963
1964 /* Drag in HTTP extensions */
1965 REQUIRING_SYMBOL ( http_open );
1966 REQUIRE_OBJECT ( config_http );