Files
ipxe/src/net/tcp/httpconn.c
T
Michael Brown e7f67d5a4c [http] Work around stateful authentication schemes
As pointedly documented in RFC7230 section 2.3, HTTP is a stateless
protocol: each request message can be understood in isolation from any
other requests or responses.  Various authentication schemes such as
NTLM break this fundamental property of HTTP and rely on the same TCP
connection being reused.

Work around these broken authentication schemes by ensuring that the
most recently pooled connection is reused for the subsequent
authentication retry.

Reported-by: Andreas Hammarskjöld <junior@2PintSoftware.com>
Tested-by: Andreas Hammarskjöld <junior@2PintSoftware.com>
Signed-off-by: Michael Brown <mcb30@ipxe.org>
2018-06-08 13:53:02 +01:00

325 lines
8.8 KiB
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;
}