* 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 * 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 #if defined (__SVR4) && defined (__sun) #define MSGTYPE_BINDINGREQUEST 0x0001 #define MSGTYPE_BINDINGRESPONSE 0x0101 #define ATTRIB_MAPPEDADDRESS 0x0001 #ifndef _SIZEOF_ADDR_IFREQ # define _SIZEOF_ADDR_IFREQ(a) sizeof(a) struct stun_header *packet; static PurpleStunNatDiscovery nattype = { PURPLE_STUN_STATUS_UNDISCOVERED, PURPLE_STUN_NAT_TYPE_PUBLIC_IP, static GSList *callbacks = NULL; static void close_stun_conn(struct stun_conn *sc) { purple_input_remove(sc->incb); g_source_remove(sc->timeout); static void do_callbacks(void) { PurpleStunCallback cb = callbacks->data; callbacks = g_slist_delete_link(callbacks, callbacks); static gboolean timeoutfunc(gpointer data) { struct stun_conn *sc = data; purple_debug_warning("stun", "request timed out, giving up.\n"); nattype.type = PURPLE_STUN_NAT_TYPE_SYMMETRIC; nattype.status = PURPLE_STUN_STATUS_UNKNOWN; nattype.lookup_time = g_get_monotonic_time(); /* we don't need to remove the timeout (returning FALSE) */ purple_debug_info("stun", "request timed out, retrying.\n"); if (sendto(sc->fd, sc->packet, sc->packetsize, 0, (struct sockaddr *)&(sc->addr), sizeof(struct sockaddr_in)) != purple_debug_warning("stun", "sendto failed\n"); static void reply_cb(gpointer data, gint source, PurpleInputCondition cond) { struct stun_conn *sc = data; struct ifreq buffer_ifr[1000]; struct stun_attrib attrib; struct sockaddr_in *sinptr; memset(&in, 0, sizeof(in)); len = recv(source, buffer, sizeof(buffer) - 1, 0); purple_debug_warning("stun", "unable to read stun response\n"); if ((gsize)len < sizeof(struct stun_header)) { purple_debug_warning("stun", "got invalid response\n"); memcpy(&hdr, buffer, sizeof(hdr)); if ((gsize)len != (ntohs(hdr.len) + sizeof(struct stun_header))) { purple_debug_warning("stun", "got incomplete response\n"); 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"); if (hdr.type != MSGTYPE_BINDINGRESPONSE) { purple_debug_warning("stun", "Expected Binding Response, got %d\n", 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 + ntohs(attrib.len)))) if(attrib.type == htons(ATTRIB_MAPPEDADDRESS) && ntohs(attrib.len) == 8) { /* 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, it + 4, 4); g_strlcpy(nattype.publicip, ip, sizeof(nattype.publicip)); purple_debug_info("stun", "got public ip %s\n", nattype.publicip); nattype.status = PURPLE_STUN_STATUS_DISCOVERED; nattype.type = PURPLE_STUN_NAT_TYPE_UNKNOWN_NAT; nattype.lookup_time = g_get_monotonic_time(); ifc.ifc_len = sizeof(buffer_ifr); ifc.ifc_req = buffer_ifr; ioctl(source, SIOCGIFCONF, &ifc); it = (guchar *)buffer_ifr; it_end = it + ifc.ifc_len; ifr = (struct ifreq*)(gpointer)it; it += _SIZEOF_ADDR_IFREQ(*ifr); if(ifr->ifr_addr.sa_family == AF_INET) { /* we only care about ipv4 interfaces */ sinptr = (struct sockaddr_in *)(gpointer)&ifr->ifr_addr; if(sinptr->sin_addr.s_addr == in.s_addr) { purple_debug_info("stun", "no nat\n"); nattype.type = PURPLE_STUN_NAT_TYPE_PUBLIC_IP; g_source_remove(sc->timeout); } else if(sc->test == 2) { nattype.type = PURPLE_STUN_NAT_TYPE_FULL_CONE; hbn_listen_cb(int fd, gpointer data) { StunHBNListenData *ld = (StunHBNListenData *)data; GInetAddress *address = NULL; GSocketAddress *socket_address = NULL; static struct stun_header hdr_data; nattype.status = PURPLE_STUN_STATUS_UNKNOWN; nattype.lookup_time = g_get_monotonic_time(); g_resolver_free_addresses(ld->addresses); sc = g_new0(struct stun_conn, 1); sc->addr.sin_family = AF_INET; sc->addr.sin_port = htons(purple_network_get_port_from_fd(fd)); sc->addr.sin_addr.s_addr = INADDR_ANY; sc->incb = purple_input_add(fd, PURPLE_INPUT_READ, reply_cb, sc); address = g_object_ref(G_INET_ADDRESS(ld->addresses->data)); socket_address = g_inet_socket_address_new(address, ld->port); g_socket_address_to_native(socket_address, &(sc->addr), g_socket_address_get_native_size(socket_address), NULL); g_object_unref(G_OBJECT(address)); g_object_unref(G_OBJECT(socket_address)); g_resolver_free_addresses(ld->addresses); hdr_data.type = htons(MSGTYPE_BINDINGREQUEST); hdr_data.transid[0] = g_random_int(); hdr_data.transid[1] = 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(); if(sendto(sc->fd, &hdr_data, sizeof(struct stun_header), 0, (struct sockaddr *)&(sc->addr), sizeof(struct sockaddr_in)) < (gssize)sizeof(struct stun_header)) { nattype.status = PURPLE_STUN_STATUS_UNKNOWN; nattype.lookup_time = g_get_monotonic_time(); sc->packetsize = sizeof(struct stun_header); sc->timeout = g_timeout_add(500, (GSourceFunc) timeoutfunc, sc); hbn_cb(GObject *sender, GAsyncResult *res, gpointer data) { StunHBNListenData *ld = NULL; ld = g_new0(StunHBNListenData, 1); ld->addresses = g_resolver_lookup_by_name_finish(G_RESOLVER(sender), nattype.status = PURPLE_STUN_STATUS_UNDISCOVERED; nattype.lookup_time = g_get_monotonic_time(); ld->port = GPOINTER_TO_INT(data); if (!purple_network_listen_range(12108, 12208, AF_UNSPEC, SOCK_DGRAM, TRUE, hbn_listen_cb, ld)) { nattype.status = PURPLE_STUN_STATUS_UNKNOWN; nattype.lookup_time = g_get_monotonic_time(); g_resolver_free_addresses(ld->addresses); do_test1(GObject *sender, GAsyncResult *res, gpointer data) { const char *servername = data; services = g_resolver_lookup_service_finish(G_RESOLVER(sender), purple_debug_info("stun", "Failed to look up srv record : %s\n", error->message); 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, g_object_unref(resolver); g_resolver_free_targets(services); static gboolean call_callback(gpointer data) { PurpleStunCallback cb = data; PurpleStunNatDiscovery *purple_stun_discover(PurpleStunCallback cb) { const char *servername = purple_prefs_get_string("/purple/network/stun_server"); purple_debug_info("stun", "using server %s\n", servername); if(nattype.status == PURPLE_STUN_STATUS_DISCOVERING) { callbacks = g_slist_append(callbacks, cb); if(nattype.status != PURPLE_STUN_STATUS_UNDISCOVERED) { gboolean use_cached_result = TRUE; /* Deal with the server name having changed since we did the 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) > use_cached_result = FALSE; g_timeout_add(10, call_callback, cb); if(!servername || (strlen(servername) < 2)) { nattype.status = PURPLE_STUN_STATUS_UNKNOWN; nattype.lookup_time = g_get_monotonic_time(); g_timeout_add(10, call_callback, cb); 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, g_object_unref(resolver); void purple_stun_init() { purple_prefs_add_string("/purple/network/stun_server", "");