1 /* Copyright (C) 2007-2008 The Android Open Source Project
2 **
3 ** This software is licensed under the terms of the GNU General Public
4 ** License version 2, as published by the Free Software Foundation, and
5 ** may be copied, distributed, and modified under those terms.
6 **
7 ** This program is distributed in the hope that it will be useful,
8 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
9 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 ** GNU General Public License for more details.
11 */
12 #include "proxy_int.h"
13 #include "proxy_http_int.h"
14 #include "qemu-common.h"
15 #include <errno.h>
16 #include <stdio.h>
17 #include <string.h>
18
19 #define HTTP_VERSION "1.1"
20
21 static void
http_service_free(HttpService * service)22 http_service_free( HttpService* service )
23 {
24 PROXY_LOG("%s", __FUNCTION__);
25 if (service->footer != service->footer0)
26 g_free(service->footer);
27 g_free(service);
28 }
29
30
31 static ProxyConnection*
http_service_connect(HttpService * service,SocketType sock_type,SockAddress * address)32 http_service_connect( HttpService* service,
33 SocketType sock_type,
34 SockAddress* address )
35 {
36 /* the HTTP proxy can only handle TCP connections */
37 if (sock_type != SOCKET_STREAM)
38 return NULL;
39
40 /* if the client tries to directly connect to the proxy, let it do so */
41 if (sock_address_equal( address, &service->server_addr ))
42 return NULL;
43
44 PROXY_LOG("%s: trying to connect to %s",
45 __FUNCTION__, sock_address_to_string(address));
46
47 if (sock_address_get_port(address) == 80) {
48 /* use the rewriter for HTTP */
49 PROXY_LOG("%s: using HTTP rewriter", __FUNCTION__);
50 return http_rewriter_connect(service, address);
51 } else {
52 PROXY_LOG("%s: using HTTP rewriter", __FUNCTION__);
53 return http_connector_connect(service, address);
54 }
55 }
56
57
58 int
proxy_http_setup(const char * servername,int servernamelen,int serverport,int num_options,const ProxyOption * options)59 proxy_http_setup( const char* servername,
60 int servernamelen,
61 int serverport,
62 int num_options,
63 const ProxyOption* options )
64 {
65 HttpService* service;
66 SockAddress server_addr;
67 const ProxyOption* opt_nocache = NULL;
68 const ProxyOption* opt_keepalive = NULL;
69 const ProxyOption* opt_auth_user = NULL;
70 const ProxyOption* opt_auth_pass = NULL;
71 const ProxyOption* opt_user_agent = NULL;
72
73 if (servernamelen < 0)
74 servernamelen = strlen(servername);
75
76 PROXY_LOG( "%s: creating http proxy service connecting to: %.*s:%d",
77 __FUNCTION__, servernamelen, servername, serverport );
78
79 /* resolve server address */
80 if (proxy_resolve_server(&server_addr, servername,
81 servernamelen, serverport) < 0)
82 {
83 return -1;
84 }
85
86 /* create service object */
87 service = g_malloc0(sizeof(*service));
88 if (service == NULL) {
89 PROXY_LOG("%s: not enough memory to allocate new proxy service", __FUNCTION__);
90 return -1;
91 }
92
93 service->server_addr = server_addr;
94
95 /* parse options */
96 {
97 const ProxyOption* opt = options;
98 const ProxyOption* end = opt + num_options;
99
100 for ( ; opt < end; opt++ ) {
101 switch (opt->type) {
102 case PROXY_OPTION_HTTP_NOCACHE: opt_nocache = opt; break;
103 case PROXY_OPTION_HTTP_KEEPALIVE: opt_keepalive = opt; break;
104 case PROXY_OPTION_AUTH_USERNAME: opt_auth_user = opt; break;
105 case PROXY_OPTION_AUTH_PASSWORD: opt_auth_pass = opt; break;
106 case PROXY_OPTION_HTTP_USER_AGENT: opt_user_agent = opt; break;
107 default: ;
108 }
109 }
110 }
111
112 /* prepare footer */
113 {
114 int wlen;
115 char* p = service->footer0;
116 char* end = p + sizeof(service->footer0);
117
118 /* no-cache */
119 if (opt_nocache) {
120 p += snprintf(p, end-p, "Pragma: no-cache\r\nCache-Control: no-cache\r\n");
121 if (p >= end) goto FooterOverflow;
122 }
123 /* keep-alive */
124 if (opt_keepalive) {
125 p += snprintf(p, end-p, "Connection: Keep-Alive\r\nProxy-Connection: Keep-Alive\r\n");
126 if (p >= end) goto FooterOverflow;
127 }
128 /* authentication */
129 if (opt_auth_user && opt_auth_pass) {
130 char user_pass[256];
131 char encoded[512];
132 int uplen;
133
134 uplen = snprintf( user_pass, sizeof(user_pass), "%.*s:%.*s",
135 opt_auth_user->string_len, opt_auth_user->string,
136 opt_auth_pass->string_len, opt_auth_pass->string );
137
138 if (uplen >= sizeof(user_pass)) goto FooterOverflow;
139
140 wlen = proxy_base64_encode(user_pass, uplen, encoded, (int)sizeof(encoded));
141 if (wlen < 0) {
142 PROXY_LOG( "could not base64 encode '%.*s'", uplen, user_pass);
143 goto FooterOverflow;
144 }
145
146 p += snprintf(p, end-p, "Proxy-authorization: Basic %.*s\r\n", wlen, encoded);
147 if (p >= end) goto FooterOverflow;
148 }
149 /* user agent */
150 if (opt_user_agent) {
151 p += snprintf(p, end-p, "User-Agent: %.*s\r\n",
152 opt_user_agent->string_len,
153 opt_user_agent->string);
154 if (p >= end) goto FooterOverflow;
155 }
156
157 p += snprintf(p, end-p, "\r\n");
158
159 if (p >= end) {
160 FooterOverflow:
161 PROXY_LOG( "%s: buffer overflow when creating connection footer",
162 __FUNCTION__);
163 http_service_free(service);
164 return -1;
165 }
166
167 service->footer = service->footer0;
168 service->footer_len = (p - service->footer);
169 }
170
171 PROXY_LOG( "%s: creating HTTP Proxy Service Footer is (len=%d):\n'%.*s'",
172 __FUNCTION__, service->footer_len,
173 service->footer_len, service->footer );
174
175 service->root->opaque = service;
176 service->root->serv_free = (ProxyServiceFreeFunc) http_service_free;
177 service->root->serv_connect = (ProxyServiceConnectFunc) http_service_connect;
178
179 if (proxy_manager_add_service( service->root ) < 0) {
180 PROXY_LOG("%s: could not register service ?", __FUNCTION__);
181 http_service_free(service);
182 return -1;
183 }
184 return 0;
185 }
186
187