iPXE
httpconn.c
Go to the documentation of this file.
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) connection management
30  *
31  */
32 
33 #include <stdlib.h>
34 #include <string.h>
35 #include <errno.h>
36 #include <byteswap.h>
37 #include <ipxe/tcpip.h>
38 #include <ipxe/uri.h>
39 #include <ipxe/timer.h>
40 #include <ipxe/xfer.h>
41 #include <ipxe/open.h>
42 #include <ipxe/pool.h>
43 #include <ipxe/http.h>
44 
45 /** HTTP pooled connection expiry time */
46 #define HTTP_CONN_EXPIRY ( 10 * TICKS_PER_SEC )
47 
48 /** HTTP connection pool */
49 static LIST_HEAD ( http_connection_pool );
50 
51 /**
52  * Identify HTTP scheme
53  *
54  * @v uri URI
55  * @ret scheme HTTP scheme, or NULL
56  */
57 static struct http_scheme * http_scheme ( struct uri *uri ) {
58  struct http_scheme *scheme;
59 
60  /* Sanity check */
61  if ( ! uri->scheme )
62  return NULL;
63 
64  /* Identify scheme */
66  if ( strcmp ( uri->scheme, scheme->name ) == 0 )
67  return scheme;
68  }
69 
70  return NULL;
71 }
72 
73 /**
74  * Free HTTP connection
75  *
76  * @v refcnt Reference count
77  */
78 static void http_conn_free ( struct refcnt *refcnt ) {
79  struct http_connection *conn =
81 
82  /* Free connection */
83  uri_put ( conn->uri );
84  free ( conn );
85 }
86 
87 /**
88  * Close HTTP connection
89  *
90  * @v conn HTTP connection
91  * @v rc Reason for close
92  */
93 static void http_conn_close ( struct http_connection *conn, int rc ) {
94 
95  /* Remove from connection pool, if applicable */
96  pool_del ( &conn->pool );
97 
98  /* Shut down interfaces */
99  intf_shutdown ( &conn->socket, rc );
100  intf_shutdown ( &conn->xfer, rc );
101  if ( rc == 0 ) {
102  DBGC2 ( conn, "HTTPCONN %p closed %s://%s\n",
103  conn, conn->scheme->name, conn->uri->host );
104  } else {
105  DBGC ( conn, "HTTPCONN %p closed %s://%s: %s\n",
106  conn, conn->scheme->name, conn->uri->host,
107  strerror ( rc ) );
108  }
109 }
110 
111 /**
112  * Disconnect idle HTTP connection
113  *
114  * @v pool Pooled connection
115  */
116 static void http_conn_expired ( struct pooled_connection *pool ) {
117  struct http_connection *conn =
118  container_of ( pool, struct http_connection, pool );
119 
120  /* Close connection */
121  http_conn_close ( conn, 0 /* Not an error to close idle connection */ );
122 }
123 
124 /**
125  * Receive data from transport layer interface
126  *
127  * @v http HTTP connection
128  * @v iobuf I/O buffer
129  * @v meta Transfer metadata
130  * @ret rc Return status code
131  */
132 static int http_conn_socket_deliver ( struct http_connection *conn,
133  struct io_buffer *iobuf,
134  struct xfer_metadata *meta ) {
135 
136  /* Mark connection as alive */
137  pool_alive ( &conn->pool );
138 
139  /* Pass on to data transfer interface */
140  return xfer_deliver ( &conn->xfer, iobuf, meta );
141 }
142 
143 /**
144  * Close HTTP connection transport layer interface
145  *
146  * @v http HTTP connection
147  * @v rc Reason for close
148  */
149 static void http_conn_socket_close ( struct http_connection *conn, int rc ) {
150 
151  /* If we are reopenable (i.e. we are a recycled connection
152  * from the connection pool, and we have received no data from
153  * the underlying socket since we were pooled), then suggest
154  * that the client should reopen the connection.
155  */
156  if ( pool_is_reopenable ( &conn->pool ) )
157  pool_reopen ( &conn->xfer );
158 
159  /* Close the connection */
160  http_conn_close ( conn, rc );
161 }
162 
163 /**
164  * Recycle this connection after closing
165  *
166  * @v http HTTP connection
167  */
168 static void http_conn_xfer_recycle ( struct http_connection *conn ) {
169 
170  /* Mark connection as recyclable */
171  pool_recyclable ( &conn->pool );
172  DBGC2 ( conn, "HTTPCONN %p keepalive enabled\n", conn );
173 }
174 
175 /**
176  * Close HTTP connection data transfer interface
177  *
178  * @v conn HTTP connection
179  * @v rc Reason for close
180  */
181 static void http_conn_xfer_close ( struct http_connection *conn, int rc ) {
182 
183  /* Add to the connection pool if keepalive is enabled and no
184  * error occurred.
185  */
186  if ( ( rc == 0 ) && pool_is_recyclable ( &conn->pool ) ) {
187  intf_restart ( &conn->xfer, rc );
188  pool_add ( &conn->pool, &http_connection_pool,
190  DBGC2 ( conn, "HTTPCONN %p pooled %s://%s\n",
191  conn, conn->scheme->name, conn->uri->host );
192  return;
193  }
194 
195  /* Otherwise, close the connection */
196  http_conn_close ( conn, rc );
197 }
198 
199 /** HTTP connection socket interface operations */
203  INTF_OP ( intf_close, struct http_connection *,
205 };
206 
207 /** HTTP connection socket interface descriptor */
209  INTF_DESC_PASSTHRU ( struct http_connection, socket,
211 
212 /** HTTP connection data transfer interface operations */
216  INTF_OP ( intf_close, struct http_connection *,
218 };
219 
220 /** HTTP connection data transfer interface descriptor */
222  INTF_DESC_PASSTHRU ( struct http_connection, xfer,
223  http_conn_xfer_operations, socket );
224 
225 /**
226  * Connect to an HTTP server
227  *
228  * @v xfer Data transfer interface
229  * @v uri Connection URI
230  * @ret rc Return status code
231  *
232  * HTTP connections are pooled. The caller should be prepared to
233  * receive a pool_reopen() message.
234  */
235 int http_connect ( struct interface *xfer, struct uri *uri ) {
236  struct http_connection *conn;
237  struct http_scheme *scheme;
238  struct sockaddr_tcpip server;
239  struct interface *socket;
240  unsigned int port;
241  int rc;
242 
243  /* Identify scheme */
244  scheme = http_scheme ( uri );
245  if ( ! scheme )
246  return -ENOTSUP;
247 
248  /* Sanity check */
249  if ( ! uri->host )
250  return -EINVAL;
251 
252  /* Identify port */
253  port = uri_port ( uri, scheme->port );
254 
255  /* Look for a reusable connection in the pool. Reuse the most
256  * recent connection in order to accommodate authentication
257  * schemes that break the stateless nature of HTTP and rely on
258  * the same connection being reused for authentication
259  * responses.
260  */
261  list_for_each_entry_reverse ( conn, &http_connection_pool, pool.list ) {
262 
263  /* Sanity checks */
264  assert ( conn->uri != NULL );
265  assert ( conn->uri->host != NULL );
266 
267  /* Reuse connection, if possible */
268  if ( ( scheme == conn->scheme ) &&
269  ( strcmp ( uri->host, conn->uri->host ) == 0 ) &&
270  ( port == uri_port ( conn->uri, scheme->port ) ) ) {
271 
272  /* Remove from connection pool, stop timer,
273  * attach to parent interface, and return.
274  */
275  pool_del ( &conn->pool );
276  intf_plug_plug ( &conn->xfer, xfer );
277  DBGC2 ( conn, "HTTPCONN %p reused %s://%s:%d\n", conn,
278  conn->scheme->name, conn->uri->host, port );
279  return 0;
280  }
281  }
282 
283  /* Allocate and initialise structure */
284  conn = zalloc ( sizeof ( *conn ) );
285  if ( ! conn ) {
286  rc = -ENOMEM;
287  goto err_alloc;
288  }
289  ref_init ( &conn->refcnt, http_conn_free );
290  conn->uri = uri_get ( uri );
291  conn->scheme = scheme;
292  intf_init ( &conn->socket, &http_conn_socket_desc, &conn->refcnt );
293  intf_init ( &conn->xfer, &http_conn_xfer_desc, &conn->refcnt );
294  pool_init ( &conn->pool, http_conn_expired, &conn->refcnt );
295 
296  /* Open socket */
297  memset ( &server, 0, sizeof ( server ) );
298  server.st_port = htons ( port );
299  socket = &conn->socket;
300  if ( scheme->filter &&
301  ( ( rc = scheme->filter ( socket, uri->host, &socket ) ) != 0 ) )
302  goto err_filter;
303  if ( ( rc = xfer_open_named_socket ( socket, SOCK_STREAM,
304  ( struct sockaddr * ) &server,
305  uri->host, NULL ) ) != 0 )
306  goto err_open;
307 
308  /* Attach to parent interface, mortalise self, and return */
309  intf_plug_plug ( &conn->xfer, xfer );
310  ref_put ( &conn->refcnt );
311 
312  DBGC2 ( conn, "HTTPCONN %p created %s://%s:%d\n", conn,
313  conn->scheme->name, conn->uri->host, port );
314  return 0;
315 
316  err_open:
317  err_filter:
318  DBGC2 ( conn, "HTTPCONN %p could not create %s://%s:%d: %s\n", conn,
319  conn->scheme->name, conn->uri->host, port, strerror ( rc ) );
320  http_conn_close ( conn, rc );
321  ref_put ( &conn->refcnt );
322  err_alloc:
323  return rc;
324 }
static struct interface_operation http_conn_socket_operations[]
HTTP connection socket interface operations.
Definition: httpconn.c:200
#define EINVAL
Invalid argument.
Definition: errno.h:428
An object interface operation.
Definition: interface.h:17
TCP/IP socket address.
Definition: tcpip.h:75
struct refcnt refcnt
Reference count.
Definition: http.h:75
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
void pool_add(struct pooled_connection *pool, struct list_head *list, unsigned long expiry)
Add connection to pool.
Definition: pool.c:63
void intf_close(struct interface *intf, int rc)
Close an object interface.
Definition: interface.c:244
void intf_restart(struct interface *intf, int rc)
Shut down and restart an object interface.
Definition: interface.c:337
Data transfer metadata.
Definition: xfer.h:22
void intf_shutdown(struct interface *intf, int rc)
Shut down an object interface.
Definition: interface.c:273
static void uri_put(struct uri *uri)
Decrement URI reference count.
Definition: uri.h:188
static struct uri * uri_get(struct uri *uri)
Increment URI reference count.
Definition: uri.h:177
static struct interface_descriptor http_conn_socket_desc
HTTP connection socket interface descriptor.
Definition: httpconn.c:208
timer_init & pool
Definition: pool.h:65
#define ref_init(refcnt, free)
Initialise a reference counter.
Definition: refcnt.h:64
Error codes.
Pooled connections.
unsigned int port
Default port.
Definition: http.h:43
#define DBGC(...)
Definition: compiler.h:505
static struct interface_operation http_conn_xfer_operations[]
HTTP connection data transfer interface operations.
Definition: httpconn.c:213
void intf_plug_plug(struct interface *a, struct interface *b)
Plug two object interfaces together.
Definition: interface.c:102
iPXE timers
A pooled connection.
Definition: pool.h:17
struct interface socket
Transport layer interface.
Definition: http.h:86
Uniform Resource Identifiers.
void pool_del(struct pooled_connection *pool)
Remove connection from pool.
Definition: pool.c:82
#define ENOTSUP
Operation not supported.
Definition: errno.h:589
struct interface xfer
Data transfer interface.
Definition: http.h:88
Data transfer interfaces.
A reference counter.
Definition: refcnt.h:26
int http_connect(struct interface *xfer, struct uri *uri)
Connect to an HTTP server.
Definition: httpconn.c:235
#define ENOMEM
Not enough space.
Definition: errno.h:534
const char * scheme
Scheme.
Definition: uri.h:54
u8 port
Port number.
Definition: CIB_PRM.h:31
static struct http_scheme * http_scheme(struct uri *uri)
Identify HTTP scheme.
Definition: httpconn.c:57
int(* filter)(struct interface *xfer, const char *name, struct interface **next)
Transport-layer filter (if any)
Definition: http.h:51
Hyper Text Transport Protocol.
static int http_conn_socket_deliver(struct http_connection *conn, struct io_buffer *iobuf, struct xfer_metadata *meta)
Receive data from transport layer interface.
Definition: httpconn.c:132
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
#define container_of(ptr, type, field)
Get containing structure.
Definition: stddef.h:35
An object interface.
Definition: interface.h:109
static void http_conn_socket_close(struct http_connection *conn, int rc)
Close HTTP connection transport layer interface.
Definition: httpconn.c:149
#define list_for_each_entry_reverse(pos, head, member)
Iterate over entries in a list in reverse order.
Definition: list.h:433
Transport-network layer interface.
void pool_reopen(struct interface *intf)
Reopen a defunct connection.
Definition: pool.c:51
static void http_conn_xfer_close(struct http_connection *conn, int rc)
Close HTTP connection data transfer interface.
Definition: httpconn.c:181
const char * name
Scheme name (e.g.
Definition: http.h:41
int meta(WINDOW *, bool)
uint16_t st_port
TCP/IP port.
Definition: tcpip.h:81
Generalized socket address structure.
Definition: socket.h:96
An object interface descriptor.
Definition: interface.h:40
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
static void(* free)(struct refcnt *refcnt))
Definition: refcnt.h:54
void * zalloc(size_t size)
Allocate cleared memory.
Definition: malloc.c:624
#define INTF_OP(op_type, object_type, op_func)
Define an object interface operation.
Definition: interface.h:32
#define for_each_table_entry(pointer, table)
Iterate through all entries within a linker table.
Definition: tables.h:358
static void http_conn_close(struct http_connection *conn, int rc)
Close HTTP connection.
Definition: httpconn.c:93
#define SOCK_STREAM
Definition: socket.h:24
int xfer_deliver(struct interface *intf, struct io_buffer *iobuf, struct xfer_metadata *meta)
Deliver datagram.
Definition: xfer.c:193
Data transfer interface opening.
const char * host
Host name.
Definition: uri.h:62
struct http_scheme * scheme
HTTP scheme.
Definition: http.h:84
#define HTTP_SCHEMES
HTTP scheme table.
Definition: http.h:56
#define HTTP_CONN_EXPIRY
HTTP pooled connection expiry time.
Definition: httpconn.c:46
An HTTP URI scheme.
Definition: http.h:39
#define DBGC2(...)
Definition: compiler.h:522
int strcmp(const char *first, const char *second)
Compare strings.
Definition: string.c:157
FILE_LICENCE(GPL2_OR_LATER_OR_UBDL)
struct uri * uri
Connection URI.
Definition: http.h:82
static void http_conn_free(struct refcnt *refcnt)
Free HTTP connection.
Definition: httpconn.c:78
unsigned int uri_port(const struct uri *uri, unsigned int default_port)
Get port from URI.
Definition: uri.c:441
A Uniform Resource Identifier.
Definition: uri.h:50
#define INTF_DESC_PASSTHRU(object_type, intf, operations, passthru)
Define an object interface descriptor with pass-through interface.
Definition: interface.h:82
static void http_conn_expired(struct pooled_connection *pool)
Disconnect idle HTTP connection.
Definition: httpconn.c:116
void pool_recycle(struct interface *intf)
Recycle this connection after closing.
Definition: pool.c:41
static void http_conn_xfer_recycle(struct http_connection *conn)
Recycle this connection after closing.
Definition: httpconn.c:168
static void intf_init(struct interface *intf, struct interface_descriptor *desc, struct refcnt *refcnt)
Initialise an object interface.
Definition: interface.h:173
struct pooled_connection pool
Pooled connection.
Definition: http.h:90
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
String functions.
An HTTP connection.
Definition: http.h:73
#define htons(value)
Definition: byteswap.h:135
static LIST_HEAD(http_connection_pool)
HTTP connection pool.
int xfer_open_named_socket(struct interface *xfer, int semantics, struct sockaddr *peer, const char *name, struct sockaddr *local)
Open named socket.
Definition: resolv.c:402
#define ref_put(refcnt)
Drop reference to object.
Definition: refcnt.h:106
void * memset(void *dest, int character, size_t len) __nonnull
A persistent I/O buffer.
Definition: iobuf.h:32
static struct interface_descriptor http_conn_xfer_desc
HTTP connection data transfer interface descriptor.
Definition: httpconn.c:221