ipxe/src/net/tcp/httpconn.c

/*
 * Copyright (C) 2015 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 * You can also choose to distribute this program under the terms of
 * the Unmodified Binary Distribution Licence (as given in the file
 * COPYING.UBDL), provided that you have satisfied its requirements.
 */

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

/**
 * @file
 *
 * Hyper Text Transfer Protocol (HTTP) connection management
 *
 */

#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/tcpip.h>
#include <ipxe/uri.h>
#include <ipxe/timer.h>
#include <ipxe/xfer.h>
#include <ipxe/open.h>
#include <ipxe/pool.h>
#include <ipxe/http.h>

/** HTTP pooled connection expiry time */
#define HTTP_CONN_EXPIRY ( 10 * TICKS_PER_SEC )

/** HTTP connection pool */
static LIST_HEAD ( http_connection_pool );

/**
 * Identify HTTP scheme
 *
 * @v uri		URI
 * @ret scheme		HTTP scheme, or NULL
 */
static struct http_scheme * http_scheme ( struct uri *uri ) {
	struct http_scheme *scheme;

	/* Sanity check */
	if ( ! uri->scheme )
		return NULL;

	/* Identify scheme */
	for_each_table_entry ( scheme, HTTP_SCHEMES ) {
		if ( strcmp ( uri->scheme, scheme->name ) == 0 )
			return scheme;
	}

	return NULL;
}

/**
 * Free HTTP connection
 *
 * @v refcnt		Reference count
 */
static void http_conn_free ( struct refcnt *refcnt ) {
	struct http_connection *conn =
		container_of ( refcnt, struct http_connection, refcnt );

	/* Free connection */
	uri_put ( conn->uri );
	free ( conn );
}

/**
 * Close HTTP connection
 *
 * @v conn		HTTP connection
 * @v rc		Reason for close
 */
static void http_conn_close ( struct http_connection *conn, int rc ) {

	/* Remove from connection pool, if applicable */
	pool_del ( &conn->pool );

	/* Shut down interfaces */
	intf_shutdown ( &conn->socket, rc );
	intf_shutdown ( &conn->xfer, rc );
	if ( rc == 0 ) {
		DBGC2 ( conn, "HTTPCONN %p closed %s://%s\n",
			conn, conn->scheme->name, conn->uri->host );
	} else {
		DBGC ( conn, "HTTPCONN %p closed %s://%s: %s\n",
		       conn, conn->scheme->name, conn->uri->host,
		       strerror ( rc ) );
	}
}

/**
 * Disconnect idle HTTP connection
 *
 * @v pool		Pooled connection
 */
static void http_conn_expired ( struct pooled_connection *pool ) {
	struct http_connection *conn =
		container_of ( pool, struct http_connection, pool );

	/* Close connection */
	http_conn_close ( conn, 0 /* Not an error to close idle connection */ );
}

/**
 * Receive data from transport layer interface
 *
 * @v http		HTTP connection
 * @v iobuf		I/O buffer
 * @v meta		Transfer metadata
 * @ret rc		Return status code
 */
static int http_conn_socket_deliver ( struct http_connection *conn,
				      struct io_buffer *iobuf,
				      struct xfer_metadata *meta ) {

	/* Mark connection as alive */
	pool_alive ( &conn->pool );

	/* Pass on to data transfer interface */
	return xfer_deliver ( &conn->xfer, iobuf, meta );
}

/**
 * Close HTTP connection transport layer interface
 *
 * @v http		HTTP connection
 * @v rc		Reason for close
 */
static void http_conn_socket_close ( struct http_connection *conn, int rc ) {

	/* If we are reopenable (i.e. we are a recycled connection
	 * from the connection pool, and we have received no data from
	 * the underlying socket since we were pooled), then suggest
	 * that the client should reopen the connection.
	 */
	if ( pool_is_reopenable ( &conn->pool ) )
		pool_reopen ( &conn->xfer );

	/* Close the connection */
	http_conn_close ( conn, rc );
}

/**
 * Recycle this connection after closing
 *
 * @v http		HTTP connection
 */
static void http_conn_xfer_recycle ( struct http_connection *conn ) {

	/* Mark connection as recyclable */
	pool_recyclable ( &conn->pool );
	DBGC2 ( conn, "HTTPCONN %p keepalive enabled\n", conn );
}

/**
 * Close HTTP connection data transfer interface
 *
 * @v conn		HTTP connection
 * @v rc		Reason for close
 */
