Context Navigation

source: lib/proxy.c @ 4c225f0

Last change on this file since 4c225f0 was a010498, checked in by Wilmer van der Gaast <wilmer@…>, at 2011-07-12T08:04:12Z
Fixed dumb file descriptor leak.
Property mode set to `100644`
File size: 13.6 KB

Line
1	/*
2	* gaim
3	*
4	* Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
5	* Copyright (C) 2002-2004, Wilmer van der Gaast, Jelmer Vernooij
6	*
7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20	*
21	*/
22
23	#define BITLBEE_CORE
24	#include <stdio.h>
25	#include <stdlib.h>
26	#include <string.h>
27	#include <sys/types.h>
28	#ifndef _WIN32
29	#include <sys/socket.h>
30	#include <netdb.h>
31	#include <netinet/in.h>
32	#include <arpa/inet.h>
33	#include <unistd.h>
34	#else
35	#include "sock.h"
36	#define ETIMEDOUT WSAETIMEDOUT
37	#define EINPROGRESS WSAEINPROGRESS
38	#endif
39	#include <fcntl.h>
40	#include <errno.h>
41	#include "nogaim.h"
42	#include "proxy.h"
43	#include "base64.h"
44
45	char proxyhost[128] = "";
46	int proxyport = 0;
47	int proxytype = PROXY_NONE;
48	char proxyuser[128] = "";
49	char proxypass[128] = "";
50
51	/* Some systems don't know this one. It's not essential, so set it to 0 then. */
52	#ifndef AI_NUMERICSERV
53	#define AI_NUMERICSERV 0
54	#endif
55	#ifndef AI_ADDRCONFIG
56	#define AI_ADDRCONFIG 0
57	#endif
58
59	struct PHB {
60	b_event_handler func, proxy_func;
61	gpointer data, proxy_data;
62	char *host;
63	int port;
64	int fd;
65	gint inpa;
66	struct addrinfo gai, gai_cur;
67	};
68
69	static int proxy_connect_none(const char host, unsigned short port_, struct PHB phb);
70
71	static gboolean gaim_io_connected(gpointer data, gint source, b_input_condition cond)
72	{
73	struct PHB *phb = data;
74	unsigned int len;
75	int error = ETIMEDOUT;
76	len = sizeof(error);
77
78	#ifndef _WIN32
79	if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0 \|\| error) {
80	if ((phb->gai_cur = phb->gai_cur->ai_next)) {
81	int new_fd;
82	b_event_remove(phb->inpa);
83	if ((new_fd = proxy_connect_none(NULL, 0, phb))) {
84	b_event_remove(phb->inpa);
85	closesocket(source);
86	dup2(new_fd, source);
87	closesocket(new_fd);
88	phb->inpa = b_input_add(source, B_EV_IO_WRITE, gaim_io_connected, phb);
89	return FALSE;
90	}
91	}
92	freeaddrinfo(phb->gai);
93	closesocket(source);
94	b_event_remove(phb->inpa);
95	if( phb->proxy_func )
96	phb->proxy_func(phb->proxy_data, -1, B_EV_IO_READ);
97	else {
98	phb->func(phb->data, -1, B_EV_IO_READ);
99	g_free(phb);
100	}
101	return FALSE;
102	}
103	#endif
104	freeaddrinfo(phb->gai);
105	sock_make_blocking(source);
106	b_event_remove(phb->inpa);
107	if( phb->proxy_func )
108	phb->proxy_func(phb->proxy_data, source, B_EV_IO_READ);
109	else {
110	phb->func(phb->data, source, B_EV_IO_READ);
111	g_free(phb);
112	}
113
114	return FALSE;
115	}
116
117	static int proxy_connect_none(const char host, unsigned short port_, struct PHB phb)
118	{
119	struct sockaddr_in me;
120	int fd = -1;
121
122	if (phb->gai_cur == NULL)
123	{
124	int ret;
125	char port[6];
126	struct addrinfo hints;
127
128	g_snprintf(port, sizeof(port), "%d", port_);
129
130	memset(&hints, 0, sizeof(struct addrinfo));
131	hints.ai_family = AF_UNSPEC;
132	hints.ai_socktype = SOCK_STREAM;
133	hints.ai_flags = AI_ADDRCONFIG \| AI_NUMERICSERV;
134
135	if (!(ret = getaddrinfo(host, port, &hints, &phb->gai)))
136	phb->gai_cur = phb->gai;
137	else
138	event_debug("gai(): %s\n", gai_strerror(ret));
139	}
140
141	for (; phb->gai_cur; phb->gai_cur = phb->gai_cur->ai_next)
142	{
143	if ((fd = socket(phb->gai_cur->ai_family, phb->gai_cur->ai_socktype, phb->gai_cur->ai_protocol)) < 0) {
144	event_debug( "socket failed: %d\n", errno);
145	continue;
146	}
147
148	sock_make_nonblocking(fd);
149
150	if (global.conf->iface_out)
151	{
152	me.sin_family = AF_INET;
153	me.sin_port = 0;
154	me.sin_addr.s_addr = inet_addr( global.conf->iface_out );
155
156	if (bind(fd, (struct sockaddr *) &me, sizeof(me)) != 0)
157	event_debug("bind( %d, \"%s\" ) failure\n", fd, global.conf->iface_out);
158	}
159
160	event_debug("proxy_connect_none( \"%s\", %d ) = %d\n", host, port, fd);
161
162	if (connect(fd, phb->gai_cur->ai_addr, phb->gai_cur->ai_addrlen) < 0 && !sockerr_again()) {
163	event_debug( "connect failed: %s\n", strerror(errno));
164	closesocket(fd);
165	fd = -1;
166	continue;
167	} else {
168	phb->inpa = b_input_add(fd, B_EV_IO_WRITE, gaim_io_connected, phb);
169	phb->fd = fd;
170
171	break;
172	}
173	}
174
175	if(fd < 0 && host)
176	g_free(phb);
177
178	return fd;
179	}
180
181
182	/* Connecting to HTTP proxies */
183
184	#define HTTP_GOODSTRING "HTTP/1.0 200 Connection established"
185	#define HTTP_GOODSTRING2 "HTTP/1.1 200 Connection established"
186
187	static gboolean http_canread(gpointer data, gint source, b_input_condition cond)
188	{
189	int nlc = 0;
190	int pos = 0;
191	struct PHB *phb = data;
192	char inputline[8192];
193
194	b_event_remove(phb->inpa);
195
196	while ((pos < sizeof(inputline)-1) && (nlc != 2) && (read(source, &inputline[pos++], 1) == 1)) {
197	if (inputline[pos - 1] == '\n')
198	nlc++;
199	else if (inputline[pos - 1] != '\r')
200	nlc = 0;
201	}
202	inputline[pos] = '\0';
203
204	if ((memcmp(HTTP_GOODSTRING, inputline, strlen(HTTP_GOODSTRING)) == 0) \|\|
205	(memcmp(HTTP_GOODSTRING2, inputline, strlen(HTTP_GOODSTRING2)) == 0)) {
206	phb->func(phb->data, source, B_EV_IO_READ);
207	g_free(phb->host);
208	g_free(phb);
209	return FALSE;
210	}
211
212	close(source);
213	phb->func(phb->data, -1, B_EV_IO_READ);
214	g_free(phb->host);
215	g_free(phb);
216
217	return FALSE;
218	}
219
220	static gboolean http_canwrite(gpointer data, gint source, b_input_condition cond)
221	{
222	char cmd[384];
223	struct PHB *phb = data;
224	unsigned int len;
225	int error = ETIMEDOUT;
226	if (phb->inpa > 0)
227	b_event_remove(phb->inpa);
228	len = sizeof(error);
229	if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
230	close(source);
231	phb->func(phb->data, -1, B_EV_IO_READ);
232	g_free(phb->host);
233	g_free(phb);
234	return FALSE;
235	}
236	sock_make_blocking(source);
237
238	g_snprintf(cmd, sizeof(cmd), "CONNECT %s:%d HTTP/1.1\r\nHost: %s:%d\r\n", phb->host, phb->port,
239	phb->host, phb->port);
240	if (send(source, cmd, strlen(cmd), 0) < 0) {
241	close(source);
242	phb->func(phb->data, -1, B_EV_IO_READ);
243	g_free(phb->host);
244	g_free(phb);
245	return FALSE;
246	}
247
248	if (strlen(proxyuser) > 0) {
249	char t1, t2;
250	t1 = g_strdup_printf("%s:%s", proxyuser, proxypass);
251	t2 = tobase64(t1);
252	g_free(t1);
253	g_snprintf(cmd, sizeof(cmd), "Proxy-Authorization: Basic %s\r\n", t2);
254	g_free(t2);
255	if (send(source, cmd, strlen(cmd), 0) < 0) {
256	close(source);
257	phb->func(phb->data, -1, B_EV_IO_READ);
258	g_free(phb->host);
259	g_free(phb);
260	return FALSE;
261	}
262	}
263
264	g_snprintf(cmd, sizeof(cmd), "\r\n");
265	if (send(source, cmd, strlen(cmd), 0) < 0) {
266	close(source);
267	phb->func(phb->data, -1, B_EV_IO_READ);
268	g_free(phb->host);
269	g_free(phb);
270	return FALSE;
271	}
272
273	phb->inpa = b_input_add(source, B_EV_IO_READ, http_canread, phb);
274
275	return FALSE;
276	}
277
278	static int proxy_connect_http(const char host, unsigned short port, struct PHB phb)
279	{
280	phb->host = g_strdup(host);
281	phb->port = port;
282	phb->proxy_func = http_canwrite;
283	phb->proxy_data = phb;
284
285	return( proxy_connect_none( proxyhost, proxyport, phb ) );
286	}
287
288
289	/* Connecting to SOCKS4 proxies */
290
291	static gboolean s4_canread(gpointer data, gint source, b_input_condition cond)
292	{
293	unsigned char packet[12];
294	struct PHB *phb = data;
295
296	b_event_remove(phb->inpa);
297
298	memset(packet, 0, sizeof(packet));
299	if (read(source, packet, 9) >= 4 && packet[1] == 90) {
300	phb->func(phb->data, source, B_EV_IO_READ);
301	g_free(phb->host);
302	g_free(phb);
303	return FALSE;
304	}
305
306	close(source);
307	phb->func(phb->data, -1, B_EV_IO_READ);
308	g_free(phb->host);
309	g_free(phb);
310
311	return FALSE;
312	}
313
314	static gboolean s4_canwrite(gpointer data, gint source, b_input_condition cond)
315	{
316	unsigned char packet[12];
317	struct hostent *hp;
318	struct PHB *phb = data;
319	unsigned int len;
320	int error = ETIMEDOUT;
321	if (phb->inpa > 0)
322	b_event_remove(phb->inpa);
323	len = sizeof(error);
324	if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
325	close(source);
326	phb->func(phb->data, -1, B_EV_IO_READ);
327	g_free(phb->host);
328	g_free(phb);
329	return FALSE;
330	}
331	sock_make_blocking(source);
332
333	/* XXX does socks4 not support host name lookups by the proxy? */
334	if (!(hp = gethostbyname(phb->host))) {
335	close(source);
336	phb->func(phb->data, -1, B_EV_IO_READ);
337	g_free(phb->host);
338	g_free(phb);
339	return FALSE;
340	}
341
342	packet[0] = 4;
343	packet[1] = 1;
344	packet[2] = phb->port >> 8;
345	packet[3] = phb->port & 0xff;
346	packet[4] = (unsigned char)(hp->h_addr_list[0])[0];
347	packet[5] = (unsigned char)(hp->h_addr_list[0])[1];
348	packet[6] = (unsigned char)(hp->h_addr_list[0])[2];
349	packet[7] = (unsigned char)(hp->h_addr_list[0])[3];
350	packet[8] = 0;
351	if (write(source, packet, 9) != 9) {
352	close(source);
353	phb->func(phb->data, -1, B_EV_IO_READ);
354	g_free(phb->host);
355	g_free(phb);
356	return FALSE;
357	}
358
359	phb->inpa = b_input_add(source, B_EV_IO_READ, s4_canread, phb);
360
361	return FALSE;
362	}
363
364	static int proxy_connect_socks4(const char host, unsigned short port, struct PHB phb)
365	{
366	phb->host = g_strdup(host);
367	phb->port = port;
368	phb->proxy_func = s4_canwrite;
369	phb->proxy_data = phb;
370
371	return( proxy_connect_none( proxyhost, proxyport, phb ) );
372	}
373
374
375	/* Connecting to SOCKS5 proxies */
376
377	static gboolean s5_canread_again(gpointer data, gint source, b_input_condition cond)
378	{
379	unsigned char buf[512];
380	struct PHB *phb = data;
381
382	b_event_remove(phb->inpa);
383
384	if (read(source, buf, 10) < 10) {
385	close(source);
386	phb->func(phb->data, -1, B_EV_IO_READ);
387	g_free(phb->host);
388	g_free(phb);
389	return FALSE;
390	}
391	if ((buf[0] != 0x05) \|\| (buf[1] != 0x00)) {
392	close(source);
393	phb->func(phb->data, -1, B_EV_IO_READ);
394	g_free(phb->host);
395	g_free(phb);
396	return FALSE;
397	}
398
399	phb->func(phb->data, source, B_EV_IO_READ);
400	g_free(phb->host);
401	g_free(phb);
402
403	return FALSE;
404	}
405
406	static void s5_sendconnect(gpointer data, gint source)
407	{
408	unsigned char buf[512];
409	struct PHB *phb = data;
410	int hlen = strlen(phb->host);
411
412	buf[0] = 0x05;
413	buf[1] = 0x01; /* CONNECT */
414	buf[2] = 0x00; /* reserved */
415	buf[3] = 0x03; /* address type -- host name */
416	buf[4] = hlen;
417	memcpy(buf + 5, phb->host, hlen);
418	buf[5 + strlen(phb->host)] = phb->port >> 8;
419	buf[5 + strlen(phb->host) + 1] = phb->port & 0xff;
420
421	if (write(source, buf, (5 + strlen(phb->host) + 2)) < (5 + strlen(phb->host) + 2)) {
422	close(source);
423	phb->func(phb->data, -1, B_EV_IO_READ);
424	g_free(phb->host);
425	g_free(phb);
426	return;
427	}
428
429	phb->inpa = b_input_add(source, B_EV_IO_READ, s5_canread_again, phb);
430	}
431
432	static gboolean s5_readauth(gpointer data, gint source, b_input_condition cond)
433	{
434	unsigned char buf[512];
435	struct PHB *phb = data;
436
437	b_event_remove(phb->inpa);
438
439	if (read(source, buf, 2) < 2) {
440	close(source);
441	phb->func(phb->data, -1, B_EV_IO_READ);
442	g_free(phb->host);
443	g_free(phb);
444	return FALSE;
445	}
446
447	if ((buf[0] != 0x01) \|\| (buf[1] != 0x00)) {
448	close(source);
449	phb->func(phb->data, -1, B_EV_IO_READ);
450	g_free(phb->host);
451	g_free(phb);
452	return FALSE;
453	}
454
455	s5_sendconnect(phb, source);
456
457	return FALSE;
458	}
459
460	static gboolean s5_canread(gpointer data, gint source, b_input_condition cond)
461	{
462	unsigned char buf[512];
463	struct PHB *phb = data;
464
465	b_event_remove(phb->inpa);
466
467	if (read(source, buf, 2) < 2) {
468	close(source);
469	phb->func(phb->data, -1, B_EV_IO_READ);
470	g_free(phb->host);
471	g_free(phb);
472	return FALSE;
473	}
474
475	if ((buf[0] != 0x05) \|\| (buf[1] == 0xff)) {
476	close(source);
477	phb->func(phb->data, -1, B_EV_IO_READ);
478	g_free(phb->host);
479	g_free(phb);
480	return FALSE;
481	}
482
483	if (buf[1] == 0x02) {
484	unsigned int i = strlen(proxyuser), j = strlen(proxypass);
485	buf[0] = 0x01; /* version 1 */
486	buf[1] = i;
487	memcpy(buf + 2, proxyuser, i);
488	buf[2 + i] = j;
489	memcpy(buf + 2 + i + 1, proxypass, j);
490	if (write(source, buf, 3 + i + j) < 3 + i + j) {
491	close(source);
492	phb->func(phb->data, -1, B_EV_IO_READ);
493	g_free(phb->host);
494	g_free(phb);
495	return FALSE;
496	}
497
498	phb->inpa = b_input_add(source, B_EV_IO_READ, s5_readauth, phb);
499	} else {
500	s5_sendconnect(phb, source);
501	}
502
503	return FALSE;
504	}
505
506	static gboolean s5_canwrite(gpointer data, gint source, b_input_condition cond)
507	{
508	unsigned char buf[512];
509	int i;
510	struct PHB *phb = data;
511	unsigned int len;
512	int error = ETIMEDOUT;
513	if (phb->inpa > 0)
514	b_event_remove(phb->inpa);
515	len = sizeof(error);
516	if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
517	close(source);
518	phb->func(phb->data, -1, B_EV_IO_READ);
519	g_free(phb->host);
520	g_free(phb);
521	return FALSE;
522	}
523	sock_make_blocking(source);
524
525	i = 0;
526	buf[0] = 0x05; /* SOCKS version 5 */
527	if (proxyuser[0]) {
528	buf[1] = 0x02; /* two methods */
529	buf[2] = 0x00; /* no authentication */
530	buf[3] = 0x02; /* username/password authentication */
531	i = 4;
532	} else {
533	buf[1] = 0x01;
534	buf[2] = 0x00;
535	i = 3;
536	}
537
538	if (write(source, buf, i) < i) {
539	close(source);
540	phb->func(phb->data, -1, B_EV_IO_READ);
541	g_free(phb->host);
542	g_free(phb);
543	return FALSE;
544	}
545
546	phb->inpa = b_input_add(source, B_EV_IO_READ, s5_canread, phb);
547
548	return FALSE;
549	}
550
551	static int proxy_connect_socks5(const char host, unsigned short port, struct PHB phb)
552	{
553	phb->host = g_strdup(host);
554	phb->port = port;
555	phb->proxy_func = s5_canwrite;
556	phb->proxy_data = phb;
557
558	return( proxy_connect_none( proxyhost, proxyport, phb ) );
559	}
560
561
562	/* Export functions */
563
564	int proxy_connect(const char *host, int port, b_event_handler func, gpointer data)
565	{
566	struct PHB *phb;
567
568	if (!host \|\| port <= 0 \|\| !func \|\| strlen(host) > 128) {
569	return -1;
570	}
571
572	phb = g_new0(struct PHB, 1);
573	phb->func = func;
574	phb->data = data;
575
576	if (proxytype == PROXY_NONE \|\| !proxyhost[0] \|\| proxyport <= 0)
577	return proxy_connect_none(host, port, phb);
578	else if (proxytype == PROXY_HTTP)
579	return proxy_connect_http(host, port, phb);
580	else if (proxytype == PROXY_SOCKS4)
581	return proxy_connect_socks4(host, port, phb);
582	else if (proxytype == PROXY_SOCKS5)
583	return proxy_connect_socks5(host, port, phb);
584
585	g_free(phb);
586	return -1;
587	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: