http.c File Reference

Hyper Text Transfer Protocol (HTTP). More...

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <byteswap.h>
#include <errno.h>
#include <assert.h>
#include <gpxe/uri.h>
#include <gpxe/refcnt.h>
#include <gpxe/iobuf.h>
#include <gpxe/xfer.h>
#include <gpxe/open.h>
#include <gpxe/socket.h>
#include <gpxe/tcpip.h>
#include <gpxe/process.h>
#include <gpxe/linebuf.h>
#include <gpxe/features.h>
#include <gpxe/base64.h>
#include <gpxe/http.h>

Go to the source code of this file.

Data Structures
struct	http_request
	An HTTP request. More...
struct	http_header_handler
	An HTTP header handler. More...
struct	http_line_handler
	An HTTP line-based data handler. More...
Enumerations
enum	http_rx_state { HTTP_RX_RESPONSE = 0, HTTP_RX_HEADER, HTTP_RX_DATA, HTTP_RX_DEAD }
	HTTP receive state. More...
Functions
	FILE_LICENCE (GPL2_OR_LATER)
	FEATURE (FEATURE_PROTOCOL,"HTTP", DHCP_EB_FEATURE_HTTP, 1)
static void	http_free (struct refcnt *refcnt)
	Free HTTP request.
static void	http_done (struct http_request *http, int rc)
	Mark HTTP request as complete.
static int	http_response_to_rc (unsigned int response)
	Convert HTTP response code to return status code.
static int	http_rx_response (struct http_request *http, char *response)
	Handle HTTP response.
static int	http_rx_location (struct http_request *http, const char *value)
	Handle HTTP Location header.
static int	http_rx_content_length (struct http_request *http, const char *value)
	Handle HTTP Content-Length header.
static int	http_rx_header (struct http_request *http, char *header)
	Handle HTTP header.
static int	http_rx_data (struct http_request *http, struct io_buffer *iobuf)
	Handle new data arriving via HTTP connection in the data phase.
static int	http_socket_deliver_iob (struct xfer_interface *socket, struct io_buffer *iobuf, struct xfer_metadata *meta __unused)
	Handle new data arriving via HTTP connection.
static void	http_step (struct process *process)
	HTTP process.
static void	http_socket_close (struct xfer_interface *socket, int rc)
	HTTP connection closed by network stack.
static void	http_xfer_close (struct xfer_interface *xfer, int rc)
	Close HTTP data transfer interface.
int	http_open_filter (struct xfer_interface *xfer, struct uri *uri, unsigned int default_port, int(*filter)(struct xfer_interface *xfer, struct xfer_interface **next))
	Initiate an HTTP connection, with optional filter.
static int	http_open (struct xfer_interface *xfer, struct uri *uri)
	Initiate an HTTP connection.
Variables
static struct http_header_handler	http_header_handlers []
	List of HTTP header handlers.
static struct http_line_handler	http_line_handlers []
	List of HTTP line-based data handlers.
static struct xfer_interface_operations	http_socket_operations
	HTTP socket operations.
static struct xfer_interface_operations	http_xfer_operations
	HTTP data transfer interface operations.
struct uri_opener http_uri_opener	__uri_opener
	HTTP URI opener.

---

Detailed Description

Hyper Text Transfer Protocol (HTTP).

Definition in file http.c.

---

Enumeration Type Documentation

enum http_rx_state

HTTP receive state.

Enumerator:

HTTP_RX_RESPONSE
HTTP_RX_HEADER
HTTP_RX_DATA
HTTP_RX_DEAD

Definition at line 52 of file http.c.

                   {
        HTTP_RX_RESPONSE = 0,
        HTTP_RX_HEADER,
        HTTP_RX_DATA,
        HTTP_RX_DEAD,
};

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

FEATURE	(	FEATURE_PROTOCOL	,
		"HTTP"	,
		DHCP_EB_FEATURE_HTTP	,
		1
	)

static void http_free

(

struct refcnt *

refcnt

)

[static]

Free HTTP request.

Parameters:

refcnt

Reference counter

Definition at line 94 of file http.c.

References container_of, empty_line_buffer(), free(), http_request::linebuf, and http_request::uri.

Referenced by http_open_filter().

                                                {
        struct http_request *http =
                container_of ( refcnt, struct http_request, refcnt );

        uri_put ( http->uri );
        empty_line_buffer ( &http->linebuf );
        free ( http );
};

