* 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 #include <arpa/nameser.h> #if defined (__SVR4) && defined (__sun) * Calling sizeof(struct ifreq) isn't always correct on * Mac OS X (and maybe others). #ifdef _SIZEOF_ADDR_IFREQ # define HX_SIZE_OF_IFREQ(a) _SIZEOF_ADDR_IFREQ(a) # define HX_SIZE_OF_IFREQ(a) sizeof(a) struct _PurpleNetworkListenData { PurpleNetworkListenCallback cb; PurpleUPnPMappingAddRemove *mapping_data; static gboolean force_online = FALSE; /* Cached IP addresses for STUN and TURN servers (set globally in prefs) */ static gchar *stun_ip = NULL; static gchar *turn_ip = NULL; /* Keep track of port mappings done with UPnP and NAT-PMP */ static GHashTable *upnp_port_mappings = NULL; static GHashTable *nat_pmp_port_mappings = NULL; purple_network_set_public_ip(const char *ip) g_return_if_fail(ip != NULL); /* XXX - Ensure the IP address is valid */ purple_prefs_set_string("/purple/network/public_ip", ip); purple_network_get_public_ip(void) return purple_prefs_get_string("/purple/network/public_ip"); purple_network_get_local_system_ip(int fd) struct ifreq buffer[100]; struct sockaddr_in *sinptr; guint32 lhost = htonl((127 << 24) + 1); /* 127.0.0.1 */ source = socket(PF_INET,SOCK_STREAM, 0); ifc.ifc_len = sizeof(buffer); ioctl(source, SIOCGIFCONF, &ifc); if (fd < 0 && source >= 0) it_end = it + ifc.ifc_len; * a) (struct ifreq)-aligned * b) not aligned, because of OS quirks (see * _SIZEOF_ADDR_IFREQ), so the OS should deal with it. ifr = (struct ifreq *)(gpointer)it; it += HX_SIZE_OF_IFREQ(*ifr); if (ifr->ifr_addr.sa_family == AF_INET) sinptr = (struct sockaddr_in *)(gpointer)&ifr->ifr_addr; if (sinptr->sin_addr.s_addr != lhost) add = ntohl(sinptr->sin_addr.s_addr); g_snprintf(ip, 16, "%lu.%lu.%lu.%lu", purple_network_get_all_local_system_ips(void) #if defined(HAVE_GETIFADDRS) && defined(HAVE_INET_NTOP) struct ifaddrs *start, *ifa; ret = getifaddrs(&start); purple_debug_warning("network", "getifaddrs() failed: %s\n", g_strerror(errno)); for (ifa = start; ifa; ifa = ifa->ifa_next) { int family = ifa->ifa_addr ? ifa->ifa_addr->sa_family : AF_UNSPEC; char host[INET6_ADDRSTRLEN]; common_sockaddr_t *addr = (common_sockaddr_t *)(gpointer)ifa->ifa_addr; if ((family != AF_INET && family != AF_INET6) || ifa->ifa_flags & IFF_LOOPBACK) tmp = inet_ntop(family, &addr->in.sin_addr, host, sizeof(host)); /* Peer-peer link-local communication is a big TODO. I am not sure * how communicating link-local addresses is supposed to work, and * it seems like it would require attempting the cartesian product * of the local and remote interfaces to see if any match (eww). if (!IN6_IS_ADDR_LINKLOCAL(&addr->in6.sin6_addr)) tmp = inet_ntop(family, &addr->in6.sin6_addr, host, sizeof(host)); result = g_list_prepend(result, g_strdup(tmp)); return g_list_reverse(result); #else /* HAVE_GETIFADDRS && HAVE_INET_NTOP */ int source = socket(PF_INET,SOCK_STREAM, 0); struct ifreq buffer[100]; ifc.ifc_len = sizeof(buffer); ioctl(source, SIOCGIFCONF, &ifc); it_end = it + ifc.ifc_len; char dst[INET_ADDRSTRLEN]; /* alignment: see purple_network_get_local_system_ip */ ifr = (struct ifreq *)(gpointer)it; it += HX_SIZE_OF_IFREQ(*ifr); if (ifr->ifr_addr.sa_family == AF_INET) { struct sockaddr_in *sinptr = (struct sockaddr_in *)(gpointer)&ifr->ifr_addr; inet_ntop(AF_INET, &sinptr->sin_addr, dst, purple_debug_info("network", "found local i/f with address %s on IPv4\n", dst); if (!purple_strequal(dst, "127.0.0.1")) { result = g_list_append(result, g_strdup(dst)); #endif /* HAVE_GETIFADDRS && HAVE_INET_NTOP */ * purple_network_is_ipv4: * @hostname: The hostname to be verified. * Checks, if specified hostname is valid ipv4 address. * Returns: TRUE, if the hostname is valid. purple_network_is_ipv4(const gchar *hostname) g_return_val_if_fail(hostname != NULL, FALSE); /* We don't accept ipv6 here. */ if (strchr(hostname, ':') != NULL) return g_hostname_is_ip_address(hostname); purple_network_get_my_ip(int fd) PurpleStunNatDiscovery *stun; /* Check if the user specified an IP manually */ if (!purple_prefs_get_bool("/purple/network/auto_ip")) { ip = purple_network_get_public_ip(); /* Make sure the IP address entered by the user is valid */ if ((ip != NULL) && (purple_network_is_ipv4(ip))) /* Check if STUN discovery was already done */ stun = purple_stun_discover(NULL); if ((stun != NULL) && (stun->status == PURPLE_STUN_STATUS_DISCOVERED)) /* Attempt to get the IP from a NAT device using UPnP */ ip = purple_upnp_get_public_ip(); /* Attempt to get the IP from a NAT device using NAT-PMP */ ip = purple_pmp_get_public_ip(); /* Just fetch the IP of the local system */ return purple_network_get_local_system_ip(fd); purple_network_set_upnp_port_mapping_cb(gboolean success, gpointer data) PurpleNetworkListenData *listen_data; /* TODO: Once we're keeping track of upnp requests... */ /* listen_data->pnp_data = NULL; */ purple_debug_warning("network", "Couldn't create UPnP mapping\n"); if (listen_data->retry) { listen_data->retry = FALSE; listen_data->adding = FALSE; listen_data->mapping_data = purple_upnp_remove_port_mapping( purple_network_get_port_from_fd(listen_data->listenfd), (listen_data->socket_type == SOCK_STREAM) ? "TCP" : "UDP", purple_network_set_upnp_port_mapping_cb, listen_data); } else if (!listen_data->adding) { /* We've tried successfully to remove the port mapping. listen_data->adding = TRUE; listen_data->mapping_data = purple_upnp_set_port_mapping( purple_network_get_port_from_fd(listen_data->listenfd), (listen_data->socket_type == SOCK_STREAM) ? "TCP" : "UDP", purple_network_set_upnp_port_mapping_cb, listen_data); /* add port mapping to hash table */ gint key = purple_network_get_port_from_fd(listen_data->listenfd); gint value = listen_data->socket_type; g_hash_table_insert(upnp_port_mappings, GINT_TO_POINTER(key), GINT_TO_POINTER(value)); listen_data->cb(listen_data->listenfd, listen_data->cb_data); /* Clear the UPnP mapping data, since it's complete and purple_network_listen_cancel() will try to cancel listen_data->mapping_data = NULL; purple_network_listen_cancel(listen_data); purple_network_finish_pmp_map_cb(gpointer data) PurpleNetworkListenData *listen_data; /* add port mapping to hash table */ key = purple_network_get_port_from_fd(listen_data->listenfd); value = listen_data->socket_type; g_hash_table_insert(nat_pmp_port_mappings, GINT_TO_POINTER(key), GINT_TO_POINTER(value)); listen_data->cb(listen_data->listenfd, listen_data->cb_data); purple_network_listen_cancel(listen_data); static PurpleNetworkListenData * purple_network_do_listen(unsigned short port, int socket_family, int socket_type, gboolean map_external, PurpleNetworkListenCallback cb, gpointer cb_data) PurpleNetworkListenData *listen_data; unsigned short actual_port; struct addrinfo hints, *res, *next; * Get a list of addresses on this machine. g_snprintf(serv, sizeof(serv), "%hu", port); memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_flags = AI_PASSIVE; hints.ai_family = socket_family; hints.ai_socktype = socket_type; errnum = getaddrinfo(NULL /* any IP */, serv, &hints, &res); purple_debug_warning("network", "getaddrinfo: %s\n", purple_gai_strerror(errnum)); if (errnum == EAI_SYSTEM) purple_debug_warning("network", "getaddrinfo: system error: %s\n", g_strerror(errno)); purple_debug_warning("network", "getaddrinfo: Error Code = %d\n", errnum); * Go through the list of addresses and attempt to listen on * XXX - Try IPv6 addresses first? for (next = res; next != NULL; next = next->ai_next) { listenfd = socket(next->ai_family, next->ai_socktype, next->ai_protocol); if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) != 0) purple_debug_warning("network", "setsockopt(SO_REUSEADDR): %s\n", g_strerror(errno)); if (bind(listenfd, next->ai_addr, next->ai_addrlen) == 0) /* XXX - It is unclear to me (datallah) whether we need to be using a new socket each time */ struct sockaddr_in sockin; if (socket_family != AF_INET && socket_family != AF_UNSPEC) { purple_debug_warning("network", "Address family %d only " "supported when built with getaddrinfo() " "support\n", socket_family); if ((listenfd = socket(AF_INET, socket_type, 0)) < 0) { purple_debug_warning("network", "socket: %s\n", g_strerror(errno)); if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) != 0) purple_debug_warning("network", "setsockopt: %s\n", g_strerror(errno)); memset(&sockin, 0, sizeof(struct sockaddr_in)); sockin.sin_family = PF_INET; sockin.sin_port = htons(port); if (bind(listenfd, (struct sockaddr *)&sockin, sizeof(struct sockaddr_in)) != 0) { purple_debug_warning("network", "bind: %s\n", g_strerror(errno)); if (socket_type == SOCK_STREAM && listen(listenfd, 4) != 0) { purple_debug_warning("network", "listen: %s\n", g_strerror(errno)); _purple_network_set_common_socket_flags(listenfd); actual_port = purple_network_get_port_from_fd(listenfd); purple_debug_info("network", "Listening on port: %hu\n", actual_port); listen_data = g_new0(PurpleNetworkListenData, 1); listen_data->listenfd = listenfd; listen_data->adding = TRUE; listen_data->retry = TRUE; listen_data->cb_data = cb_data; listen_data->socket_type = socket_type; if (!purple_socket_speaks_ipv4(listenfd) || !map_external || !purple_prefs_get_bool("/purple/network/map_ports")) purple_debug_info("network", "Skipping external port mapping.\n"); /* The pmp_map_cb does what we want to do */ listen_data->timer = g_timeout_add(0, purple_network_finish_pmp_map_cb, listen_data); /* Attempt a NAT-PMP Mapping, which will return immediately */ else if (purple_pmp_create_map(((socket_type == SOCK_STREAM) ? PURPLE_PMP_TYPE_TCP : PURPLE_PMP_TYPE_UDP), actual_port, actual_port, PURPLE_PMP_LIFETIME)) purple_debug_info("network", "Created NAT-PMP mapping on port %i\n", actual_port); /* We want to return listen_data now, and on the next run loop trigger the cb and destroy listen_data */ listen_data->timer = g_timeout_add(0, purple_network_finish_pmp_map_cb, listen_data); /* Attempt a UPnP Mapping */ listen_data->mapping_data = purple_upnp_set_port_mapping( (socket_type == SOCK_STREAM) ? "TCP" : "UDP", purple_network_set_upnp_port_mapping_cb, listen_data); PurpleNetworkListenData * purple_network_listen(unsigned short port, int socket_family, int socket_type, gboolean map_external, PurpleNetworkListenCallback cb, g_return_val_if_fail(port != 0, NULL); return purple_network_do_listen(port, socket_family, socket_type, map_external, PurpleNetworkListenData * purple_network_listen_range(unsigned short start, unsigned short end, int socket_family, int socket_type, gboolean map_external, PurpleNetworkListenCallback cb, PurpleNetworkListenData *ret = NULL; if (purple_prefs_get_bool("/purple/network/ports_range_use")) { start = purple_prefs_get_int("/purple/network/ports_range_start"); end = purple_prefs_get_int("/purple/network/ports_range_end"); for (; start <= end; start++) { ret = purple_network_do_listen(start, AF_UNSPEC, socket_type, map_external, cb, cb_data); void purple_network_listen_cancel(PurpleNetworkListenData *listen_data) if (listen_data->mapping_data != NULL) purple_upnp_cancel_port_mapping(listen_data->mapping_data); if (listen_data->timer > 0) g_source_remove(listen_data->timer); purple_network_get_port_from_fd(int fd) g_return_val_if_fail(fd >= 0, 0); if (getsockname(fd, (struct sockaddr *) &addr, &len) == -1) { purple_debug_warning("network", "getsockname: %s\n", g_strerror(errno)); return ntohs(addr.sin_port); purple_network_is_available(void) return g_network_monitor_get_network_available(g_network_monitor_get_default()); purple_network_force_online() purple_network_ip_lookup_cb(GObject *sender, GAsyncResult *result, gpointer data) { GInetAddress *address = NULL; const gchar **ip_address = (const gchar **)data; addresses = g_resolver_lookup_by_name_finish(G_RESOLVER(sender), purple_debug_info("network", "lookup of IP address failed: %s\n", error->message); address = G_INET_ADDRESS(addresses->data); *ip_address = g_inet_address_to_string(address); g_resolver_free_addresses(addresses); purple_network_set_stun_server(const gchar *stun_server) if (stun_server && stun_server[0] != '\0') { if (purple_network_is_available()) { GResolver *resolver = g_resolver_get_default(); g_resolver_lookup_by_name_async(resolver, purple_network_ip_lookup_cb, g_object_unref(resolver); purple_debug_info("network", "network is unavailable, don't try to update STUN IP"); purple_network_set_turn_server(const gchar *turn_server) if (turn_server && turn_server[0] != '\0') { if (purple_network_is_available()) { GResolver *resolver = g_resolver_get_default(); g_resolver_lookup_by_name_async(resolver, purple_network_ip_lookup_cb, g_object_unref(resolver); purple_debug_info("network", "network is unavailable, don't try to update TURN IP"); purple_network_get_stun_ip(void) purple_network_get_turn_ip(void) purple_network_get_handle(void) purple_network_upnp_mapping_remove_cb(gboolean sucess, gpointer data) purple_debug_info("network", "done removing UPnP port mapping\n"); /* the reason for these functions to have these signatures is to be able to use them for g_hash_table_foreach to clean remaining port mappings, which is purple_network_upnp_mapping_remove(gpointer key, gpointer value, gint port = GPOINTER_TO_INT(key); gint protocol = GPOINTER_TO_INT(value); purple_debug_info("network", "removing UPnP port mapping for port %d\n", purple_upnp_remove_port_mapping(port, protocol == SOCK_STREAM ? "TCP" : "UDP", purple_network_upnp_mapping_remove_cb, NULL); g_hash_table_remove(upnp_port_mappings, GINT_TO_POINTER(port)); purple_network_nat_pmp_mapping_remove(gpointer key, gpointer value, gint port = GPOINTER_TO_INT(key); gint protocol = GPOINTER_TO_INT(value); purple_debug_info("network", "removing NAT-PMP port mapping for port %d\n", protocol == SOCK_STREAM ? PURPLE_PMP_TYPE_TCP : PURPLE_PMP_TYPE_UDP, g_hash_table_remove(nat_pmp_port_mappings, GINT_TO_POINTER(port)); purple_network_remove_port_mapping(gint fd) int port = purple_network_get_port_from_fd(fd); gint protocol = GPOINTER_TO_INT(g_hash_table_lookup(upnp_port_mappings, GINT_TO_POINTER(port))); purple_network_upnp_mapping_remove(GINT_TO_POINTER(port), GINT_TO_POINTER(protocol), NULL); protocol = GPOINTER_TO_INT(g_hash_table_lookup(nat_pmp_port_mappings, GINT_TO_POINTER(port))); purple_network_nat_pmp_mapping_remove(GINT_TO_POINTER(port), GINT_TO_POINTER(protocol), NULL); _purple_network_set_common_socket_flags(int fd) g_return_val_if_fail(fd >= 0, FALSE); flags = fcntl(fd, F_GETFL); if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) != 0) { purple_debug_warning("network", "Couldn't set O_NONBLOCK flag\n"); if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0) { purple_debug_warning("network", "Couldn't set FD_CLOEXEC flag\n"); purple_network_init(void) purple_prefs_add_none ("/purple/network"); purple_prefs_add_string("/purple/network/stun_server", ""); purple_prefs_add_string("/purple/network/turn_server", ""); purple_prefs_add_int ("/purple/network/turn_port", 3478); purple_prefs_add_int ("/purple/network/turn_port_tcp", 3478); purple_prefs_add_string("/purple/network/turn_username", ""); purple_prefs_add_string("/purple/network/turn_password", ""); purple_prefs_add_bool ("/purple/network/auto_ip", TRUE); purple_prefs_add_string("/purple/network/public_ip", ""); purple_prefs_add_bool ("/purple/network/map_ports", TRUE); purple_prefs_add_bool ("/purple/network/ports_range_use", FALSE); purple_prefs_add_int ("/purple/network/ports_range_start", 1024); purple_prefs_add_int ("/purple/network/ports_range_end", 2048); if(purple_prefs_get_bool("/purple/network/map_ports") || purple_prefs_get_bool("/purple/network/auto_ip")) purple_upnp_discover(NULL, NULL); purple_network_set_stun_server( purple_prefs_get_string("/purple/network/stun_server")); purple_network_set_turn_server( purple_prefs_get_string("/purple/network/turn_server")); upnp_port_mappings = g_hash_table_new(g_direct_hash, g_direct_equal); nat_pmp_port_mappings = g_hash_table_new(g_direct_hash, g_direct_equal); purple_network_uninit(void) g_hash_table_destroy(upnp_port_mappings); g_hash_table_destroy(nat_pmp_port_mappings); /* TODO: clean up remaining port mappings, note calling purple_upnp_remove_port_mapping from here doesn't quite work... */