![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to http.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net / tcp|
Return to http.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net / tcp |
1.1 root 1: /*
2: * Copyright (C) 2007 Michael Brown <[email protected]>.
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: FILE_LICENCE ( GPL2_OR_LATER );
20:
21: /**
22: * @file
23: *
24: * Hyper Text Transfer Protocol (HTTP)
25: *
26: */
27:
28: #include <stdint.h>
29: #include <stdlib.h>
30: #include <stdio.h>
31: #include <string.h>
32: #include <strings.h>
33: #include <byteswap.h>
34: #include <errno.h>
35: #include <assert.h>
36: #include <ipxe/uri.h>
37: #include <ipxe/refcnt.h>
38: #include <ipxe/iobuf.h>
39: #include <ipxe/xfer.h>
40: #include <ipxe/open.h>
41: #include <ipxe/socket.h>
42: #include <ipxe/tcpip.h>
43: #include <ipxe/process.h>
44: #include <ipxe/linebuf.h>
45: #include <ipxe/features.h>
46: #include <ipxe/base64.h>
47: #include <ipxe/http.h>
48:
49: FEATURE ( FEATURE_PROTOCOL, "HTTP", DHCP_EB_FEATURE_HTTP, 1 );
50:
51: /** HTTP receive state */
52: enum http_rx_state {
53: HTTP_RX_RESPONSE = 0,
54: HTTP_RX_HEADER,
55: HTTP_RX_DATA,
56: HTTP_RX_DEAD,
57: };
58:
59: /**
60: * An HTTP request
61: *
62: */
63: struct http_request {
64: /** Reference count */
65: struct refcnt refcnt;
66: /** Data transfer interface */
67: struct interface xfer;
68:
69: /** URI being fetched */
70: struct uri *uri;
71: /** Transport layer interface */
72: struct interface socket;
73:
74: /** TX process */
75: struct process process;
76:
77: /** HTTP response code */
78: unsigned int response;
79: /** HTTP Content-Length */
80: size_t content_length;
81: /** Received length */
82: size_t rx_len;
83: /** RX state */
84: enum http_rx_state rx_state;
85: /** Line buffer for received header lines */
86: struct line_buffer linebuf;
87: };
88:
89: /**
90: * Free HTTP request
91: *
92: * @v refcnt Reference counter
93: */
94: static void http_free ( struct refcnt *refcnt ) {
95: struct http_request *http =
96: container_of ( refcnt, struct http_request, refcnt );
97:
98: uri_put ( http->uri );
99: empty_line_buffer ( &http->linebuf );
100: free ( http );
101: };
102:
103: /**
104: * Mark HTTP request as complete
105: *
106: * @v http HTTP request
107: * @v rc Return status code
108: */
109: static void http_done ( struct http_request *http, int rc ) {
110:
111: /* Prevent further processing of any current packet */
112: http->rx_state = HTTP_RX_DEAD;
113:
114: /* If we had a Content-Length, and the received content length
115: * isn't correct, flag an error
116: */
117: if ( http->content_length &&
118: ( http->content_length != http->rx_len ) ) {
119: DBGC ( http, "HTTP %p incorrect length %zd, should be %zd\n",
120: http, http->rx_len, http->content_length );
121: rc = -EIO;
122: }
123:
124: /* Remove process */
125: process_del ( &http->process );
126:
127: /* Close all data transfer interfaces */
128: intf_shutdown ( &http->socket, rc );
129: intf_shutdown ( &http->xfer, rc );
130: }
131:
132: /**
133: * Convert HTTP response code to return status code
134: *
135: * @v response HTTP response code
136: * @ret rc Return status code
137: */
138: static int http_response_to_rc ( unsigned int response ) {
139: switch ( response ) {
140: case 200:
141: case 301:
142: case 302:
143: return 0;
144: case 404:
145: return -ENOENT;
146: case 403:
147: return -EPERM;
148: case 401:
149: return -EACCES;
150: default:
151: return -EIO;
152: }
153: }
154:
155: /**
156: * Handle HTTP response
157: *
158: * @v http HTTP request
159: * @v response HTTP response
160: * @ret rc Return status code
161: */
162: static int http_rx_response ( struct http_request *http, char *response ) {
163: char *spc;
164: int rc;
165:
166: DBGC ( http, "HTTP %p response \"%s\"\n", http, response );
167:
168: /* Check response starts with "HTTP/" */
169: if ( strncmp ( response, "HTTP/", 5 ) != 0 )
170: return -EIO;
171:
172: /* Locate and check response code */
173: spc = strchr ( response, ' ' );
174: if ( ! spc )
175: return -EIO;
176: http->response = strtoul ( spc, NULL, 10 );
177: if ( ( rc = http_response_to_rc ( http->response ) ) != 0 )
178: return rc;
179:
180: /* Move to received headers */
181: http->rx_state = HTTP_RX_HEADER;
182: return 0;
183: }
184:
185: /**
186: * Handle HTTP Location header
187: *
188: * @v http HTTP request
189: * @v value HTTP header value
190: * @ret rc Return status code
191: */
192: static int http_rx_location ( struct http_request *http, const char *value ) {
193: int rc;
194:
195: /* Redirect to new location */
196: DBGC ( http, "HTTP %p redirecting to %s\n", http, value );
197: if ( ( rc = xfer_redirect ( &http->xfer, LOCATION_URI_STRING,
198: value ) ) != 0 ) {
199: DBGC ( http, "HTTP %p could not redirect: %s\n",
200: http, strerror ( rc ) );
201: return rc;
202: }
203:
204: return 0;
205: }
206:
207: /**
208: * Handle HTTP Content-Length header
209: *
210: * @v http HTTP request
211: * @v value HTTP header value
212: * @ret rc Return status code
213: */
214: static int http_rx_content_length ( struct http_request *http,
215: const char *value ) {
216: char *endp;
217:
218: http->content_length = strtoul ( value, &endp, 10 );
219: if ( *endp != '\0' ) {
220: DBGC ( http, "HTTP %p invalid Content-Length \"%s\"\n",
221: http, value );
222: return -EIO;
223: }
224:
225: /* Use seek() to notify recipient of filesize */
226: xfer_seek ( &http->xfer, http->content_length );
227: xfer_seek ( &http->xfer, 0 );
228:
229: return 0;
230: }
231:
232: /** An HTTP header handler */
233: struct http_header_handler {
234: /** Name (e.g. "Content-Length") */
235: const char *header;
236: /** Handle received header
237: *
238: * @v http HTTP request
239: * @v value HTTP header value
240: * @ret rc Return status code
241: *
242: * If an error is returned, the download will be aborted.
243: */
244: int ( * rx ) ( struct http_request *http, const char *value );
245: };
246:
247: /** List of HTTP header handlers */
248: static struct http_header_handler http_header_handlers[] = {
249: {
250: .header = "Location",
251: .rx = http_rx_location,
252: },
253: {
254: .header = "Content-Length",
255: .rx = http_rx_content_length,
256: },
257: { NULL, NULL }
258: };
259:
260: /**
261: * Handle HTTP header
262: *
263: * @v http HTTP request
264: * @v header HTTP header
265: * @ret rc Return status code
266: */
267: static int http_rx_header ( struct http_request *http, char *header ) {
268: struct http_header_handler *handler;
269: char *separator;
270: char *value;
271: int rc;
272:
273: /* An empty header line marks the transition to the data phase */
274: if ( ! header[0] ) {
275: DBGC ( http, "HTTP %p start of data\n", http );
276: empty_line_buffer ( &http->linebuf );
277: http->rx_state = HTTP_RX_DATA;
278: return 0;
279: }
280:
281: DBGC ( http, "HTTP %p header \"%s\"\n", http, header );
282:
283: /* Split header at the ": " */
284: separator = strstr ( header, ": " );
285: if ( ! separator ) {
286: DBGC ( http, "HTTP %p malformed header\n", http );
287: return -EIO;
288: }
289: *separator = '\0';
290: value = ( separator + 2 );
291:
292: /* Hand off to header handler, if one exists */
293: for ( handler = http_header_handlers ; handler->header ; handler++ ) {
294: if ( strcasecmp ( header, handler->header ) == 0 ) {
295: if ( ( rc = handler->rx ( http, value ) ) != 0 )
296: return rc;
297: break;
298: }
299: }
300: return 0;
301: }
302:
303: /** An HTTP line-based data handler */
304: struct http_line_handler {
305: /** Handle line
306: *
307: * @v http HTTP request
308: * @v line Line to handle
309: * @ret rc Return status code
310: */
311: int ( * rx ) ( struct http_request *http, char *line );
312: };
313:
314: /** List of HTTP line-based data handlers */
315: static struct http_line_handler http_line_handlers[] = {
316: [HTTP_RX_RESPONSE] = { .rx = http_rx_response },
317: [HTTP_RX_HEADER] = { .rx = http_rx_header },
318: };
319:
320: /**
321: * Handle new data arriving via HTTP connection in the data phase
322: *
323: * @v http HTTP request
324: * @v iobuf I/O buffer
325: * @ret rc Return status code
326: */
327: static int http_rx_data ( struct http_request *http,
328: struct io_buffer *iobuf ) {
329: int rc;
330:
331: /* Update received length */
332: http->rx_len += iob_len ( iobuf );
333:
334: /* Hand off data buffer */
335: if ( ( rc = xfer_deliver_iob ( &http->xfer, iobuf ) ) != 0 )
336: return rc;
337:
338: /* If we have reached the content-length, stop now */
339: if ( http->content_length &&
340: ( http->rx_len >= http->content_length ) ) {
341: http_done ( http, 0 );
342: }
343:
344: return 0;
345: }
346:
347: /**
348: * Handle new data arriving via HTTP connection
349: *
350: * @v http HTTP request
351: * @v iobuf I/O buffer
352: * @v meta Data transfer metadata
353: * @ret rc Return status code
354: */
355: static int http_socket_deliver ( struct http_request *http,
356: struct io_buffer *iobuf,
357: struct xfer_metadata *meta __unused ) {
358: struct http_line_handler *lh;
359: char *line;
360: ssize_t len;
361: int rc = 0;
362:
363: while ( iob_len ( iobuf ) ) {
364: switch ( http->rx_state ) {
365: case HTTP_RX_DEAD:
366: /* Do no further processing */
367: goto done;
368: case HTTP_RX_DATA:
369: /* Once we're into the data phase, just fill
370: * the data buffer
371: */
372: rc = http_rx_data ( http, iob_disown ( iobuf ) );
373: goto done;
374: case HTTP_RX_RESPONSE:
375: case HTTP_RX_HEADER:
376: /* In the other phases, buffer and process a
377: * line at a time
378: */
379: len = line_buffer ( &http->linebuf, iobuf->data,
380: iob_len ( iobuf ) );
381: if ( len < 0 ) {
382: rc = len;
383: DBGC ( http, "HTTP %p could not buffer line: "
384: "%s\n", http, strerror ( rc ) );
385: goto done;
386: }
387: iob_pull ( iobuf, len );
388: line = buffered_line ( &http->linebuf );
389: if ( line ) {
390: lh = &http_line_handlers[http->rx_state];
391: if ( ( rc = lh->rx ( http, line ) ) != 0 )
392: goto done;
393: }
394: break;
395: default:
396: assert ( 0 );
397: break;
398: }
399: }
400:
401: done:
402: if ( rc )
403: http_done ( http, rc );
404: free_iob ( iobuf );
405: return rc;
406: }
407:
408: /**
409: * HTTP process
410: *
411: * @v process Process
412: */
413: static void http_step ( struct process *process ) {
414: struct http_request *http =
415: container_of ( process, struct http_request, process );
416: const char *host = http->uri->host;
417: const char *user = http->uri->user;
418: const char *password =
419: ( http->uri->password ? http->uri->password : "" );
420: size_t user_pw_len = ( user ? ( strlen ( user ) + 1 /* ":" */ +
421: strlen ( password ) ) : 0 );
422: size_t user_pw_base64_len = base64_encoded_len ( user_pw_len );
423: uint8_t user_pw[ user_pw_len + 1 /* NUL */ ];
424: char user_pw_base64[ user_pw_base64_len + 1 /* NUL */ ];
425: int rc;
426: int request_len = unparse_uri ( NULL, 0, http->uri,
427: URI_PATH_BIT | URI_QUERY_BIT );
428:
429: if ( xfer_window ( &http->socket ) ) {
430: char request[request_len + 1];
431:
432: /* Construct path?query request */
433: unparse_uri ( request, sizeof ( request ), http->uri,
434: URI_PATH_BIT | URI_QUERY_BIT );
435:
436: /* We want to execute only once */
437: process_del ( &http->process );
438:
439: /* Construct authorisation, if applicable */
440: if ( user ) {
441: /* Make "user:password" string from decoded fields */
442: snprintf ( ( ( char * ) user_pw ), sizeof ( user_pw ),
443: "%s:%s", user, password );
444:
445: /* Base64-encode the "user:password" string */
446: base64_encode ( user_pw, user_pw_len, user_pw_base64 );
447: }
448:
449: /* Send GET request */
450: if ( ( rc = xfer_printf ( &http->socket,
451: "GET %s%s HTTP/1.0\r\n"
452: "User-Agent: iPXE/" VERSION "\r\n"
453: "%s%s%s"
454: "Host: %s\r\n"
455: "\r\n",
456: http->uri->path ? "" : "/",
457: request,
458: ( user ?
459: "Authorization: Basic " : "" ),
460: ( user ? user_pw_base64 : "" ),
461: ( user ? "\r\n" : "" ),
462: host ) ) != 0 ) {
463: http_done ( http, rc );
464: }
465: }
466: }
467:
468: /** HTTP socket interface operations */
469: static struct interface_operation http_socket_operations[] = {
470: INTF_OP ( xfer_deliver, struct http_request *, http_socket_deliver ),
471: INTF_OP ( intf_close, struct http_request *, http_done ),
472: };
473:
474: /** HTTP socket interface descriptor */
475: static struct interface_descriptor http_socket_desc =
476: INTF_DESC_PASSTHRU ( struct http_request, socket,
477: http_socket_operations, xfer );
478:
479: /** HTTP data transfer interface operations */
480: static struct interface_operation http_xfer_operations[] = {
481: INTF_OP ( intf_close, struct http_request *, http_done ),
482: };
483:
484: /** HTTP data transfer interface descriptor */
485: static struct interface_descriptor http_xfer_desc =
486: INTF_DESC_PASSTHRU ( struct http_request, xfer,
487: http_xfer_operations, socket );
488:
489: /**
490: * Initiate an HTTP connection, with optional filter
491: *
492: * @v xfer Data transfer interface
493: * @v uri Uniform Resource Identifier
494: * @v default_port Default port number
495: * @v filter Filter to apply to socket, or NULL
496: * @ret rc Return status code
497: */
498: int http_open_filter ( struct interface *xfer, struct uri *uri,
499: unsigned int default_port,
500: int ( * filter ) ( struct interface *xfer,
501: struct interface **next ) ) {
502: struct http_request *http;
503: struct sockaddr_tcpip server;
504: struct interface *socket;
505: int rc;
506:
507: /* Sanity checks */
508: if ( ! uri->host )
509: return -EINVAL;
510:
511: /* Allocate and populate HTTP structure */
512: http = zalloc ( sizeof ( *http ) );
513: if ( ! http )
514: return -ENOMEM;
515: ref_init ( &http->refcnt, http_free );
516: intf_init ( &http->xfer, &http_xfer_desc, &http->refcnt );
517: http->uri = uri_get ( uri );
518: intf_init ( &http->socket, &http_socket_desc, &http->refcnt );
519: process_init ( &http->process, http_step, &http->refcnt );
520:
521: /* Open socket */
522: memset ( &server, 0, sizeof ( server ) );
523: server.st_port = htons ( uri_port ( http->uri, default_port ) );
524: socket = &http->socket;
525: if ( filter ) {
526: if ( ( rc = filter ( socket, &socket ) ) != 0 )
527: goto err;
528: }
529: if ( ( rc = xfer_open_named_socket ( socket, SOCK_STREAM,
530: ( struct sockaddr * ) &server,
531: uri->host, NULL ) ) != 0 )
532: goto err;
533:
534: /* Attach to parent interface, mortalise self, and return */
535: intf_plug_plug ( &http->xfer, xfer );
536: ref_put ( &http->refcnt );
537: return 0;
538:
539: err:
540: DBGC ( http, "HTTP %p could not create request: %s\n",
541: http, strerror ( rc ) );
542: http_done ( http, rc );
543: ref_put ( &http->refcnt );
544: return rc;
545: }
546:
547: /**
548: * Initiate an HTTP connection
549: *
550: * @v xfer Data transfer interface
551: * @v uri Uniform Resource Identifier
552: * @ret rc Return status code
553: */
554: static int http_open ( struct interface *xfer, struct uri *uri ) {
555: return http_open_filter ( xfer, uri, HTTP_PORT, NULL );
556: }
557:
558: /** HTTP URI opener */
559: struct uri_opener http_uri_opener __uri_opener = {
560: .scheme = "http",
561: .open = http_open,
562: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.