static void http_done	(	struct http_request *	http,
		int	rc
	)			[static]

Mark HTTP request as complete.

Parameters:

	http	HTTP request
	rc	Return status code

Definition at line 109 of file http.c.

References http_request::content_length, DBGC, EIO, HTTP_RX_DEAD, http_request::process, process_del(), http_request::rx_len, http_request::rx_state, http_request::socket, http_request::xfer, and xfer_close().

Referenced by http_open_filter(), http_rx_data(), http_socket_close(), http_socket_deliver_iob(), http_step(), and http_xfer_close().

                                                            {

        /* Prevent further processing of any current packet */
        http->rx_state = HTTP_RX_DEAD;

        /* If we had a Content-Length, and the received content length
         * isn't correct, flag an error
         */
        if ( http->content_length &&
             ( http->content_length != http->rx_len ) ) {
                DBGC ( http, "HTTP %p incorrect length %zd, should be %zd\n",
                       http, http->rx_len, http->content_length );
                rc = -EIO;
        }

        /* Remove process */
        process_del ( &http->process );

        /* Close all data transfer interfaces */
        xfer_nullify ( &http->socket );
        xfer_close ( &http->socket, rc );
        xfer_nullify ( &http->xfer );
        xfer_close ( &http->xfer, rc );
}

static int http_response_to_rc

(

unsigned int

response

)

[static]

Convert HTTP response code to return status code.

Parameters:

response

HTTP response code

Return values:

rc

Return status code

Definition at line 140 of file http.c.

References EACCES, EIO, ENOENT, and EPERM.

Referenced by http_rx_response().

                                                         {
        switch ( response ) {
        case 200:
        case 301:
        case 302:
                return 0;
        case 404:
                return -ENOENT;
        case 403:
                return -EPERM;
        case 401:
                return -EACCES;
        default:
                return -EIO;
        }
}

static int http_rx_response	(	struct http_request *	http,
		char *	response
	)			[static]

Handle HTTP response.

Parameters:

	http	HTTP request
	response	HTTP response

Return values:

rc

Return status code

Definition at line 164 of file http.c.

References DBGC, EIO, http_response_to_rc(), HTTP_RX_HEADER, NULL, http_request::response, http_request::rx_state, strchr(), strncmp(), and strtoul().

                                                                          {
        char *spc;
        int rc;

        DBGC ( http, "HTTP %p response \"%s\"\n", http, response );

        /* Check response starts with "HTTP/" */
        if ( strncmp ( response, "HTTP/", 5 ) != 0 )
                return -EIO;

        /* Locate and check response code */
        spc = strchr ( response, ' ' );
        if ( ! spc )
                return -EIO;
        http->response = strtoul ( spc, NULL, 10 );
        if ( ( rc = http_response_to_rc ( http->response ) ) != 0 )
                return rc;

        /* Move to received headers */
        http->rx_state = HTTP_RX_HEADER;
        return 0;
}

static int http_rx_location	(	struct http_request *	http,
		const char *	value
	)			[static]

Handle HTTP Location header.

Parameters:

	http	HTTP request
	value	HTTP header value

Return values:

rc

Return status code

Definition at line 194 of file http.c.

References DBGC, LOCATION_URI_STRING, strerror(), http_request::xfer, and xfer_redirect().

                                                                             {
        int rc;

        /* Redirect to new location */
        DBGC ( http, "HTTP %p redirecting to %s\n", http, value );
        if ( ( rc = xfer_redirect ( &http->xfer, LOCATION_URI_STRING,
                                    value ) ) != 0 ) {
                DBGC ( http, "HTTP %p could not redirect: %s\n",
                       http, strerror ( rc ) );
                return rc;
        }

        return 0;
}

static int http_rx_content_length	(	struct http_request *	http,
		const char *	value
	)			[static]

Handle HTTP Content-Length header.

Parameters:

	http	HTTP request
	value	HTTP header value

Return values:

rc

Return status code

Definition at line 216 of file http.c.

References http_request::content_length, DBGC, EIO, SEEK_SET, strtoul(), http_request::xfer, and xfer_seek().

                                                        {
        char *endp;

        http->content_length = strtoul ( value, &endp, 10 );
        if ( *endp != '\0' ) {
                DBGC ( http, "HTTP %p invalid Content-Length \"%s\"\n",
                       http, value );
                return -EIO;
        }

        /* Use seek() to notify recipient of filesize */
        xfer_seek ( &http->xfer, http->content_length, SEEK_SET );
        xfer_seek ( &http->xfer, 0, SEEK_SET );

        return 0;
}

