diff libpurple/stun.c @ 15373:5fe8042783c1

Rename gtk/ and libgaim/ to pidgin/ and libpurple/

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/stun.c	Sat Jan 20 02:32:10 2007 +0000
@@ -0,0 +1,433 @@
+/**
+ * @file stun.c STUN (RFC3489) Implementation
+ * @ingroup core
+ *
+ * gaim
+ *
+ * STUN implementation inspired by jstun [http://jstun.javawi.de/]
+ *
+ * Gaim is the legal property of its developers, whose names are too numerous
+ * to list here.  Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * 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
+ *
+ */
+
+#include "internal.h"
+
+#ifndef _WIN32
+#include <net/if.h>
+#include <sys/ioctl.h>
+#endif
+
+/* Solaris */
+#if defined (__SVR4) && defined (__sun)
+#include <sys/sockio.h>
+#endif
+
+#include "debug.h"
+#include "account.h"
+#include "dnsquery.h"
+#include "dnssrv.h"
+#include "network.h"
+#include "proxy.h"
+#include "stun.h"
+#include "prefs.h"
+
+#define MSGTYPE_BINDINGREQUEST 0x0001
+#define MSGTYPE_BINDINGRESPONSE 0x0101
+
+#define ATTRIB_MAPPEDADDRESS 0x0001
+
+struct stun_header {
+	guint16 type;
+	guint16 len;
+	guint32 transid[4];
+};
+
+struct stun_attrib {
+	guint16 type;
+	guint16 len;
+};
+
+#ifdef NOTYET
+struct stun_change {
+	struct stun_header hdr;
+	struct stun_attrib attrib;
+	char value[4];
+};
+#endif
+
+struct stun_conn {
+	int fd;
+	struct sockaddr_in addr;
+	int test;
+	int retry;
+	guint incb;
+	guint timeout;
+	struct stun_header *packet;
+	size_t packetsize;
+};
+
+static GaimStunNatDiscovery nattype = {
+	GAIM_STUN_STATUS_UNDISCOVERED,
+	GAIM_STUN_NAT_TYPE_PUBLIC_IP,
+	"\0", NULL, 0};
+
+static GSList *callbacks = NULL;
+
+static void close_stun_conn(struct stun_conn *sc) {
+
+	if (sc->incb)
+		gaim_input_remove(sc->incb);
+
+	if (sc->timeout)
+		gaim_timeout_remove(sc->timeout);
+
+	if (sc->fd)
+		close(sc->fd);
+
+	g_free(sc);
+}
+
+static void do_callbacks() {
+	while(callbacks) {
+		StunCallback cb = callbacks->data;
+		if(cb)
+			cb(&nattype);
+		callbacks = g_slist_remove(callbacks, cb);
+	}
+}
+
+static gboolean timeoutfunc(gpointer data) {
+	struct stun_conn *sc = data;
+	if(sc->retry >= 2) {
+		gaim_debug_info("stun", "request timed out, giving up.\n");
+		if(sc->test == 2)
+			nattype.type = GAIM_STUN_NAT_TYPE_SYMMETRIC;
+
+		/* set unknown */
+		nattype.status = GAIM_STUN_STATUS_UNKNOWN;
+
+		nattype.lookup_time = time(NULL);
+
+		/* callbacks */
+		do_callbacks();
+
+		/* we don't need to remove the timeout (returning FALSE) */
+		sc->timeout = 0;
+		close_stun_conn(sc);
+
+		return FALSE;
+	}
+	gaim_debug_info("stun", "request timed out, retrying.\n");
+	sc->retry++;
+	sendto(sc->fd, sc->packet, sc->packetsize, 0,
+		(struct sockaddr *)&(sc->addr), sizeof(struct sockaddr_in));
+	return TRUE;
+}
+
+#ifdef NOTYET
+static void do_test2(struct stun_conn *sc) {
+	struct stun_change data;
+	data.hdr.type = htons(0x0001);
+	data.hdr.len = 0;
+	data.hdr.transid[0] = rand();
+	data.hdr.transid[1] = ntohl(((int)'g' << 24) + ((int)'a' << 16) + ((int)'i' << 8) + (int)'m');
+	data.hdr.transid[2] = rand();
+	data.hdr.transid[3] = rand();
+	data.attrib.type = htons(0x003);
+	data.attrib.len = htons(4);
+	data.value[3] = 6;
+	sc->packet = (struct stun_header*)&data;
+	sc->packetsize = sizeof(struct stun_change);
+	sc->retry = 0;
+	sc->test = 2;
+	sendto(sc->fd, sc->packet, sc->packetsize, 0, (struct sockaddr *)&(sc->addr), sizeof(struct sockaddr_in));
+	sc->timeout = gaim_timeout_add(500, (GSourceFunc) timeoutfunc, sc);
+}
+#endif
+
+static void reply_cb(gpointer data, gint source, GaimInputCondition cond) {
+	struct stun_conn *sc = data;
+	char buffer[65536];
+	char *tmp;
+	int len;
+	struct in_addr in;
+	struct stun_attrib *attrib;
+	struct stun_header *hdr;
+	struct ifconf ifc;
+	struct ifreq *ifr;
+	struct sockaddr_in *sinptr;
+
+	len = recv(source, buffer, sizeof(buffer) - 1, 0);
+	if (!len) {
+		gaim_debug_info("stun", "unable to read stun response\n");
+		return;
+	}
+	buffer[len] = '\0';
+
+	if (len < sizeof(struct stun_header)) {
+		gaim_debug_info("stun", "got invalid response\n");
+		return;
+	}
+
+	hdr = (struct stun_header*) buffer;
+	if (len != (ntohs(hdr->len) + sizeof(struct stun_header))) {
+		gaim_debug_info("stun", "got incomplete response\n");
+		return;
+	}
+
+	/* wrong transaction */
+	if(hdr->transid[0] != sc->packet->transid[0]
+			|| hdr->transid[1] != sc->packet->transid[1]
+			|| hdr->transid[2] != sc->packet->transid[2]
+			|| hdr->transid[3] != sc->packet->transid[3]) {
+		gaim_debug_info("stun", "got wrong transid\n");
+		return;
+	}
+
+	if(sc->test==1) {
+		if (hdr->type != MSGTYPE_BINDINGRESPONSE) {
+			gaim_debug_info("stun",
+				"Expected Binding Response, got %d\n",
+				hdr->type);
+			return;
+		}
+
+		tmp = buffer + sizeof(struct stun_header);
+		while((buffer + len) > (tmp + sizeof(struct stun_attrib))) {
+			attrib = (struct stun_attrib*) tmp;
+			tmp += sizeof(struct stun_attrib);
+
+			if (!((buffer + len) > (tmp + ntohs(attrib->len))))
+				break;
+
+			if(attrib->type == htons(ATTRIB_MAPPEDADDRESS)
+					&& ntohs(attrib->len) == 8) {
+				char *ip;
+				/* Skip the first unused byte,
+				 * the family(1 byte), and the port(2 bytes);
+				 * then read the 4 byte IPv4 address */
+				memcpy(&in.s_addr, tmp + 4, 4);
+				ip = inet_ntoa(in);
+				if(ip)
+					strcpy(nattype.publicip, ip);
+			}
+
+			tmp += ntohs(attrib->len);
+		}
+		gaim_debug_info("stun", "got public ip %s\n", nattype.publicip);
+		nattype.status = GAIM_STUN_STATUS_DISCOVERED;
+		nattype.type = GAIM_STUN_NAT_TYPE_UNKNOWN_NAT;
+		nattype.lookup_time = time(NULL);
+
+		/* is it a NAT? */
+
+		ifc.ifc_len = sizeof(buffer);
+		ifc.ifc_req = (struct ifreq *) buffer;
+		ioctl(source, SIOCGIFCONF, &ifc);
+
+		tmp = buffer;
+		while(tmp < buffer + ifc.ifc_len) {
+			ifr = (struct ifreq *) tmp;
+
+			tmp += sizeof(struct ifreq);
+
+			if(ifr->ifr_addr.sa_family == AF_INET) {
+				/* we only care about ipv4 interfaces */
+				sinptr = (struct sockaddr_in *) &ifr->ifr_addr;
+				if(sinptr->sin_addr.s_addr == in.s_addr) {
+					/* no NAT */
+					gaim_debug_info("stun", "no nat");
+					nattype.type = GAIM_STUN_NAT_TYPE_PUBLIC_IP;
+				}
+			}
+		}
+
+#ifndef NOTYET
+		close_stun_conn(sc);
+		do_callbacks();
+#else
+		gaim_timeout_remove(sc->timeout);
+		sc->timeout = 0;
+
+		do_test2(sc);
+	} else if(sc->test == 2) {
+		close_stun_conn(sc);
+		nattype.type = GAIM_STUN_NAT_TYPE_FULL_CONE;
+		do_callbacks();
+#endif
+	}
+}
+
+
+static void hbn_listen_cb(int fd, gpointer data) {
+	GSList *hosts = data;
+	struct stun_conn *sc;
+	static struct stun_header hdr_data;
+	int ret;
+
+	if(fd < 0) {
+		nattype.status = GAIM_STUN_STATUS_UNKNOWN;
+		nattype.lookup_time = time(NULL);
+		do_callbacks();
+		return;
+	}
+
+	sc = g_new0(struct stun_conn, 1);
+	sc->fd = fd;
+
+	sc->addr.sin_family = AF_INET;
+	sc->addr.sin_port = htons(gaim_network_get_port_from_fd(fd));
+	sc->addr.sin_addr.s_addr = INADDR_ANY;
+
+	sc->incb = gaim_input_add(fd, GAIM_INPUT_READ, reply_cb, sc);
+
+	ret = GPOINTER_TO_INT(hosts->data);
+	hosts = g_slist_remove(hosts, hosts->data);
+	memcpy(&(sc->addr), hosts->data, sizeof(struct sockaddr_in));
+	g_free(hosts->data);
+	hosts = g_slist_remove(hosts, hosts->data);
+	while(hosts) {
+		hosts = g_slist_remove(hosts, hosts->data);
+		g_free(hosts->data);
+		hosts = g_slist_remove(hosts, hosts->data);
+	}
+
+	hdr_data.type = htons(MSGTYPE_BINDINGREQUEST);
+	hdr_data.len = 0;
+	hdr_data.transid[0] = rand();
+	hdr_data.transid[1] = ntohl(((int)'g' << 24) + ((int)'a' << 16) + ((int)'i' << 8) + (int)'m');
+	hdr_data.transid[2] = rand();
+	hdr_data.transid[3] = rand();
+
+	if(sendto(sc->fd, &hdr_data, sizeof(struct stun_header), 0,
+			(struct sockaddr *)&(sc->addr),
+			sizeof(struct sockaddr_in)) < sizeof(struct stun_header)) {
+		nattype.status = GAIM_STUN_STATUS_UNKNOWN;
+		nattype.lookup_time = time(NULL);
+		do_callbacks();
+		close_stun_conn(sc);
+		return;
+	}
+	sc->test = 1;
+	sc->packet = &hdr_data;
+	sc->packetsize = sizeof(struct stun_header);
+	sc->timeout = gaim_timeout_add(500, (GSourceFunc) timeoutfunc, sc);
+}
+
+static void hbn_cb(GSList *hosts, gpointer data, const char *error_message) {
+
+	if(!hosts || !hosts->data) {
+		nattype.status = GAIM_STUN_STATUS_UNDISCOVERED;
+		nattype.lookup_time = time(NULL);
+		do_callbacks();
+		return;
+	}
+
+	if (!gaim_network_listen_range(12108, 12208, SOCK_DGRAM, hbn_listen_cb, hosts)) {
+		nattype.status = GAIM_STUN_STATUS_UNKNOWN;
+		nattype.lookup_time = time(NULL);
+		do_callbacks();
+		return;
+	}
+
+
+}
+
+static void do_test1(GaimSrvResponse *resp, int results, gpointer sdata) {
+	const char *servername = sdata;
+	int port = 3478;
+
+	if(results) {
+		servername = resp[0].hostname;
+		port = resp[0].port;
+	}
+	gaim_debug_info("stun", "got %d SRV responses, server: %s, port: %d\n",
+		results, servername, port);
+
+	gaim_dnsquery_a(servername, port, hbn_cb, NULL);
+	g_free(resp);
+}
+
+static gboolean call_callback(gpointer data) {
+	StunCallback cb = data;
+	cb(&nattype);
+	return FALSE;
+}
+
+GaimStunNatDiscovery *gaim_stun_discover(StunCallback cb) {
+	const char *servername = gaim_prefs_get_string("/core/network/stun_server");
+
+	gaim_debug_info("stun", "using server %s\n", servername);
+
+	if(nattype.status == GAIM_STUN_STATUS_DISCOVERING) {
+		if(cb)
+			callbacks = g_slist_append(callbacks, cb);
+		return &nattype;
+	}
+
+	if(nattype.status != GAIM_STUN_STATUS_UNDISCOVERED) {
+		gboolean use_cached_result = TRUE;
+
+		/** Deal with the server name having changed since we did the
+		    lookup */
+		if (servername && strlen(servername) > 1
+				&& ((nattype.servername
+					&& strcmp(servername, nattype.servername))
+				|| !nattype.servername)) {
+			use_cached_result = FALSE;
+		}
+
+		/* If we don't have a successful status and it has been 5
+		   minutes since we last did a lookup, redo the lookup */
+		if (nattype.status != GAIM_STUN_STATUS_DISCOVERED
+				&& (time(NULL) - nattype.lookup_time) > 300) {
+			use_cached_result = FALSE;
+		}
+
+		if (use_cached_result) {
+			if(cb)
+				gaim_timeout_add(10, call_callback, cb);
+			return &nattype;
+		}
+	}
+
+	if(!servername || (strlen(servername) < 2)) {
+		nattype.status = GAIM_STUN_STATUS_UNKNOWN;
+		nattype.lookup_time = time(NULL);
+		if(cb)
+			gaim_timeout_add(10, call_callback, cb);
+		return &nattype;
+	}
+
+	nattype.status = GAIM_STUN_STATUS_DISCOVERING;
+	nattype.publicip[0] = '\0';
+	g_free(nattype.servername);
+	nattype.servername = g_strdup(servername);
+
+	callbacks = g_slist_append(callbacks, cb);
+	gaim_srv_resolve("stun", "udp", servername, do_test1,
+		(gpointer) servername);
+
+	return &nattype;
+}
+
+void gaim_stun_init() {
+	gaim_prefs_add_string("/core/network/stun_server", "");
+	gaim_stun_discover(NULL);
+}