HGKeeper

/* purple

* STUN implementation inspired by jstun [http://jstun.javawi.de/]

* Purple 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., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA

#include "internal.h"

#ifndef _WIN32

#include <net/if.h>

#endif

#include <gio/gio.h>

#include "glibcompat.h"

#include "debug.h"

#include "account.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;

};

struct stun_conn {

GSocket *sock;

GSocketAddress *addr;

int retry;

guint incb;

guint timeout;

struct stun_header *packet;

gsize packetsize;

};

static PurpleStunNatDiscovery nattype = {

PURPLE_STUN_STATUS_UNDISCOVERED,

"\0", NULL, 0};

static GSList *callbacks = NULL;

static void close_stun_conn(struct stun_conn *sc) {

g_clear_object(&sc->sock);

g_clear_object(&sc->addr);

if (sc->incb) {

g_source_remove(sc->incb);

}

if (sc->timeout) {

g_source_remove(sc->timeout);

}

g_clear_pointer(&sc->packet, g_free);

g_free(sc);

}

static void do_callbacks(void) {

while (callbacks) {

PurpleStunCallback cb = callbacks->data;

if (cb)

cb(&nattype);

callbacks = g_slist_delete_link(callbacks, callbacks);

}

static gboolean timeoutfunc(gpointer data) {

struct stun_conn *sc = data;

GError *error = NULL;

if(sc->retry >= 2) {

guint id;

purple_debug_warning("stun", "request timed out, giving up.\n");

/* set unknown */

nattype.status = PURPLE_STUN_STATUS_UNKNOWN;

nattype.lookup_time = g_get_monotonic_time();

/* callbacks */

do_callbacks();

/* we don't need to remove the timeout (returning FALSE), but

* we do need to remove the read callback, which will free the

* whole stun_conn. */

id = sc->incb;

sc->timeout = 0;

sc->incb = 0;

g_source_remove(id);

return FALSE;

}

purple_debug_info("stun", "request timed out, retrying.\n");

sc->retry++;

if (g_socket_send_to(sc->sock, sc->addr, (const gchar *)sc->packet,

sc->packetsize, NULL,

&error) != (gssize)sc->packetsize) {

purple_debug_warning("stun", "sendto failed: %s", error->message);

g_clear_error(&error);

return FALSE;

}

return TRUE;

}

static gboolean

reply_cb(GSocket *socket, GIOCondition condition, gpointer data)

{

struct stun_conn *sc = data;

gchar buffer[65536];

gchar *it;

gssize len;

struct stun_attrib attrib;

struct stun_header hdr;

GError *error = NULL;

len = g_socket_receive(socket, buffer, sizeof(buffer) - 1, NULL, &error);

if (len <= 0) {

purple_debug_warning("stun", "unable to read stun response: %s",

error->message);

g_clear_error(&error);

sc->incb = 0;

return FALSE;

}

buffer[len] = '\0';

if ((gsize)len < sizeof(struct stun_header)) {

purple_debug_warning("stun", "got invalid response\n");

sc->incb = 0;

return FALSE;

}

memcpy(&hdr, buffer, sizeof(hdr));

if ((gsize)len != (g_ntohs(hdr.len) + sizeof(struct stun_header))) {

purple_debug_warning("stun", "got incomplete response\n");

sc->incb = 0;

return FALSE;

}

/* 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]) {

purple_debug_warning("stun", "got wrong transid\n");

sc->incb = 0;

return FALSE;

}

if (hdr.type != MSGTYPE_BINDINGRESPONSE) {

purple_debug_warning("stun", "Expected Binding Response, got %d",

hdr.type);

sc->incb = 0;

return FALSE;

}

it = buffer + sizeof(struct stun_header);

while ((buffer + len) > (it + sizeof(struct stun_attrib))) {

memcpy(&attrib, it, sizeof(attrib));

it += sizeof(struct stun_attrib);

if (!((buffer + len) > (it + g_ntohs(attrib.len)))) {

break;

}

if (attrib.type == g_htons(ATTRIB_MAPPEDADDRESS) &&

g_ntohs(attrib.len) == 8) {

GInetAddress *inet_addr = NULL;

/* Skip the first unused byte,

* the family(1 byte), and the port(2 bytes);

* then read the 4 byte IPv4 address */

inet_addr = g_inet_address_new_from_bytes((const guint8 *)it + 4,

G_SOCKET_FAMILY_IPV4);

if (inet_addr) {

gchar *ip = g_inet_address_to_string(inet_addr);

g_strlcpy(nattype.publicip, ip, sizeof(nattype.publicip));

g_free(ip);

g_object_unref(inet_addr);

}

it += g_ntohs(attrib.len);

}

purple_debug_info("stun", "got public ip %s\n", nattype.publicip);

nattype.status = PURPLE_STUN_STATUS_DISCOVERED;

nattype.lookup_time = g_get_monotonic_time();

do_callbacks();

/* sc will be freed by the GSource destruction. */

sc->incb = 0;

return FALSE;

}

static void

hbn_cb(GObject *sender, GAsyncResult *res, gpointer data)