static int http_rx_header	(	struct http_request *	http,
		char *	header
	)			[static]

Handle HTTP header.

Parameters:

	http	HTTP request
	header	HTTP header

Return values:

rc

Return status code

Definition at line 269 of file http.c.

References DBGC, EIO, empty_line_buffer(), http_header_handler::header, HTTP_RX_DATA, http_request::linebuf, http_header_handler::rx, http_request::rx_state, strcasecmp(), and strstr().

                                                                      {
        struct http_header_handler *handler;
        char *separator;
        char *value;
        int rc;

        /* An empty header line marks the transition to the data phase */
        if ( ! header[0] ) {
                DBGC ( http, "HTTP %p start of data\n", http );
                empty_line_buffer ( &http->linebuf );
                http->rx_state = HTTP_RX_DATA;
                return 0;
        }

        DBGC ( http, "HTTP %p header \"%s\"\n", http, header );

        /* Split header at the ": " */
        separator = strstr ( header, ": " );
        if ( ! separator ) {
                DBGC ( http, "HTTP %p malformed header\n", http );
                return -EIO;
        }
        *separator = '\0';
        value = ( separator + 2 );

        /* Hand off to header handler, if one exists */
        for ( handler = http_header_handlers ; handler->header ; handler++ ) {
                if ( strcasecmp ( header, handler->header ) == 0 ) {
                        if ( ( rc = handler->rx ( http, value ) ) != 0 )
                                return rc;
                        break;
                }
        }
        return 0;
}

static int http_rx_data	(	struct http_request *	http,
		struct io_buffer *	iobuf
	)			[static]

Handle new data arriving via HTTP connection in the data phase.

Parameters:

	http	HTTP request
	iobuf	I/O buffer

Return values:

rc

Return status code

Definition at line 329 of file http.c.

References http_request::content_length, http_done(), iob_len(), http_request::rx_len, http_request::xfer, and xfer_deliver_iob().

Referenced by http_socket_deliver_iob().

                                                    {
        int rc;

        /* Update received length */
        http->rx_len += iob_len ( iobuf );

        /* Hand off data buffer */
        if ( ( rc = xfer_deliver_iob ( &http->xfer, iobuf ) ) != 0 )
                return rc;

        /* If we have reached the content-length, stop now */
        if ( http->content_length &&
             ( http->rx_len >= http->content_length ) ) {
                http_done ( http, 0 );
        }

        return 0;
}

static int http_socket_deliver_iob	(	struct xfer_interface *	socket,
		struct io_buffer *	iobuf,
		struct xfer_metadata *meta	__unused
	)			[static]

Handle new data arriving via HTTP connection.

Parameters:

	socket	Transport layer interface
	iobuf	I/O buffer
	meta	Data transfer metadata

Return values:

rc

Return status code

Definition at line 357 of file http.c.

References assert, buffered_line(), container_of, io_buffer::data, DBGC, free_iob(), http_done(), http_rx_data(), HTTP_RX_DATA, HTTP_RX_DEAD, HTTP_RX_HEADER, HTTP_RX_RESPONSE, iob_disown, iob_len(), iob_pull, line_buffer(), http_request::linebuf, http_line_handler::rx, http_request::rx_state, and strerror().

                                                                           {
        struct http_request *http =
                container_of ( socket, struct http_request, socket );
        struct http_line_handler *lh;
        char *line;
        ssize_t len;
        int rc = 0;

        while ( iob_len ( iobuf ) ) {
                switch ( http->rx_state ) {
                case HTTP_RX_DEAD:
                        /* Do no further processing */
                        goto done;
                case HTTP_RX_DATA:
                        /* Once we're into the data phase, just fill
                         * the data buffer
                         */
                        rc = http_rx_data ( http, iob_disown ( iobuf ) );
                        goto done;
                case HTTP_RX_RESPONSE:
                case HTTP_RX_HEADER:
                        /* In the other phases, buffer and process a
                         * line at a time
                         */
                        len = line_buffer ( &http->linebuf, iobuf->data,
                                            iob_len ( iobuf ) );
                        if ( len < 0 ) {
                                rc = len;
                                DBGC ( http, "HTTP %p could not buffer line: "
                                       "%s\n", http, strerror ( rc ) );
                                goto done;
                        }
                        iob_pull ( iobuf, len );
                        line = buffered_line ( &http->linebuf );
                        if ( line ) {
                                lh = &http_line_handlers[http->rx_state];
                                if ( ( rc = lh->rx ( http, line ) ) != 0 )
                                        goto done;
                        }
                        break;
                default:
                        assert ( 0 );
                        break;
                }
        }

 done:
        if ( rc )
                http_done ( http, rc );
        free_iob ( iobuf );
        return rc;
}