static void http_conn_xfer_close ( struct http_connection *conn, int rc ) {

	/* Add to the connection pool if keepalive is enabled and no
	 * error occurred.
	 */
	if ( ( rc == 0 ) && pool_is_recyclable ( &conn->pool ) ) {
		intf_restart ( &conn->xfer, rc );
		pool_add ( &conn->pool, &http_connection_pool,
			   HTTP_CONN_EXPIRY );
		DBGC2 ( conn, "HTTPCONN %p pooled %s://%s\n",
			conn, conn->scheme->name, conn->uri->host );
		return;
	}

	/* Otherwise, close the connection */
	http_conn_close ( conn, rc );
}

/** HTTP connection socket interface operations */
static struct interface_operation http_conn_socket_operations[] = {
	INTF_OP ( xfer_deliver, struct http_connection *,
		  http_conn_socket_deliver ),
	INTF_OP ( intf_close, struct http_connection *,
		  http_conn_socket_close ),
};

/** HTTP connection socket interface descriptor */
static struct interface_descriptor http_conn_socket_desc =
	INTF_DESC_PASSTHRU ( struct http_connection, socket,
			     http_conn_socket_operations, xfer );

/** HTTP connection data transfer interface operations */
static struct interface_operation http_conn_xfer_operations[] = {
	INTF_OP ( pool_recycle, struct http_connection *,
		  http_conn_xfer_recycle ),
	INTF_OP ( intf_close, struct http_connection *,
		  http_conn_xfer_close ),
};

/** HTTP connection data transfer interface descriptor */
static struct interface_descriptor http_conn_xfer_desc =
	INTF_DESC_PASSTHRU ( struct http_connection, xfer,
			     http_conn_xfer_operations, socket );

/**
 * Connect to an HTTP server
 *
 * @v xfer		Data transfer interface
 * @v uri		Connection URI
 * @ret rc		Return status code
 *
 * HTTP connections are pooled.  The caller should be prepared to
 * receive a pool_reopen() message.
 */
int http_connect ( struct interface *xfer, struct uri *uri ) {
	struct http_connection *conn;
	struct http_scheme *scheme;
	struct sockaddr_tcpip server;
	struct interface *socket;
	unsigned int port;
	int rc;

	/* Identify scheme */
	scheme = http_scheme ( uri );
	if ( ! scheme )
		return -ENOTSUP;

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

	/* Identify port */
	port = uri_port ( uri, scheme->port );

	/* Look for a reusable connection in the pool.  Reuse the most
	 * recent connection in order to accommodate authentication
	 * schemes that break the stateless nature of HTTP and rely on
	 * the same connection being reused for authentication
	 * responses.
	 */
	list_for_each_entry_reverse ( conn, &http_connection_pool, pool.list ) {

		/* Sanity checks */
		assert ( conn->uri != NULL );
		assert ( conn->uri->host != NULL );

		/* Reuse connection, if possible */
		if ( ( scheme == conn->scheme ) &&
		     ( strcmp ( uri->host, conn->uri->host ) == 0 ) &&
		     ( port == uri_port ( conn->uri, scheme->port ) ) ) {

			/* Remove from connection pool, stop timer,
			 * attach to parent interface, and return.
			 */
			pool_del ( &conn->pool );
			intf_plug_plug ( &conn->xfer, xfer );
			DBGC2 ( conn, "HTTPCONN %p reused %s://%s:%d\n", conn,
				conn->scheme->name, conn->uri->host, port );
			return 0;
		}
	}

	/* Allocate and initialise structure */
	conn = zalloc ( sizeof ( *conn ) );
	if ( ! conn ) {
		rc = -ENOMEM;
		goto err_alloc;
	}
	ref_init ( &conn->refcnt, http_conn_free );
	conn->uri = uri_get ( uri );
	conn->scheme = scheme;
	intf_init ( &conn->socket, &http_conn_socket_desc, &conn->refcnt );
	intf_init ( &conn->xfer, &http_conn_xfer_desc, &conn->refcnt );
	pool_init ( &conn->pool, http_conn_expired, &conn->refcnt );

	/* Open socket */
	memset ( &server, 0, sizeof ( server ) );
	server.st_port = htons ( port );
	socket = &conn->socket;
	if ( scheme->filter &&
	     ( ( rc = scheme->filter ( socket, uri->host, &socket ) ) != 0 ) )
		goto err_filter;
	if ( ( rc = xfer_open_named_socket ( socket, SOCK_STREAM,
					     ( struct sockaddr * ) &server,
					     uri->host, NULL ) ) != 0 )
		goto err_open;

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

	DBGC2 ( conn, "HTTPCONN %p created %s://%s:%d\n", conn,
		conn->scheme->name, conn->uri->host, port );
	return 0;

 err_open:
 err_filter:
	DBGC2 ( conn, "HTTPCONN %p could not create %s://%s:%d: %s\n", conn,
		conn->scheme->name, conn->uri->host, port, strerror ( rc ) );
	http_conn_close ( conn, rc );
	ref_put ( &conn->refcnt );
 err_alloc:
	return rc;
}