/* Copyright (C) 2007-2008 The Android Open Source Project
**
** This software is licensed under the terms of the GNU General Public
** License version 2, as published by the Free Software Foundation, and
** may be copied, distributed, and modified under those terms.
**
** 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.
*/
#include "proxy_http_int.h"
#include <stdio.h>
#include <string.h>
#include "qemu-common.h"
#include "android/utils/system.h" /* strsep */
/* this implements a transparent HTTP rewriting proxy
*
* this is needed because the HTTP spec mandates that
* any query made to a proxy uses an absolute URI as
* in:
*
* GET http://www.example.com/index.html HTTP/1.1
*
* while the Android browser will think it's talking to
* a normal web server and will issue a:
*
* GET /index.html HTTP/1.1
* Host: www.example.com
*
* what we do here is thus the following:
*
* - read the request header
* - rewrite the request's URI to use absolute URI
* - send the rewritten header to the proxy
* - then read the rest of the request, and tunnel it to the
* proxy as well
* - read the answer as-is and send it back to the system
*
* this sounds all easy, but the rules for computing the
* sizes of HTTP Message Bodies makes the implementation
* a *bit* funky.
*/
/* define D_ACTIVE to 1 to dump additionnal debugging
* info when -debug-proxy is used. These are only needed
* when debugging the proxy code.
*/
#define D_ACTIVE 1
#if D_ACTIVE
# define D(...) PROXY_LOG(__VA_ARGS__)
#else
# define D(...) ((void)0)
#endif
/** *************************************************************
**
** HTTP HEADERS
**
**/
/* HttpHeader is a simple structure used to hold a (key,value)
* pair in a linked list.
*/
typedef struct HttpHeader {
struct HttpHeader* next;
const char* key;
const char* value;
} HttpHeader;
static void
http_header_free( HttpHeader* h )
{
if (h) {
qemu_free((char*)h->value);
qemu_free(h);
}
}
static int
http_header_append( HttpHeader* h, const char* value )
{
int old = strlen(h->value);
int new = strlen(value);
char* s = realloc((char*)h->value, old+new+1);
if (s == NULL)
return -1;
memcpy(s + old, value, new+1);
h->value = (const char*)s;
return 0;
}
static HttpHeader*
http_header_alloc( const char* key, const char* value )
{
int len = strlen(key)+1;
HttpHeader* h = malloc(sizeof(*h) + len+1);
if (h) {
h->next = NULL;
h->key = (const char*)(h+1);
memcpy( (char*)h->key, key, len );
h->value = qemu_strdup(value);
}
return h;
}
/** *************************************************************
**
** HTTP HEADERS LIST
**
**/
typedef struct {
HttpHeader* first;
HttpHeader* last;
} HttpHeaderList;
static void
http_header_list_init( HttpHeaderList* l )
{
l->first = l->last = NULL;
}
static void
http_header_list_done( HttpHeaderList* l )
{
while (l->first) {
HttpHeader* h = l->first;
l->first = h->next;
http_header_free(h);
}
l->last = NULL;
}
static void
http_header_list_add( HttpHeaderList* l,
HttpHeader* h )
{
if (!l->first) {
l->first = h;
} else {
l->last->next = h;
}
h->next = NULL;
l->last = h;
}
static const char*
http_header_list_find( HttpHeaderList* l,
const char* key )
{
HttpHeader* h;
for (h = l->first; h; h = h->next)
if (!strcasecmp(h->key, key))
return h->value;
return NULL;
}
/** *************************************************************
**
** HTTP REQUEST AND REPLY
**
**/
typedef enum {
HTTP_REQUEST_UNSUPPORTED = 0,
HTTP_REQUEST_GET,
HTTP_REQUEST_HEAD,
HTTP_REQUEST_POST,
HTTP_REQUEST_PUT,
HTTP_REQUEST_DELETE,
} HttpRequestType;
/* HttpRequest is used both to store information about a specific
* request and the corresponding reply
*/
typedef struct {
HttpRequestType req_type; /* request type */
char* req_method; /* "GET", "POST", "HEAD", etc... */
char* req_uri; /* the request URI */
char* req_version; /* "HTTP/1.0" or "HTTP/1.1" */
char* rep_version; /* reply version string */
int rep_code; /* reply code as decimal */
char* rep_readable; /* human-friendly reply/error message */
HttpHeaderList headers[1]; /* headers */
} HttpRequest;
static HttpRequest*
http_request_alloc( const char* method,
const char* uri,
const char* version )
{
HttpRequest* r = malloc(sizeof(*r));
r->req_method = qemu_strdup(method);
r->req_uri = qemu_strdup(uri);
r->req_version = qemu_strdup(version);
r->rep_version = NULL;
r->rep_code = -1;
r->rep_readable = NULL;
if (!strcmp(method,"GET")) {
r->req_type = HTTP_REQUEST_GET;
} else if (!strcmp(method,"POST")) {
r->req_type = HTTP_REQUEST_POST;
} else if (!strcmp(method,"HEAD")) {
r->req_type = HTTP_REQUEST_HEAD;
} else if (!strcmp(method,"PUT")) {
r->req_type = HTTP_REQUEST_PUT;
} else if (!strcmp(method,"DELETE")) {
r->req_type = HTTP_REQUEST_DELETE;
} else
r->req_type = HTTP_REQUEST_UNSUPPORTED;
http_header_list_init(r->headers);
return r;
}
static void
http_request_replace_uri( HttpRequest* r,
const char* uri )
{
const char* old = r->req_uri;
r->req_uri = qemu_strdup(uri);
qemu_free((char*)old);
}
static void
http_request_free( HttpRequest* r )
{
if (r) {
http_header_list_done(r->headers);
qemu_free(r->req_method);
qemu_free(r->req_uri);
qemu_free(r->req_version);
qemu_free(r->rep_version);
qemu_free(r->rep_readable);
qemu_free(r);
}
}
static char*
http_request_find_header( HttpRequest* r,
const char* key )
{
return (char*)http_header_list_find(r->headers, key);
}
static int
http_request_add_header( HttpRequest* r,
const char* key,
const char* value )
{
HttpHeader* h = http_header_alloc(key,value);
if (h) {
http_header_list_add(r->headers, h);
return 0;
}
return -1;
}
static int
http_request_add_to_last_header( HttpRequest* r,
const char* line )
{
if (r->headers->last) {
return http_header_append( r->headers->last, line );
} else {
return -1;
}
}
static int
http_request_set_reply( HttpRequest* r,
const char* version,
const char* code,
const char* readable )
{
if (strcmp(version,"HTTP/1.0") && strcmp(version,"HTTP/1.1")) {
PROXY_LOG("%s: bad reply protocol: %s", __FUNCTION__, version);
return -1;
}
r->rep_code = atoi(code);
if (r->rep_code == 0) {
PROXY_LOG("%s: bad reply code: %d", __FUNCTION__, code);
return -1;
}
r->rep_version = qemu_strdup(version);
r->rep_readable = qemu_strdup(readable);
/* reset the list of headers */
http_header_list_done(r->headers);
return 0;
}
/** *************************************************************
**
** REWRITER CONNECTION
**
**/
typedef enum {
STATE_CONNECTING = 0,
STATE_CREATE_SOCKET_PAIR,
STATE_REQUEST_FIRST_LINE,
STATE_REQUEST_HEADERS,
STATE_REQUEST_SEND,
STATE_REQUEST_BODY,
STATE_REPLY_FIRST_LINE,
STATE_REPLY_HEADERS,
STATE_REPLY_SEND,
STATE_REPLY_BODY,
} ConnectionState;
/* root->socket is connected to the proxy server. while
* slirp_fd is connected to the slirp code through a
* socket_pair() we created for this specific purpose.
*/
typedef enum {
BODY_NONE = 0,
BODY_KNOWN_LENGTH,
BODY_UNTIL_CLOSE,
BODY_CHUNKED,
BODY_MODE_MAX
} BodyMode;
static const char* const body_mode_str[BODY_MODE_MAX] = {
"NONE", "KNOWN_LENGTH", "UNTIL_CLOSE", "CHUNKED"
};
enum {
CHUNK_HEADER, // Waiting for a chunk header + CR LF
CHUNK_DATA, // Waiting for chunk data
CHUNK_DATA_END, // Waiting for the CR LF after the chunk data
CHUNK_TRAILER // Waiting for the chunk trailer + CR LF
};
typedef struct {
ProxyConnection root[1];
int slirp_fd;
ConnectionState state;
HttpRequest* request;
BodyMode body_mode;
int64_t body_length;
int64_t body_total;
int64_t body_sent;
int64_t chunk_length;
int64_t chunk_total;
int chunk_state;
char body_has_data;
char body_is_full;
char body_is_closed;
char parse_chunk_header;
char parse_chunk_trailer;
} RewriteConnection;
static void
rewrite_connection_free( ProxyConnection* root )
{
RewriteConnection* conn = (RewriteConnection*)root;
if (conn->slirp_fd >= 0) {
socket_close(conn->slirp_fd);
conn->slirp_fd = -1;
}
http_request_free(conn->request);
proxy_connection_done(root);
qemu_free(conn);
}
static int
rewrite_connection_init( RewriteConnection* conn )
{
HttpService* service = (HttpService*) conn->root->service;
ProxyConnection* root = conn->root;
conn->slirp_fd = -1;
conn->state = STATE_CONNECTING;
if (socket_connect( root->socket, &service->server_addr ) < 0) {
if (errno == EINPROGRESS || errno == EWOULDBLOCK || errno == EAGAIN) {
PROXY_LOG("%s: connecting", conn->root->name);
}
else {
PROXY_LOG("%s: cannot connect to proxy: %s", root->name, errno_str);
return -1;
}
}
else {
PROXY_LOG("%s: immediate connection", root->name);
conn->state = STATE_CREATE_SOCKET_PAIR;
}
return 0;
}
static int
rewrite_connection_create_sockets( RewriteConnection* conn )
{
/* immediate connection to the proxy. now create a socket
* pair and send a 'success' event to slirp */
int slirp_1;
ProxyConnection* root = conn->root;
if (socket_pair( &slirp_1, &conn->slirp_fd ) < 0) {
PROXY_LOG("%s: coult not create socket pair: %s",
root->name, errno_str);
return -1;
}
root->ev_func( root->ev_opaque, slirp_1, PROXY_EVENT_CONNECTED );
conn->state = STATE_REQUEST_FIRST_LINE;
return 0;
}
/* read the first line of a given HTTP request. returns -1/0/+1 */
static DataStatus
rewrite_connection_read_request( RewriteConnection* conn )
{
ProxyConnection* root = conn->root;
DataStatus ret;
ret = proxy_connection_receive_line(root, conn->slirp_fd);
if (ret == DATA_COMPLETED) {
/* now parse the first line to see if we can handle it */
char* line = root->str->s;
char* method;
char* uri;
char* version;
char* p = line;
method = strsep(&p, " ");
if (p == NULL) {
PROXY_LOG("%s: can't parse method in '%'",
root->name, line);
return DATA_ERROR;
}
uri = strsep(&p, " ");
if (p == NULL) {
PROXY_LOG( "%s: can't parse URI in '%s'",
root->name, line);
return DATA_ERROR;
}
version = strsep(&p, " ");
if (p != NULL) {
PROXY_LOG( "%s: extra data after version in '%s'",
root->name, line);
return DATA_ERROR;
}
if (conn->request)
http_request_free(conn->request);
conn->request = http_request_alloc( method, uri, version );
if (!conn->request)
return DATA_ERROR;
proxy_connection_rewind(root);
}
return ret;
}
static DataStatus
rewrite_connection_read_reply( RewriteConnection* conn )
{
ProxyConnection* root = conn->root;
DataStatus ret;
ret = proxy_connection_receive_line( root, root->socket );
if (ret == DATA_COMPLETED) {
HttpRequest* request = conn->request;
char* line = stralloc_cstr( root->str );
char* p = line;
char* protocol;
char* number;
char* readable;
protocol = strsep(&p, " ");
if (p == NULL) {
PROXY_LOG("%s: can't parse response protocol: '%s'",
root->name, line);
return DATA_ERROR;
}
number = strsep(&p, " ");
if (p == NULL) {
PROXY_LOG("%s: can't parse response number: '%s'",
root->name, line);
return DATA_ERROR;
}
readable = p;
if (http_request_set_reply(request, protocol, number, readable) < 0)
return DATA_ERROR;
proxy_connection_rewind(root);
}
return ret;
}
static DataStatus
rewrite_connection_read_headers( RewriteConnection* conn,
int fd )
{
int ret;
ProxyConnection* root = conn->root;
for (;;) {
char* line;
stralloc_t* str = root->str;
ret = proxy_connection_receive_line(root, fd);
if (ret != DATA_COMPLETED)
break;
str->n = 0;
line = str->s;
if (line[0] == 0) {
/* an empty line means the end of headers */
ret = 1;
break;
}
/* it this a continuation ? */
if (line[0] == ' ' || line[0] == '\t') {
ret = http_request_add_to_last_header( conn->request, line );
}
else {
char* key;
char* value;
value = line;
key = strsep(&value, ":");
if (value == NULL) {
PROXY_LOG("%s: can't parse header '%s'", root->name, line);
ret = -1;
break;
}
value += strspn(value, " ");
if (http_request_add_header(conn->request, key, value) < 0)
ret = -1;
}
if (ret == DATA_ERROR)
break;
}
return ret;
}
static int
rewrite_connection_rewrite_request( RewriteConnection* conn )
{
ProxyConnection* root = conn->root;
HttpService* service = (HttpService*) root->service;
HttpRequest* r = conn->request;
stralloc_t* str = root->str;
HttpHeader* h;
proxy_connection_rewind(conn->root);
/* only rewrite the URI if it is not absolute */
if (r->req_uri[0] == '/') {
char* host = http_request_find_header(r, "Host");
if (host == NULL) {
PROXY_LOG("%s: uh oh, not Host: in request ?", root->name);
} else {
/* now create new URI */
stralloc_add_str(str, "http://");
stralloc_add_str(str, host);
stralloc_add_str(str, r->req_uri);
http_request_replace_uri(r, stralloc_cstr(str));
proxy_connection_rewind(root);
}
}
stralloc_format( str, "%s %s %s\r\n", r->req_method, r->req_uri, r->req_version );
for (h = r->headers->first; h; h = h->next) {
stralloc_add_format( str, "%s: %s\r\n", h->key, h->value );
}
/* add the service's footer - includes final \r\n */
stralloc_add_bytes( str, service->footer, service->footer_len );
return 0;
}
static int
rewrite_connection_rewrite_reply( RewriteConnection* conn )
{
HttpRequest* r = conn->request;
ProxyConnection* root = conn->root;
stralloc_t* str = root->str;
HttpHeader* h;
proxy_connection_rewind(root);
stralloc_format(str, "%s %d %s\r\n", r->rep_version, r->rep_code, r->rep_readable);
for (h = r->headers->first; h; h = h->next) {
stralloc_add_format(str, "%s: %s\r\n", h->key, h->value);
}
stralloc_add_str(str, "\r\n");
return 0;
}
static int
rewrite_connection_get_body_length( RewriteConnection* conn,
int is_request )
{
HttpRequest* r = conn->request;
ProxyConnection* root = conn->root;
char* content_length;
char* transfer_encoding;
conn->body_mode = BODY_NONE;
conn->body_length = 0;
conn->body_total = 0;
conn->body_sent = 0;
conn->body_is_closed = 0;
conn->body_is_full = 0;
conn->body_has_data = 0;
proxy_connection_rewind(root);
if (is_request) {
/* only POST and PUT should have a body */
if (r->req_type != HTTP_REQUEST_POST &&
r->req_type != HTTP_REQUEST_PUT)
{
return 0;
}
} else {
/* HTTP 1.1 Section 4.3 Message Body states that HEAD requests must not have
* a message body, as well as any 1xx, 204 and 304 replies */
if (r->req_type == HTTP_REQUEST_HEAD || r->rep_code/100 == 1 ||
r->rep_code == 204 || r->rep_code == 304)
return 0;
}
content_length = http_request_find_header(r, "Content-Length");
if (content_length != NULL) {
char* end;
int64_t body_len = strtoll( content_length, &end, 10 );
if (*end != '\0' || *content_length == '\0' || body_len < 0) {
PROXY_LOG("%s: bad content length: %s", root->name, content_length);
return DATA_ERROR;
}
if (body_len > 0) {
conn->body_mode = BODY_KNOWN_LENGTH;
conn->body_length = body_len;
}
} else {
transfer_encoding = http_request_find_header(r, "Transfer-Encoding");
if (transfer_encoding && !strcasecmp(transfer_encoding, "Chunked")) {
conn->body_mode = BODY_CHUNKED;
conn->parse_chunk_header = 0;
conn->parse_chunk_trailer = 0;
conn->chunk_length = -1;
conn->chunk_total = 0;
conn->chunk_state = CHUNK_HEADER;
}
}
if (conn->body_mode == BODY_NONE) {
char* connection = http_request_find_header(r, "Proxy-Connection");
if (!connection)
connection = http_request_find_header(r, "Connection");
if (!connection || strcasecmp(connection, "Close")) {
/* hum, we can't support this at all */
PROXY_LOG("%s: can't determine content length, and client wants"
" to keep connection opened",
root->name);
return -1;
}
/* a negative value means that the data ends when the client
* disconnects the connection.
*/
conn->body_mode = BODY_UNTIL_CLOSE;
}
D("%s: body_length=%lld body_mode=%s",
root->name, conn->body_length,
body_mode_str[conn->body_mode]);
proxy_connection_rewind(root);
return 0;
}
#define MAX_BODY_BUFFER 65536
static DataStatus
rewrite_connection_read_body( RewriteConnection* conn, int fd )
{
ProxyConnection* root = conn->root;
stralloc_t* str = root->str;
int wanted = 0, current, avail;
DataStatus ret;
if (conn->body_is_closed) {
return DATA_NEED_MORE;
}
/* first, determine how many bytes we want to read. */
switch (conn->body_mode) {
case BODY_NONE:
D("%s: INTERNAL ERROR: SHOULDN'T BE THERE", root->name);
return DATA_COMPLETED;
case BODY_KNOWN_LENGTH:
{
if (conn->body_length == 0)
return DATA_COMPLETED;
if (conn->body_length > MAX_BODY_BUFFER)
wanted = MAX_BODY_BUFFER;
else
wanted = (int)conn->body_length;
}
break;
case BODY_UNTIL_CLOSE:
wanted = MAX_BODY_BUFFER;
break;
case BODY_CHUNKED:
if (conn->chunk_state == CHUNK_DATA_END) {
/* We're waiting for the CR LF after the chunk data */
ret = proxy_connection_receive_line(root, fd);
if (ret != DATA_COMPLETED)
return ret;
if (str->s[0] != 0) { /* this should be an empty line */
PROXY_LOG("%s: invalid chunk data end: '%s'",
root->name, str->s);
return DATA_ERROR;
}
/* proxy_connection_receive_line() did remove the
* trailing \r\n, but we must preserve it when we
* send the chunk size end to the proxy.
*/
stralloc_add_str(root->str, "\r\n");
conn->chunk_state = CHUNK_HEADER;
/* fall-through */
}
if (conn->chunk_state == CHUNK_HEADER) {
char* line;
char* end;
long long length;
/* Ensure that the previous chunk was flushed before
* accepting a new header */
if (!conn->parse_chunk_header) {
if (conn->body_has_data)
return DATA_NEED_MORE;
D("%s: waiting chunk header", root->name);
conn->parse_chunk_header = 1;
}
ret = proxy_connection_receive_line(root, fd);
if (ret != DATA_COMPLETED) {
return ret;
}
conn->parse_chunk_header = 0;
line = str->s;
length = strtoll(line, &end, 16);
if (line[0] == ' ' || (end[0] != '\0' && end[0] != ';')) {
PROXY_LOG("%s: invalid chunk header: %s",
root->name, line);
return DATA_ERROR;
}
if (length < 0) {
PROXY_LOG("%s: invalid chunk length %lld",
root->name, length);
return DATA_ERROR;
}
/* proxy_connection_receive_line() did remove the
* trailing \r\n, but we must preserve it when we
* send the chunk size to the proxy.
*/
stralloc_add_str(root->str, "\r\n");
conn->chunk_length = length;
conn->chunk_total = 0;
conn->chunk_state = CHUNK_DATA;
if (length == 0) {
/* the last chunk, no we need to add the trailer */
conn->chunk_state = CHUNK_TRAILER;
conn->parse_chunk_trailer = 0;
}
}
if (conn->chunk_state == CHUNK_TRAILER) {
/* ensure that 'str' is flushed before reading the trailer */
if (!conn->parse_chunk_trailer) {
if (conn->body_has_data)
return DATA_NEED_MORE;
conn->parse_chunk_trailer = 1;
}
ret = rewrite_connection_read_headers(conn, fd);
if (ret == DATA_COMPLETED) {
conn->body_is_closed = 1;
}
return ret;
}
/* if we get here, body_length > 0 */
if (conn->chunk_length > MAX_BODY_BUFFER)
wanted = MAX_BODY_BUFFER;
else
wanted = (int)conn->chunk_length;
break;
default:
;
}
/* we don't want more than MAX_BODY_BUFFER bytes in the
* buffer we used to pass the body */
current = str->n;
avail = MAX_BODY_BUFFER - current;
if (avail <= 0) {
/* wait for some flush */
conn->body_is_full = 1;
D("%s: waiting to flush %d bytes",
root->name, current);
return DATA_NEED_MORE;
}
if (wanted > avail)
wanted = avail;
ret = proxy_connection_receive(root, fd, wanted);
conn->body_has_data = (str->n > 0);
conn->body_is_full = (str->n == MAX_BODY_BUFFER);
if (ret == DATA_ERROR) {
if (conn->body_mode == BODY_UNTIL_CLOSE) {
/* a disconnection here is normal and signals the
* end of the body */
conn->body_total += root->str_recv;
D("%s: body completed by close (%lld bytes)",
root->name, conn->body_total);
conn->body_is_closed = 1;
ret = DATA_COMPLETED;
}
} else {
avail = root->str_recv;
ret = DATA_NEED_MORE; /* we're not really done yet */
switch (conn->body_mode) {
case BODY_CHUNKED:
conn->chunk_total += avail;
conn->chunk_length -= avail;
if (conn->chunk_length == 0) {
D("%s: chunk completed (%lld bytes)",
root->name, conn->chunk_total);
conn->body_total += conn->chunk_total;
conn->chunk_total = 0;
conn->chunk_length = -1;
conn->chunk_state = CHUNK_DATA;
}
break;
case BODY_KNOWN_LENGTH:
conn->body_length -= avail;
conn->body_total += avail;
if (conn->body_length == 0) {
D("%s: body completed (%lld bytes)",
root->name, conn->body_total);
conn->body_is_closed = 1;
ret = DATA_COMPLETED;
}
break;
case BODY_UNTIL_CLOSE:
conn->body_total += avail;
break;
default:
;
}
}
return ret;
}
static DataStatus
rewrite_connection_send_body( RewriteConnection* conn, int fd )
{
ProxyConnection* root = conn->root;
stralloc_t* str = root->str;
DataStatus ret = DATA_NEED_MORE;
if (conn->body_has_data) {
ret = proxy_connection_send(root, fd);
if (ret != DATA_ERROR) {
int pos = root->str_pos;
memmove(str->s, str->s+pos, str->n-pos);
str->n -= pos;
root->str_pos = 0;
conn->body_is_full = (str->n == MAX_BODY_BUFFER);
conn->body_has_data = (str->n > 0);
conn->body_sent += root->str_sent;
/* ensure that we return DATA_COMPLETED only when
* we have sent everything, and there is no more
* body pieces to read */
if (ret == DATA_COMPLETED) {
if (!conn->body_is_closed || conn->body_has_data)
ret = DATA_NEED_MORE;
else {
D("%s: sent all body (%lld bytes)",
root->name, conn->body_sent);
}
}
D("%s: sent closed=%d data=%d n=%d ret=%d",
root->name, conn->body_is_closed,
conn->body_has_data, str->n,
ret);
}
}
return ret;
}
static void
rewrite_connection_select( ProxyConnection* root,
ProxySelect* sel )
{
RewriteConnection* conn = (RewriteConnection*)root;
int slirp = conn->slirp_fd;
int proxy = root->socket;
switch (conn->state) {
case STATE_CONNECTING:
case STATE_CREATE_SOCKET_PAIR:
/* try to connect to the proxy server */
proxy_select_set( sel, proxy, PROXY_SELECT_WRITE );
break;
case STATE_REQUEST_FIRST_LINE:
case STATE_REQUEST_HEADERS:
proxy_select_set( sel, slirp, PROXY_SELECT_READ );
break;
case STATE_REQUEST_SEND:
proxy_select_set( sel, proxy, PROXY_SELECT_WRITE );
break;
case STATE_REQUEST_BODY:
if (!conn->body_is_closed && !conn->body_is_full)
proxy_select_set( sel, slirp, PROXY_SELECT_READ );
if (conn->body_has_data)
proxy_select_set( sel, proxy, PROXY_SELECT_WRITE );
break;
case STATE_REPLY_FIRST_LINE:
case STATE_REPLY_HEADERS:
proxy_select_set( sel, proxy, PROXY_SELECT_READ );
break;
case STATE_REPLY_SEND:
proxy_select_set( sel, slirp, PROXY_SELECT_WRITE );
break;
case STATE_REPLY_BODY:
if (conn->body_has_data)
proxy_select_set( sel, slirp, PROXY_SELECT_WRITE );
if (!conn->body_is_closed && !conn->body_is_full)
proxy_select_set( sel, proxy, PROXY_SELECT_READ );
break;
default:
;
};
}
static void
rewrite_connection_poll( ProxyConnection* root,
ProxySelect* sel )
{
RewriteConnection* conn = (RewriteConnection*)root;
int slirp = conn->slirp_fd;
int proxy = root->socket;
int has_slirp = proxy_select_poll(sel, slirp);
int has_proxy = proxy_select_poll(sel, proxy);
DataStatus ret = DATA_NEED_MORE;
switch (conn->state) {
case STATE_CONNECTING:
if (has_proxy) {
PROXY_LOG("%s: connected to proxy", root->name);
conn->state = STATE_CREATE_SOCKET_PAIR;
}
break;
case STATE_CREATE_SOCKET_PAIR:
if (has_proxy) {
if (rewrite_connection_create_sockets(conn) < 0) {
ret = DATA_ERROR;
} else {
D("%s: socket pair created", root->name);
conn->state = STATE_REQUEST_FIRST_LINE;
}
}
break;
case STATE_REQUEST_FIRST_LINE:
if (has_slirp) {
ret = rewrite_connection_read_request(conn);
if (ret == DATA_COMPLETED) {
PROXY_LOG("%s: request first line ok", root->name);
conn->state = STATE_REQUEST_HEADERS;
}
}
break;
case STATE_REQUEST_HEADERS:
if (has_slirp) {
ret = rewrite_connection_read_headers(conn, slirp);
if (ret == DATA_COMPLETED) {
PROXY_LOG("%s: request headers ok", root->name);
if (rewrite_connection_rewrite_request(conn) < 0)
ret = DATA_ERROR;
else
conn->state = STATE_REQUEST_SEND;
}
}
break;
case STATE_REQUEST_SEND:
if (has_proxy) {
ret = proxy_connection_send(root, proxy);
if (ret == DATA_COMPLETED) {
if (rewrite_connection_get_body_length(conn, 1) < 0) {
ret = DATA_ERROR;
} else if (conn->body_mode != BODY_NONE) {
PROXY_LOG("%s: request sent, waiting for body",
root->name);
conn->state = STATE_REQUEST_BODY;
} else {
PROXY_LOG("%s: request sent, waiting for reply",
root->name);
conn->state = STATE_REPLY_FIRST_LINE;
}
}
}
break;
case STATE_REQUEST_BODY:
if (has_slirp) {
ret = rewrite_connection_read_body(conn, slirp);
}
if (ret != DATA_ERROR && has_proxy) {
ret = rewrite_connection_send_body(conn, proxy);
if (ret == DATA_COMPLETED) {
PROXY_LOG("%s: request body ok, waiting for reply",
root->name);
conn->state = STATE_REPLY_FIRST_LINE;
}
}
break;
case STATE_REPLY_FIRST_LINE:
if (has_proxy) {
ret = rewrite_connection_read_reply(conn);
if (ret == DATA_COMPLETED) {
PROXY_LOG("%s: reply first line ok", root->name);
conn->state = STATE_REPLY_HEADERS;
}
}
break;
case STATE_REPLY_HEADERS:
if (has_proxy) {
ret = rewrite_connection_read_headers(conn, proxy);
if (ret == DATA_COMPLETED) {
PROXY_LOG("%s: reply headers ok", root->name);
if (rewrite_connection_rewrite_reply(conn) < 0)
ret = DATA_ERROR;
else
conn->state = STATE_REPLY_SEND;
}
}
break;
case STATE_REPLY_SEND:
if (has_slirp) {
ret = proxy_connection_send(conn->root, slirp);
if (ret == DATA_COMPLETED) {
if (rewrite_connection_get_body_length(conn, 0) < 0) {
ret = DATA_ERROR;
} else if (conn->body_mode != BODY_NONE) {
PROXY_LOG("%s: reply sent, waiting for body",
root->name);
conn->state = STATE_REPLY_BODY;
} else {
PROXY_LOG("%s: reply sent, looping to waiting request",
root->name);
conn->state = STATE_REQUEST_FIRST_LINE;
}
}
}
break;
case STATE_REPLY_BODY:
if (has_proxy) {
ret = rewrite_connection_read_body(conn, proxy);
}
if (ret != DATA_ERROR && has_slirp) {
ret = rewrite_connection_send_body(conn, slirp);
if (ret == DATA_COMPLETED) {
if (conn->body_mode == BODY_UNTIL_CLOSE) {
PROXY_LOG("%s: closing connection", root->name);
ret = DATA_ERROR;
} else {
PROXY_LOG("%s: reply body ok, looping to waiting request",
root->name);
conn->state = STATE_REQUEST_FIRST_LINE;
}
}
}
break;
default:
;
}
if (ret == DATA_ERROR)
proxy_connection_free(root, 0, PROXY_EVENT_NONE);
return;
}
ProxyConnection*
http_rewriter_connect( HttpService* service,
SockAddress* address )
{
RewriteConnection* conn;
int s;
s = socket_create(address->family, SOCKET_STREAM );
if (s < 0)
return NULL;
conn = qemu_mallocz(sizeof(*conn));
if (conn == NULL) {
socket_close(s);
return NULL;
}
proxy_connection_init( conn->root, s, address, service->root,
rewrite_connection_free,
rewrite_connection_select,
rewrite_connection_poll );
if ( rewrite_connection_init( conn ) < 0 ) {
rewrite_connection_free( conn->root );
return NULL;
}
return conn->root;
}