Initial repository (0.99 release tree)0.99

1 files changed, 672 insertions, 0 deletions

diff --git a/protocols/proxy.c b/protocols/proxy.c
new file mode 100644
index 00000000..b0196e12
--- /dev/null
+++ b/protocols/proxy.c
@@ -0,0 +1,672 @@
+/*
+ * gaim
+ *
+ * Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
+ * Copyright (C) 2002-2004, Wilmer van der Gaast, Jelmer Vernooij
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+/* this is a little piece of code to handle proxy connection */
+/* it is intended to : 1st handle http proxy, using the CONNECT command
+ , 2nd provide an easy way to add socks support */
+
+#define BITLBEE_CORE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#ifndef _WIN32
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#else
+#include "sock.h"
+#define ETIMEDOUT WSAETIMEDOUT
+#define EINPROGRESS WSAEINPROGRESS
+#endif
+#include <fcntl.h>
+#include <errno.h>
+#include "nogaim.h"
+#include "proxy.h"
+
+#define GAIM_READ_COND  (G_IO_IN | G_IO_HUP | G_IO_ERR)
+#define GAIM_WRITE_COND (G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL)
+#define GAIM_ERR_COND   (G_IO_HUP | G_IO_ERR | G_IO_NVAL)
+
+/*FIXME*		
+	#ifndef _WIN32
+		if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
+			closesocket(fd);
+			g_free(phb);
+			return -1;
+		}
+		fcntl(fd, F_SETFL, 0);
+#endif*/
+
+char proxyhost[128] = "";
+int proxyport = 0;
+int proxytype = PROXY_NONE;
+char proxyuser[128] = "";
+char proxypass[128] = "";
+
+struct PHB {
+	GaimInputFunction func, proxy_func;
+	gpointer data, proxy_data;
+	char *host;
+	int port;
+	int fd;
+	gint inpa;
+};
+
+typedef struct _GaimIOClosure {
+	GaimInputFunction function;
+	guint result;
+	gpointer data;
+} GaimIOClosure;
+
+
+
+static struct sockaddr_in *gaim_gethostbyname(char *host, int port)
+{
+	static struct sockaddr_in sin;
+
+	if (!inet_aton(host, &sin.sin_addr)) {
+		struct hostent *hp;
+		if (!(hp = gethostbyname(host))) {
+			return NULL;
+		}
+		memset(&sin, 0, sizeof(struct sockaddr_in));
+		memcpy(&sin.sin_addr.s_addr, hp->h_addr, hp->h_length);
+		sin.sin_family = hp->h_addrtype;
+	} else
+		sin.sin_family = AF_INET;
+	sin.sin_port = htons(port);
+
+	return &sin;
+}
+
+static void gaim_io_destroy(gpointer data)
+{
+	g_free(data);
+}
+
+#ifdef PROXYPROFILER
+struct proxyprofiler
+{
+	GaimInputFunction function;
+	gpointer data;
+	
+	int count;
+	
+	struct proxyprofiler *next;
+} *pp = NULL;
+
+void proxyprofiler_dump()
+{
+	struct proxyprofiler *l;
+	char s[128];
+	FILE *fp;
+	
+	sprintf( s, "proxyprofiler.%d", (int) getpid() );
+	fp = fopen( s, "w" );
+	
+	fprintf( fp, "%-18s  %-18s  %10s\n", "Function", "Data", "Count" );
+	for( l = pp; l; l = l->next )
+		fprintf( fp, "0x%-16x  0x%-16x  %10d\n", (int) l->function, (int) l->data, l->count );
+	
+	fclose( fp );
+}
+#endif
+
+static gboolean gaim_io_invoke(GIOChannel *source, GIOCondition condition, gpointer data)
+{
+	GaimIOClosure *closure = data;
+	GaimInputCondition gaim_cond = 0;
+
+#ifdef PROXYPROFILER
+	struct proxyprofiler *l;
+	
+	for( l = pp; l; l = l->next )
+	{
+		if( closure->function == l->function && closure->data == l->data )
+			break;
+	}
+	if( l )
+	{
+		l->count ++;
+	}
+	else
+	{
+		l = g_new0( struct proxyprofiler, 1 );
+		l->function = closure->function;
+		l->data = closure->data;
+		l->count = 1;
+		
+		l->next = pp;
+		pp = l;
+	}
+#endif
+	
+	count_io_event(source, "proxy");
+	
+	if (condition & GAIM_READ_COND)
+		gaim_cond |= GAIM_INPUT_READ;
+	if (condition & GAIM_WRITE_COND)
+		gaim_cond |= GAIM_INPUT_WRITE;
+//	if (condition & GAIM_ERR_COND)
+//		fprintf( stderr, "ERROR! fd=%d\n", g_io_channel_unix_get_fd( source ) );
+
+	closure->function(closure->data, g_io_channel_unix_get_fd(source), gaim_cond);
+
+	return TRUE;
+}
+
+static void no_one_calls(gpointer data, gint source, GaimInputCondition cond)
+{
+	struct PHB *phb = data;
+	unsigned int len;
+	int error = ETIMEDOUT;
+	len = sizeof(error);
+	
+#ifndef _WIN32
+	if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
+		closesocket(source);
+		gaim_input_remove(phb->inpa);
+		if( phb->proxy_func )
+			phb->proxy_func(phb->proxy_data, -1, GAIM_INPUT_READ);
+		else {
+			phb->func(phb->data, -1, GAIM_INPUT_READ);
+			g_free(phb);
+		}
+		return;
+	}
+	fcntl(source, F_SETFL, 0);
+#endif
+	gaim_input_remove(phb->inpa);
+	if( phb->proxy_func )
+		phb->proxy_func(phb->proxy_data, source, GAIM_INPUT_READ);
+	else {
+		phb->func(phb->data, source, GAIM_INPUT_READ);
+		g_free(phb);
+	}
+}
+
+static int proxy_connect_none(char *host, unsigned short port, struct PHB *phb)
+{
+	struct sockaddr_in *sin;
+	int fd = -1;
+
+	if (!(sin = gaim_gethostbyname(host, port))) {
+		g_free(phb);
+		return -1;
+	}
+
+	if ((fd = socket(sin->sin_family, SOCK_STREAM, 0)) < 0) {
+		g_free(phb);
+		return -1;
+	}
+
+	sock_make_nonblocking(fd);
+
+	if (connect(fd, (struct sockaddr *)sin, sizeof(*sin)) < 0) {
+		if (sockerr_again()) {
+			phb->inpa = gaim_input_add(fd, GAIM_INPUT_WRITE, no_one_calls, phb);
+			phb->fd = fd;
+		} else {
+			closesocket(fd);
+			g_free(phb);
+			return -1;
+		}
+	}
+
+	return fd;
+}
+
+
+/* Connecting to HTTP proxies */
+
+#define HTTP_GOODSTRING "HTTP/1.0 200 Connection established"
+#define HTTP_GOODSTRING2 "HTTP/1.1 200 Connection established"
+
+static void http_canread(gpointer data, gint source, GaimInputCondition cond)
+{
+	int nlc = 0;
+	int pos = 0;
+	struct PHB *phb = data;
+	char inputline[8192];
+
+	gaim_input_remove(phb->inpa);
+
+	while ((pos < sizeof(inputline)-1) && (nlc != 2) && (read(source, &inputline[pos++], 1) == 1)) {
+		if (inputline[pos - 1] == '\n')
+			nlc++;
+		else if (inputline[pos - 1] != '\r')
+			nlc = 0;
+	}
+	inputline[pos] = '\0';
+
+	if ((memcmp(HTTP_GOODSTRING, inputline, strlen(HTTP_GOODSTRING)) == 0) ||
+	    (memcmp(HTTP_GOODSTRING2, inputline, strlen(HTTP_GOODSTRING2)) == 0)) {
+		phb->func(phb->data, source, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	close(source);
+	phb->func(phb->data, -1, GAIM_INPUT_READ);
+	g_free(phb->host);
+	g_free(phb);
+	return;
+}
+
+static void http_canwrite(gpointer data, gint source, GaimInputCondition cond)
+{
+	char cmd[384];
+	struct PHB *phb = data;
+	unsigned int len;
+	int error = ETIMEDOUT;
+	if (phb->inpa > 0)
+		gaim_input_remove(phb->inpa);
+	len = sizeof(error);
+	if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+#ifdef F_SETFL
+	fcntl(source, F_SETFL, 0);
+#endif
+
+	g_snprintf(cmd, sizeof(cmd), "CONNECT %s:%d HTTP/1.1\r\nHost: %s:%d\r\n", phb->host, phb->port,
+		   phb->host, phb->port);
+	if (send(source, cmd, strlen(cmd), 0) < 0) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	if (proxyuser && *proxyuser) {
+		char *t1, *t2;
+		t1 = g_strdup_printf("%s:%s", proxyuser, proxypass);
+		t2 = tobase64(t1);
+		g_free(t1);
+		g_snprintf(cmd, sizeof(cmd), "Proxy-Authorization: Basic %s\r\n", t2);
+		g_free(t2);
+		if (send(source, cmd, strlen(cmd), 0) < 0) {
+			close(source);
+			phb->func(phb->data, -1, GAIM_INPUT_READ);
+			g_free(phb->host);
+			g_free(phb);
+			return;
+		}
+	}
+
+	g_snprintf(cmd, sizeof(cmd), "\r\n");
+	if (send(source, cmd, strlen(cmd), 0) < 0) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, http_canread, phb);
+}
+
+static int proxy_connect_http(char *host, unsigned short port, struct PHB *phb)
+{
+	phb->host = g_strdup(host);
+	phb->port = port;
+	phb->proxy_func = http_canwrite;
+	phb->proxy_data = phb;
+	
+	return( proxy_connect_none( proxyhost, proxyport, phb ) );
+}
+
+
+/* Connecting to SOCKS4 proxies */
+
+static void s4_canread(gpointer data, gint source, GaimInputCondition cond)
+{
+	unsigned char packet[12];
+	struct PHB *phb = data;
+
+	gaim_input_remove(phb->inpa);
+
+	memset(packet, 0, sizeof(packet));
+	if (read(source, packet, 9) >= 4 && packet[1] == 90) {
+		phb->func(phb->data, source, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	close(source);
+	phb->func(phb->data, -1, GAIM_INPUT_READ);
+	g_free(phb->host);
+	g_free(phb);
+}
+
+static void s4_canwrite(gpointer data, gint source, GaimInputCondition cond)
+{
+	unsigned char packet[12];
+	struct hostent *hp;
+	struct PHB *phb = data;
+	unsigned int len;
+	int error = ETIMEDOUT;
+	if (phb->inpa > 0)
+		gaim_input_remove(phb->inpa);
+	len = sizeof(error);
+	if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+#ifdef F_SETFL
+	fcntl(source, F_SETFL, 0);
+#endif
+
+	/* XXX does socks4 not support host name lookups by the proxy? */
+	if (!(hp = gethostbyname(phb->host))) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	packet[0] = 4;
+	packet[1] = 1;
+	packet[2] = phb->port >> 8;
+	packet[3] = phb->port & 0xff;
+	packet[4] = (unsigned char)(hp->h_addr_list[0])[0];
+	packet[5] = (unsigned char)(hp->h_addr_list[0])[1];
+	packet[6] = (unsigned char)(hp->h_addr_list[0])[2];
+	packet[7] = (unsigned char)(hp->h_addr_list[0])[3];
+	packet[8] = 0;
+	if (write(source, packet, 9) != 9) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, s4_canread, phb);
+}
+
+static int proxy_connect_socks4(char *host, unsigned short port, struct PHB *phb)
+{
+	phb->host = g_strdup(host);
+	phb->port = port;
+	phb->proxy_func = s4_canwrite;
+	phb->proxy_data = phb;
+	
+	return( proxy_connect_none( proxyhost, proxyport, phb ) );
+}
+
+
+/* Connecting to SOCKS5 proxies */
+
+static void s5_canread_again(gpointer data, gint source, GaimInputCondition cond)
+{
+	unsigned char buf[512];
+	struct PHB *phb = data;
+
+	gaim_input_remove(phb->inpa);
+
+	if (read(source, buf, 10) < 10) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+	if ((buf[0] != 0x05) || (buf[1] != 0x00)) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	phb->func(phb->data, source, GAIM_INPUT_READ);
+	g_free(phb->host);
+	g_free(phb);
+	return;
+}
+
+static void s5_sendconnect(gpointer data, gint source)
+{
+	unsigned char buf[512];
+	struct PHB *phb = data;
+	int hlen = strlen(phb->host);
+
+	buf[0] = 0x05;
+	buf[1] = 0x01;		/* CONNECT */
+	buf[2] = 0x00;		/* reserved */
+	buf[3] = 0x03;		/* address type -- host name */
+	buf[4] = hlen;
+	memcpy(buf + 5, phb->host, hlen);
+	buf[5 + strlen(phb->host)] = phb->port >> 8;
+	buf[5 + strlen(phb->host) + 1] = phb->port & 0xff;
+
+	if (write(source, buf, (5 + strlen(phb->host) + 2)) < (5 + strlen(phb->host) + 2)) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, s5_canread_again, phb);
+}
+
+static void s5_readauth(gpointer data, gint source, GaimInputCondition cond)
+{
+	unsigned char buf[512];
+	struct PHB *phb = data;
+
+	gaim_input_remove(phb->inpa);
+
+	if (read(source, buf, 2) < 2) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	if ((buf[0] != 0x01) || (buf[1] != 0x00)) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	s5_sendconnect(phb, source);
+}
+
+static void s5_canread(gpointer data, gint source, GaimInputCondition cond)
+{
+	unsigned char buf[512];
+	struct PHB *phb = data;
+
+	gaim_input_remove(phb->inpa);
+
+	if (read(source, buf, 2) < 2) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	if ((buf[0] != 0x05) || (buf[1] == 0xff)) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	if (buf[1] == 0x02) {
+		unsigned int i = strlen(proxyuser), j = strlen(proxypass);
+		buf[0] = 0x01;	/* version 1 */
+		buf[1] = i;
+		memcpy(buf + 2, proxyuser, i);
+		buf[2 + i] = j;
+		memcpy(buf + 2 + i + 1, proxypass, j);
+		if (write(source, buf, 3 + i + j) < 3 + i + j) {
+			close(source);
+			phb->func(phb->data, -1, GAIM_INPUT_READ);
+			g_free(phb->host);
+			g_free(phb);
+			return;
+		}
+
+		phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, s5_readauth, phb);
+	} else {
+		s5_sendconnect(phb, source);
+	}
+}
+
+static void s5_canwrite(gpointer data, gint source, GaimInputCondition cond)
+{
+	unsigned char buf[512];
+	int i;
+	struct PHB *phb = data;
+	unsigned int len;
+	int error = ETIMEDOUT;
+	if (phb->inpa > 0)
+		gaim_input_remove(phb->inpa);
+	len = sizeof(error);
+	if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+#ifdef F_SETFL
+	fcntl(source, F_SETFL, 0);
+#endif
+
+	i = 0;
+	buf[0] = 0x05;		/* SOCKS version 5 */
+	if (proxyuser[0]) {
+		buf[1] = 0x02;	/* two methods */
+		buf[2] = 0x00;	/* no authentication */
+		buf[3] = 0x02;	/* username/password authentication */
+		i = 4;
+	} else {
+		buf[1] = 0x01;
+		buf[2] = 0x00;
+		i = 3;
+	}
+
+	if (write(source, buf, i) < i) {
+		close(source);
+		phb->func(phb->data, -1, GAIM_INPUT_READ);
+		g_free(phb->host);
+		g_free(phb);
+		return;
+	}
+
+	phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, s5_canread, phb);
+}
+
+static int proxy_connect_socks5(char *host, unsigned short port, struct PHB *phb)
+{
+	phb->host = g_strdup(host);
+	phb->port = port;
+	phb->proxy_func = s5_canwrite;
+	phb->proxy_data = phb;
+	
+	return( proxy_connect_none( proxyhost, proxyport, phb ) );
+}
+
+
+/* Export functions */
+
+gint gaim_input_add(gint source, GaimInputCondition condition, GaimInputFunction function, gpointer data)
+{
+	GaimIOClosure *closure = g_new0(GaimIOClosure, 1);
+	GIOChannel *channel;
+	GIOCondition cond = 0;
+	
+	closure->function = function;
+	closure->data = data;
+	
+	if (condition & GAIM_INPUT_READ)
+		cond |= GAIM_READ_COND;
+	if (condition & GAIM_INPUT_WRITE)
+		cond |= GAIM_WRITE_COND;
+	
+	channel = g_io_channel_unix_new(source);
+	closure->result = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, cond,
+					      gaim_io_invoke, closure, gaim_io_destroy);
+	
+	g_io_channel_unref(channel);
+	return closure->result;
+}
+
+void gaim_input_remove(gint tag)
+{
+	if (tag > 0)
+		g_source_remove(tag);
+}
+
+int proxy_connect(char *host, int port, GaimInputFunction func, gpointer data)
+{
+	struct PHB *phb;
+	
+	if (!host || !port || (port == -1) || !func || strlen(host) > 128) {
+		return -1;
+	}
+	
+	phb = g_new0(struct PHB, 1);
+	phb->func = func;
+	phb->data = data;
+	
+#ifndef _WIN32
+	sethostent(1);
+#endif
+	
+	if ((proxytype == PROXY_NONE) || !proxyhost || !proxyhost[0] || !proxyport || (proxyport == -1))
+		return proxy_connect_none(host, port, phb);
+	else if (proxytype == PROXY_HTTP)
+		return proxy_connect_http(host, port, phb);
+	else if (proxytype == PROXY_SOCKS4)
+		return proxy_connect_socks4(host, port, phb);
+	else if (proxytype == PROXY_SOCKS5)
+		return proxy_connect_socks5(host, port, phb);
+	
+	if (phb->host) g_free(phb);
+	g_free(phb);
+	return -1;
+}