static void http_step

(

struct process *

process

)

[static]

HTTP process.

Parameters:

process

Process

Definition at line 417 of file http.c.

References base64_encode(), base64_encoded_len(), container_of, uri::host, http_done(), NULL, uri::password, uri::path, http_request::process, process_del(), snprintf(), http_request::socket, strlen(), unparse_uri(), http_request::uri, URI_PATH_BIT, URI_QUERY_BIT, uri::user, xfer_printf(), and xfer_window().

Referenced by http_open_filter().

                                                  {
        struct http_request *http =
                container_of ( process, struct http_request, process );
        const char *host = http->uri->host;
        const char *user = http->uri->user;
        const char *password =
                ( http->uri->password ? http->uri->password : "" );
        size_t user_pw_len = ( user ? ( strlen ( user ) + 1 /* ":" */ +
                                        strlen ( password ) ) : 0 );
        size_t user_pw_base64_len = base64_encoded_len ( user_pw_len );
        char user_pw[ user_pw_len + 1 /* NUL */ ];
        char user_pw_base64[ user_pw_base64_len + 1 /* NUL */ ];
        int rc;
        int request_len = unparse_uri ( NULL, 0, http->uri,
                                        URI_PATH_BIT | URI_QUERY_BIT );

        if ( xfer_window ( &http->socket ) ) {
                char request[request_len + 1];

                /* Construct path?query request */
                unparse_uri ( request, sizeof ( request ), http->uri,
                              URI_PATH_BIT | URI_QUERY_BIT );

                /* We want to execute only once */
                process_del ( &http->process );

                /* Construct authorisation, if applicable */
                if ( user ) {
                        /* Make "user:password" string from decoded fields */
                        snprintf ( user_pw, sizeof ( user_pw ), "%s:%s",
                                   user, password );

                        /* Base64-encode the "user:password" string */
                        base64_encode ( user_pw, user_pw_base64 );
                }

                /* Send GET request */
                if ( ( rc = xfer_printf ( &http->socket,
                                          "GET %s%s HTTP/1.0\r\n"
                                          "User-Agent: gPXE/" VERSION "\r\n"
                                          "%s%s%s"
                                          "Host: %s\r\n"
                                          "\r\n",
                                          http->uri->path ? "" : "/",
                                          request,
                                          ( user ?
                                            "Authorization: Basic " : "" ),
                                          ( user ? user_pw_base64 : "" ),
                                          ( user ? "\r\n" : "" ),
                                          host ) ) != 0 ) {
                        http_done ( http, rc );
                }
        }
}

static void http_socket_close	(	struct xfer_interface *	socket,
		int	rc
	)			[static]

HTTP connection closed by network stack.

Parameters:

	socket	Transport layer interface
	rc	Reason for close

Definition at line 478 of file http.c.

References container_of, DBGC, http_done(), and strerror().

                                                                        {
        struct http_request *http =
                container_of ( socket, struct http_request, socket );

        DBGC ( http, "HTTP %p socket closed: %s\n",
               http, strerror ( rc ) );
        
        http_done ( http, rc );
}

static void http_xfer_close	(	struct xfer_interface *	xfer,
		int	rc
	)			[static]

Close HTTP data transfer interface.

Parameters:

	xfer	Data transfer interface
	rc	Reason for close

Definition at line 504 of file http.c.

References container_of, DBGC, http_done(), and strerror().

                                                                    {
        struct http_request *http =
                container_of ( xfer, struct http_request, xfer );

        DBGC ( http, "HTTP %p interface closed: %s\n",
               http, strerror ( rc ) );

        http_done ( http, rc );
}

int http_open_filter	(	struct xfer_interface *	xfer,
		struct uri *	uri,
		unsigned int	default_port,
		int(*)(struct xfer_interface *xfer, struct xfer_interface **next)	filter
	)

Initiate an HTTP connection, with optional filter.

Parameters:

	xfer	Data transfer interface
	uri	Uniform Resource Identifier
	default_port	Default port number
	filter	Filter to apply to socket, or NULL

Return values:

rc

Return status code

Definition at line 533 of file http.c.

References DBGC, EINVAL, ENOMEM, filter(), refcnt::free, uri::host, htons, http_done(), http_free(), http_step(), memset(), NULL, http_request::process, process_init(), ref_put(), http_request::refcnt, SOCK_STREAM, http_request::socket, sockaddr_tcpip::st_port, strerror(), http_request::uri, uri_port(), http_request::xfer, xfer_init(), xfer_open_named_socket(), and zalloc().

Referenced by http_open(), and https_open().

                                                                           {
        struct http_request *http;
        struct sockaddr_tcpip server;
        struct xfer_interface *socket;
        int rc;

        /* Sanity checks */
        if ( ! uri->host )
                return -EINVAL;

        /* Allocate and populate HTTP structure */
        http = zalloc ( sizeof ( *http ) );
        if ( ! http )
                return -ENOMEM;
        http->refcnt.free = http_free;
        xfer_init ( &http->xfer, &http_xfer_operations, &http->refcnt );
        http->uri = uri_get ( uri );
        xfer_init ( &http->socket, &http_socket_operations, &http->refcnt );
        process_init ( &http->process, http_step, &http->refcnt );

        /* Open socket */
        memset ( &server, 0, sizeof ( server ) );
        server.st_port = htons ( uri_port ( http->uri, default_port ) );
        socket = &http->socket;
        if ( filter ) {
                if ( ( rc = filter ( socket, &socket ) ) != 0 )
                        goto err;
        }
        if ( ( rc = xfer_open_named_socket ( socket, SOCK_STREAM,
                                             ( struct sockaddr * ) &server,
                                             uri->host, NULL ) ) != 0 )
                goto err;

        /* Attach to parent interface, mortalise self, and return */
        xfer_plug_plug ( &http->xfer, xfer );
        ref_put ( &http->refcnt );
        return 0;

 err:
        DBGC ( http, "HTTP %p could not create request: %s\n", 
               http, strerror ( rc ) );
        http_done ( http, rc );
        ref_put ( &http->refcnt );
        return rc;
}

static int http_open	(	struct xfer_interface *	xfer,
		struct uri *	uri
	)			[static]

Initiate an HTTP connection.

Parameters:

	xfer	Data transfer interface
	uri	Uniform Resource Identifier

Return values:

rc

Return status code

Definition at line 589 of file http.c.

References http_open_filter(), HTTP_PORT, and NULL.

                                                                      {
        return http_open_filter ( xfer, uri, HTTP_PORT, NULL );
}

---

Variable Documentation

struct http_header_handler http_header_handlers[] [static]

Initial value:

 {
        {
                .header = "Location",
                .rx = http_rx_location,
        },
        {
                .header = "Content-Length",
                .rx = http_rx_content_length,
        },
        { NULL, NULL }
}

List of HTTP header handlers.

Definition at line 250 of file http.c.

struct http_line_handler http_line_handlers[] [static]

Initial value:

 {
        [HTTP_RX_RESPONSE]      = { .rx = http_rx_response },
        [HTTP_RX_HEADER]        = { .rx = http_rx_header },
}

List of HTTP line-based data handlers.

Definition at line 317 of file http.c.

struct xfer_interface_operations http_socket_operations [static]

Initial value:

 {
        .close          = http_socket_close,
        .vredirect      = xfer_vreopen,
        .window         = unlimited_xfer_window,
        .alloc_iob      = default_xfer_alloc_iob,
        .deliver_iob    = http_socket_deliver_iob,
        .deliver_raw    = xfer_deliver_as_iob,
}

HTTP socket operations.

Definition at line 489 of file http.c.

struct xfer_interface_operations http_xfer_operations [static]

Initial value:

 {
        .close          = http_xfer_close,
        .vredirect      = ignore_xfer_vredirect,
        .window         = unlimited_xfer_window,
        .alloc_iob      = default_xfer_alloc_iob,
        .deliver_iob    = xfer_deliver_as_raw,
        .deliver_raw    = ignore_xfer_deliver_raw,
}

HTTP data transfer interface operations.

Definition at line 515 of file http.c.

struct uri_opener http_uri_opener __uri_opener

Initial value:

 {
        .scheme = "http",
        .open   = http_open,
}

HTTP URI opener.

Definition at line 594 of file http.c.