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 <stddef.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/async.h>
  35 #include <gpxe/uri.h>
  36 #include <gpxe/buffer.h>
  37 #include <gpxe/download.h>
  38 #include <gpxe/resolv.h>
  39 #include <gpxe/tcp.h>
  40 #include <gpxe/tls.h>
  41 #include <gpxe/http.h>
  42
  43 static struct async_operations http_async_operations;
  44
  45 static inline struct http_request *
  46 stream_to_http ( struct stream_application *app ) {
  47         return container_of ( app, struct http_request, stream );
  48 }
  49
  50 /**
  51  * Mark HTTP request as complete
  52  *
  53  * @v http              HTTP request
  54  * @v rc                Return status code
  55  *
  56  */
  57 static void http_done ( struct http_request *http, int rc ) {
  58
  59         /* Close stream connection */
  60         stream_close ( &http->stream );
  61
  62         /* Prevent further processing of any current packet */
  63         http->rx_state = HTTP_RX_DEAD;
  64
  65         /* Free up any dynamically allocated storage */
  66         empty_line_buffer ( &http->linebuf );
  67
  68         /* If we had a Content-Length, and the received content length
  69          * isn't correct, flag an error
  70          */
  71         if ( http->content_length &&
  72              ( http->content_length != http->buffer->fill ) ) {
  73                 DBGC ( http, "HTTP %p incorrect length %zd, should be %zd\n",
  74                        http, http->buffer->fill, http->content_length );
  75                 rc = -EIO;
  76         }
  77
  78         /* Mark async operation as complete */
  79         async_done ( &http->async, rc );
  80 }
  81
  82 /**
  83  * Convert HTTP response code to return status code
  84  *
  85  * @v response          HTTP response code
  86  * @ret rc              Return status code
  87  */
  88 static int http_response_to_rc ( unsigned int response ) {
  89         switch ( response ) {
  90         case 200:
  91                 return 0;
  92         case 404:
  93                 return -ENOENT;
  94         case 403:
  95                 return -EPERM;
  96         default:
  97                 return -EIO;
  98         }
  99 }
 100
 101 /**
 102  * Handle HTTP response
 103  *
 104  * @v http              HTTP request
 105  * @v response          HTTP response
 106  */
 107 static void http_rx_response ( struct http_request *http, char *response ) {
 108         char *spc;
 109         int rc = -EIO;
 110
 111         DBGC ( http, "HTTP %p response \"%s\"\n", http, response );
 112
 113         /* Check response starts with "HTTP/" */
 114         if ( strncmp ( response, "HTTP/", 5 ) != 0 )
 115                 goto err;
 116
 117         /* Locate and check response code */
 118         spc = strchr ( response, ' ' );
 119         if ( ! spc )
 120                 goto err;
 121         http->response = strtoul ( spc, NULL, 10 );
 122         if ( ( rc = http_response_to_rc ( http->response ) ) != 0 )
 123                 goto err;
 124
 125         /* Move to received headers */
 126         http->rx_state = HTTP_RX_HEADER;
 127         return;
 128
 129  err:
 130         DBGC ( http, "HTTP %p bad response\n", http );
 131         http_done ( http, rc );
 132         return;
 133 }
 134
 135 /**
 136  * Handle HTTP Content-Length header
 137  *
 138  * @v http              HTTP request
 139  * @v value             HTTP header value
 140  * @ret rc              Return status code
 141  */
 142 static int http_rx_content_length ( struct http_request *http,
 143                                     const char *value ) {
 144         char *endp;
 145         int rc;
 146
 147         http->content_length = strtoul ( value, &endp, 10 );
 148         if ( *endp != '\0' ) {
 149                 DBGC ( http, "HTTP %p invalid Content-Length \"%s\"\n",
 150                        http, value );
 151                 return -EIO;
 152         }
 153
 154         /* Try to presize the receive buffer */
 155         if ( ( rc = expand_buffer ( http->buffer,
 156                                     http->content_length ) ) != 0 ) {
 157                 /* May as well abandon the download now; it will fail */
 158                 DBGC ( http, "HTTP %p could not presize buffer: %s\n",
 159                        http, strerror ( rc ) );
 160                 return rc;
 161         }
 162
 163         return 0;
 164 }
 165
 166 /**
 167  * An HTTP header handler
 168  *
 169  */
 170 struct http_header_handler {
 171         /** Name (e.g. "Content-Length") */
 172         const char *header;
 173         /** Handle received header
 174          *
 175          * @v http      HTTP request
 176          * @v value     HTTP header value
 177          * @ret rc      Return status code
 178          *
 179          * If an error is returned, the download will be aborted.
 180          */
 181         int ( * rx ) ( struct http_request *http, const char *value );
 182 };
 183
 184 /** List of HTTP header handlers */
 185 struct http_header_handler http_header_handlers[] = {
 186         {
 187                 .header = "Content-Length",
 188                 .rx = http_rx_content_length,
 189         },
 190         { NULL, NULL }
 191 };
 192
 193 /**
 194  * Handle HTTP header
 195  *
 196  * @v http              HTTP request
 197  * @v header            HTTP header
 198  */
 199 static void http_rx_header ( struct http_request *http, char *header ) {
 200         struct http_header_handler *handler;
 201         char *separator;
 202         char *value;
 203         int rc = -EIO;
 204
 205         /* An empty header line marks the transition to the data phase */
 206         if ( ! header[0] ) {
 207                 DBGC ( http, "HTTP %p start of data\n", http );
 208                 empty_line_buffer ( &http->linebuf );
 209                 http->rx_state = HTTP_RX_DATA;
 210                 return;
 211         }
 212
 213         DBGC ( http, "HTTP %p header \"%s\"\n", http, header );
 214
 215         /* Split header at the ": " */
 216         separator = strstr ( header, ": " );
 217         if ( ! separator )
 218                 goto err;
 219         *separator = '\0';
 220         value = ( separator + 2 );
 221
 222         /* Hand off to header handler, if one exists */
 223         for ( handler = http_header_handlers ; handler->header ; handler++ ) {
 224                 if ( strcasecmp ( header, handler->header ) == 0 ) {
 225                         if ( ( rc = handler->rx ( http, value ) ) != 0 )
 226                                 goto err;
 227                         break;
 228                 }
 229         }
 230         return;
 231
 232  err:
 233         DBGC ( http, "HTTP %p bad header\n", http );
 234         http_done ( http, rc );
 235         return;
 236 }
 237
 238 /**
 239  * Handle new data arriving via HTTP connection in the data phase
 240  *
 241  * @v http              HTTP request
 242  * @v data              New data
 243  * @v len               Length of new data
 244  */
 245 static void http_rx_data ( struct http_request *http,
 246                            const char *data, size_t len ) {
 247         int rc;
 248
 249         /* Fill data buffer */
 250         if ( ( rc = fill_buffer ( http->buffer, data,
 251                                   http->buffer->fill, len ) ) != 0 ) {
 252                 DBGC ( http, "HTTP %p failed to fill data buffer: %s\n",
 253                        http, strerror ( rc ) );
 254                 http_done ( http, rc );
 255                 return;
 256         }
 257
 258         /* Update progress */
 259         http->async.completed = http->buffer->fill;
 260         http->async.total = http->content_length;
 261
 262         /* If we have reached the content-length, stop now */
 263         if ( http->content_length &&
 264              ( http->buffer->fill >= http->content_length ) ) {
 265                 http_done ( http, 0 );
 266         }
 267 }
 268
 269 /**
 270  * Handle new data arriving via HTTP connection
 271  *
 272  * @v http              HTTP request
 273  * @v data              New data
 274  * @v len               Length of new data
 275  */
 276 static void http_newdata ( struct stream_application *app,
 277                            void *data, size_t len ) {
 278         struct http_request *http = stream_to_http ( app );
 279         const char *buf = data;
 280         char *line;
 281         int rc;
 282
 283         while ( len ) {
 284                 if ( http->rx_state == HTTP_RX_DEAD ) {
 285                         /* Do no further processing */
 286                         return;
 287                 } else if ( http->rx_state == HTTP_RX_DATA ) {
 288                         /* Once we're into the data phase, just fill
 289                          * the data buffer
 290                          */
 291                         http_rx_data ( http, buf, len );
 292                         return;
 293                 } else {
 294                         /* In the other phases, buffer and process a
 295                          * line at a time
 296                          */
 297                         if ( ( rc = line_buffer ( &http->linebuf, &buf,
 298                                                   &len ) ) != 0 ) {
 299                                 DBGC ( http, "HTTP %p could not buffer line: "
 300                                        "%s\n", http, strerror ( rc ) );
 301                                 http_done ( http, rc );
 302                                 return;
 303                         }
 304                         if ( ( line = buffered_line ( &http->linebuf ) ) ) {
 305                                 switch ( http->rx_state ) {
 306                                 case HTTP_RX_RESPONSE:
 307                                         http_rx_response ( http, line );
 308                                         break;
 309                                 case HTTP_RX_HEADER:
 310                                         http_rx_header ( http, line );
 311                                         break;
 312                                 default:
 313                                         assert ( 0 );
 314                                         break;
 315                                 }
 316                         }
 317                 }
 318         }
 319 }
 320
 321 /**
 322  * Send HTTP data
 323  *
 324  * @v app               Stream application
 325  * @v buf               Temporary data buffer
 326  * @v len               Length of temporary data buffer
 327  */
 328 static void http_senddata ( struct stream_application *app,
 329                             void *buf, size_t len ) {
 330         struct http_request *http = stream_to_http ( app );
 331         const char *path = http->uri->path;
 332         const char *host = http->uri->host;
 333
 334         if ( ! path )
 335                 path = "/";
 336
 337         len = snprintf ( buf, len,
 338                          "GET %s HTTP/1.1\r\n"
 339                          "User-Agent: gPXE/" VERSION "\r\n"
 340                          "Host: %s\r\n"
 341                          "\r\n", path, host );
 342
 343         stream_send ( app, ( buf + http->tx_offset ),
 344                       ( len - http->tx_offset ) );
 345 }
 346
 347 /**
 348  * HTTP data acknowledged
 349  *
 350  * @v app               Stream application
 351  * @v len               Length of acknowledged data
 352  */
 353 static void http_acked ( struct stream_application *app, size_t len ) {
 354         struct http_request *http = stream_to_http ( app );
 355
 356         http->tx_offset += len;
 357 }
 358
 359 /**
 360  * HTTP connection closed by network stack
 361  *
 362  * @v app               Stream application
 363  */
 364 static void http_closed ( struct stream_application *app, int rc ) {
 365         struct http_request *http = stream_to_http ( app );
 366
 367         DBGC ( http, "HTTP %p connection closed: %s\n",
 368                http, strerror ( rc ) );
 369
 370         http_done ( http, rc );
 371 }
 372
 373 /** HTTP stream operations */
 374 static struct stream_application_operations http_stream_operations = {
 375         .closed         = http_closed,
 376         .acked          = http_acked,
 377         .newdata        = http_newdata,
 378         .senddata       = http_senddata,
 379 };
 380
 381 /**
 382  * Initiate a HTTP connection
 383  *
 384  * @v uri               Uniform Resource Identifier
 385  * @v buffer            Buffer into which to download file
 386  * @v parent            Parent asynchronous operation
 387  * @ret rc              Return status code
 388  */
 389 int http_get ( struct uri *uri, struct buffer *buffer, struct async *parent ) {
 390         struct http_request *http = NULL;
 391         struct sockaddr_tcpip *st;
 392         int rc;
 393
 394         /* Allocate and populate HTTP structure */
 395         http = malloc ( sizeof ( *http ) );
 396         if ( ! http )
 397                 return -ENOMEM;
 398         memset ( http, 0, sizeof ( *http ) );
 399         http->uri = uri;
 400         http->buffer = buffer;
 401         async_init ( &http->async, &http_async_operations, parent );
 402         http->stream.op = &http_stream_operations;
 403         st = ( struct sockaddr_tcpip * ) &http->server;
 404         st->st_port = htons ( uri_port ( http->uri, HTTP_PORT ) );
 405
 406         /* Open TCP connection */
 407         if ( ( rc = tcp_open ( &http->stream ) ) != 0 )
 408                 goto err;
 409         if ( strcmp ( http->uri->scheme, "https" ) == 0 ) {
 410                 st->st_port = htons ( uri_port ( http->uri, HTTPS_PORT ) );
 411                 if ( ( rc = add_tls ( &http->stream ) ) != 0 )
 412                         goto err;
 413         }
 414
 415         /* Start name resolution.  The download proper will start when
 416          * name resolution completes.
 417          */
 418         if ( ( rc = resolv ( uri->host, &http->server, &http->async ) ) != 0 )
 419                 goto err;
 420
 421         return 0;
 422
 423  err:
 424         DBGC ( http, "HTTP %p could not create request: %s\n",
 425                http, strerror ( rc ) );
 426         async_uninit ( &http->async );
 427         free ( http );
 428         return rc;
 429 }
 430
 431 /**
 432  * Handle name resolution completion
 433  *
 434  * @v async             HTTP asynchronous operation
 435  * @v signal            SIGCHLD
 436  */
 437 static void http_sigchld ( struct async *async, enum signal signal __unused ) {
 438         struct http_request *http =
 439                 container_of ( async, struct http_request, async );
 440         int rc;
 441
 442         /* If name resolution failed, abort now */
 443         async_wait ( async, &rc, 1 );
 444         if ( rc != 0 ) {
 445                 http_done ( http, rc );
 446                 return;
 447         }
 448
 449         /* Otherwise, start the HTTP connection */
 450         if ( ( rc = stream_connect ( &http->stream, &http->server ) ) != 0 ) {
 451                 DBGC ( http, "HTTP %p could not connect stream: %s\n",
 452                        http, strerror ( rc ) );
 453                 http_done ( http, rc );
 454                 return;
 455         }
 456 }
 457
 458 /**
 459  * Free HTTP connection
 460  *
 461  * @v async             Asynchronous operation
 462  */
 463 static void http_reap ( struct async *async ) {
 464         free ( container_of ( async, struct http_request, async ) );
 465 }
 466
 467 /** HTTP asynchronous operations */
 468 static struct async_operations http_async_operations = {
 469         .reap = http_reap,
 470         .signal = {
 471                 [SIGCHLD] = http_sigchld,
 472         },
 473 };
 474
 475 /** HTTP download protocol */
 476 struct download_protocol http_download_protocol __download_protocol = {
 477         .name = "http",
 478         .start_download = http_get,
 479 };
 480
 481 /** HTTPS download protocol */
 482 struct download_protocol https_download_protocol __download_protocol = {
 483         .name = "https",
 484         .start_download = http_get,
 485 };