{

struct stun_conn *sc = NULL;

GList *addresses = NULL;

GSocketAddress *local_addr = NULL;

GInetAddress *remote_addr = NULL;

struct stun_header *hdr_data = NULL;

GSource *read_source = NULL;

GError *error = NULL;

addresses =

g_resolver_lookup_by_name_finish(G_RESOLVER(sender), res, &error);

if (error != NULL) {

nattype.status = PURPLE_STUN_STATUS_UNDISCOVERED;

nattype.lookup_time = g_get_monotonic_time();

do_callbacks();

g_clear_error(&error);

return;

}

sc = g_new0(struct stun_conn, 1);

sc->sock = g_socket_new(G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM,

G_SOCKET_PROTOCOL_DEFAULT, &error);

if (sc->sock == NULL) {

purple_debug_error(

"stun", "Unable to create socket to connect to STUN server: %s",

error->message);

nattype.status = PURPLE_STUN_STATUS_UNKNOWN;

nattype.lookup_time = g_get_monotonic_time();

do_callbacks();

close_stun_conn(sc);

g_resolver_free_addresses(addresses);

g_clear_error(&error);

return;

}

local_addr = g_inet_socket_address_new_from_string("0.0.0.0", 0);

remote_addr = G_INET_ADDRESS(addresses->data);

sc->addr = g_inet_socket_address_new(remote_addr, GPOINTER_TO_INT(data));

g_resolver_free_addresses(addresses);

g_socket_set_blocking(sc->sock, FALSE);

if (!g_socket_bind(sc->sock, local_addr, TRUE, &error)) {

purple_debug_error(

"stun", "Unable to bind socket to connect to STUN server: %s",

error->message);

nattype.status = PURPLE_STUN_STATUS_UNKNOWN;

nattype.lookup_time = g_get_monotonic_time();

do_callbacks();

g_object_unref(local_addr);

close_stun_conn(sc);

g_clear_error(&error);

return;

}

g_object_unref(local_addr);

read_source = g_socket_create_source(sc->sock, G_IO_IN, NULL);

g_source_set_callback(read_source, G_SOURCE_FUNC(reply_cb), sc,

(GDestroyNotify)close_stun_conn);

sc->incb = g_source_attach(read_source, NULL);

g_source_unref(read_source);

hdr_data = g_new0(struct stun_header, 1);

hdr_data->type = g_htons(MSGTYPE_BINDINGREQUEST);

hdr_data->len = 0;

hdr_data->transid[0] = g_random_int();

hdr_data->transid[1] = g_ntohl(((int)'g' << 24) + ((int)'a' << 16) +

((int)'i' << 8) + (int)'m');

hdr_data->transid[2] = g_random_int();

hdr_data->transid[3] = g_random_int();

sc->packet = hdr_data;

sc->packetsize = sizeof(struct stun_header);

if (g_socket_send_to(sc->sock, sc->addr, (const gchar *)sc->packet,

sc->packetsize, NULL,

&error) < (gssize)sc->packetsize) {

purple_debug_warning("stun", "sendto failed: %s", error->message);

nattype.status = PURPLE_STUN_STATUS_UNKNOWN;

nattype.lookup_time = g_get_monotonic_time();

do_callbacks();

close_stun_conn(sc);

return;

}

sc->timeout = g_timeout_add(500, (GSourceFunc)timeoutfunc, sc);

}

static void

do_test1(GObject *sender, GAsyncResult *res, gpointer data) {

GList *services = NULL;

GError *error = NULL;

GResolver *resolver;

const char *servername = data;

int port = 3478;

services = g_resolver_lookup_service_finish(G_RESOLVER(sender),

res, &error);

if(error != NULL) {

purple_debug_info("stun", "Failed to look up srv record : %s\n", error->message);

g_error_free(error);

} else {

servername = g_srv_target_get_hostname((GSrvTarget *)services->data);

port = g_srv_target_get_port((GSrvTarget *)services->data);

}

purple_debug_info("stun", "connecting to %s:%d\n", servername, port);

resolver = g_resolver_get_default();

g_resolver_lookup_by_name_async(resolver,

servername,

NULL,

hbn_cb,

GINT_TO_POINTER(port));

g_object_unref(resolver);

g_resolver_free_targets(services);

}

static gboolean call_callback(gpointer data) {

PurpleStunCallback cb = data;

cb(&nattype);

return FALSE;

}

PurpleStunNatDiscovery *purple_stun_discover(PurpleStunCallback cb) {

const char *servername = purple_prefs_get_string("/purple/network/stun_server");

GResolver *resolver;

purple_debug_info("stun", "using server %s\n", servername);

if(nattype.status == PURPLE_STUN_STATUS_DISCOVERING) {

if(cb)

callbacks = g_slist_append(callbacks, cb);

return &nattype;

}

if(nattype.status != PURPLE_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

&& !purple_strequal(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 != PURPLE_STUN_STATUS_DISCOVERED &&

(g_get_monotonic_time() - nattype.lookup_time) >

300 * G_USEC_PER_SEC) {

use_cached_result = FALSE;

}

if (use_cached_result) {

if(cb)

g_timeout_add(10, call_callback, cb);

return &nattype;

}

if(!servername || (strlen(servername) < 2)) {

nattype.status = PURPLE_STUN_STATUS_UNKNOWN;

nattype.lookup_time = g_get_monotonic_time();

if(cb)

g_timeout_add(10, call_callback, cb);

return &nattype;

}

nattype.status = PURPLE_STUN_STATUS_DISCOVERING;

nattype.publicip[0] = '\0';

g_free(nattype.servername);

nattype.servername = g_strdup(servername);

callbacks = g_slist_append(callbacks, cb);

resolver = g_resolver_get_default();

g_resolver_lookup_service_async(resolver,

"stun",

"udp",

servername,

NULL,

do_test1,

(gpointer)servername);

g_object_unref(resolver);

return &nattype;

}

void purple_stun_init() {

purple_prefs_add_string("/purple/network/stun_server", "");

}

pidgin/pidgin