1 /**
2 * @file network.c Network Implementation
3 * @ingroup core
4 */
5
6 /* purple
7 *
8 * Purple is the legal property of its developers, whose names are too numerous
9 * to list here. Please refer to the COPYRIGHT file distributed with this
10 * source distribution.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
25 */
26
27 #include "internal.h"
28
29 #ifndef _WIN32
30 #include <arpa/nameser.h>
31 #include <resolv.h>
32 #include <netinet/in.h>
33 #include <net/if.h>
34 #include <sys/ioctl.h>
35 #ifdef HAVE_GETIFADDRS
36 #include <ifaddrs.h>
37 #endif
38 #else
39 #include <nspapi.h>
40 #endif
41
42 /* Solaris */
43 #if defined (__SVR4) && defined (__sun)
44 #include <sys/sockio.h>
45 #endif
46
47 #include "debug.h"
48 #include "account.h"
49 #include "nat-pmp.h"
50 #include "network.h"
51 #include "prefs.h"
52 #include "stun.h"
53 #include "upnp.h"
54 #include "dnsquery.h"
55
56 #ifdef USE_IDN
57 #include <idna.h>
58 #endif
59
60 #ifdef __HAIKU__
61 # ifndef SIOCGIFCONF
62 # include <sys/sockio.h>
63 # endif
64 #endif
65
66 /*
67 * Calling sizeof(struct ifreq) isn't always correct on
68 * Mac OS X (and maybe others).
69 */
70 #ifdef _SIZEOF_ADDR_IFREQ
71 # define HX_SIZE_OF_IFREQ(a) _SIZEOF_ADDR_IFREQ(a)
72 #else
73 # define HX_SIZE_OF_IFREQ(a) sizeof(a)
74 #endif
75
76 #ifdef HAVE_NETWORKMANAGER
77 #include <dbus/dbus-glib.h>
78 #include <NetworkManager.h>
79
80 #if !defined(NM_CHECK_VERSION)
81 #define NM_CHECK_VERSION(x,y,z) 0
82 #endif
83
84 static DBusGConnection *nm_conn = NULL;
85 static DBusGProxy *nm_proxy = NULL;
86 static DBusGProxy *dbus_proxy = NULL;
87 static NMState nm_state = NM_STATE_UNKNOWN;
88 static gboolean have_nm_state = FALSE;
89
90 #elif defined _WIN32
91 static int current_network_count;
92
93 /* Mutex for the other global vars */
94 static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
95 static gboolean network_initialized = FALSE;
96 static HANDLE network_change_handle = NULL;
97 static int (WSAAPI *MyWSANSPIoctl) (
98 HANDLE hLookup, DWORD dwControlCode, LPVOID lpvInBuffer,
99 DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer,
100 LPDWORD lpcbBytesReturned, LPWSACOMPLETION lpCompletion) = NULL;
101 #endif
102
103 struct _PurpleNetworkListenData {
104 int listenfd;
105 int socket_type;
106 gboolean retry;
107 gboolean adding;
108 PurpleNetworkListenCallback cb;
109 gpointer cb_data;
110 UPnPMappingAddRemove *mapping_data;
111 int timer;
112 };
113
114 #ifdef HAVE_NETWORKMANAGER
115 static NMState nm_get_network_state(void);
116 #endif
117
118 #if defined(HAVE_NETWORKMANAGER) || defined(_WIN32)
119 static gboolean force_online;
120 #endif
121
122 /* Cached IP addresses for STUN and TURN servers (set globally in prefs) */
123 static gchar *stun_ip = NULL;
124 static gchar *turn_ip = NULL;
125
126 /* Keep track of port mappings done with UPnP and NAT-PMP */
127 static GHashTable *upnp_port_mappings = NULL;
128 static GHashTable *nat_pmp_port_mappings = NULL;
129
130 const unsigned char *
purple_network_ip_atoi(const char * ip)131 purple_network_ip_atoi(const char *ip)
132 {
133 static unsigned char ret[4];
134 gchar *delimiter = ".";
135 gchar **split;
136 int i;
137
138 g_return_val_if_fail(ip != NULL, NULL);
139
140 split = g_strsplit(ip, delimiter, 4);
141 for (i = 0; split[i] != NULL; i++)
142 ret[i] = atoi(split[i]);
143 g_strfreev(split);
144
145 /* i should always be 4 */
146 if (i != 4)
147 return NULL;
148
149 return ret;
150 }
151
152 void
purple_network_set_public_ip(const char * ip)153 purple_network_set_public_ip(const char *ip)
154 {
155 g_return_if_fail(ip != NULL);
156
157 /* XXX - Ensure the IP address is valid */
158
159 purple_prefs_set_string("/purple/network/public_ip", ip);
160 }
161
162 const char *
purple_network_get_public_ip(void)163 purple_network_get_public_ip(void)
164 {
165 return purple_prefs_get_string("/purple/network/public_ip");
166 }
167
168 const char *
purple_network_get_local_system_ip(int fd)169 purple_network_get_local_system_ip(int fd)
170 {
171 char buffer[1024];
172 static char ip[16];
173 char *tmp;
174 struct ifconf ifc;
175 struct ifreq *ifr;
176 struct sockaddr_in *sinptr;
177 guint32 lhost = htonl((127 << 24) + 1); /* 127.0.0.1 */
178 long unsigned int add;
179 int source = fd;
180
181 if (fd < 0)
182 source = socket(PF_INET,SOCK_STREAM, 0);
183
184 ifc.ifc_len = sizeof(buffer);
185 ifc.ifc_req = (struct ifreq *)buffer;
186 ioctl(source, SIOCGIFCONF, &ifc);
187
188 if (fd < 0 && source >= 0)
189 close(source);
190
191 tmp = buffer;
192 while (tmp < buffer + ifc.ifc_len)
193 {
194 ifr = (struct ifreq *)tmp;
195 tmp += HX_SIZE_OF_IFREQ(*ifr);
196
197 if (ifr->ifr_addr.sa_family == AF_INET)
198 {
199 sinptr = (struct sockaddr_in *)&ifr->ifr_addr;
200 if (sinptr->sin_addr.s_addr != lhost)
201 {
202 add = ntohl(sinptr->sin_addr.s_addr);
203 g_snprintf(ip, 16, "%lu.%lu.%lu.%lu",
204 ((add >> 24) & 255),
205 ((add >> 16) & 255),
206 ((add >> 8) & 255),
207 add & 255);
208
209 return ip;
210 }
211 }
212 }
213
214 return "0.0.0.0";
215 }
216
217 GList *
purple_network_get_all_local_system_ips(void)218 purple_network_get_all_local_system_ips(void)
219 {
220 #if defined(HAVE_GETIFADDRS) && defined(HAVE_INET_NTOP)
221 GList *result = NULL;
222 struct ifaddrs *start, *ifa;
223 int ret;
224
225 ret = getifaddrs(&start);
226 if (ret < 0) {
227 purple_debug_warning("network",
228 "getifaddrs() failed: %s\n", g_strerror(errno));
229 return NULL;
230 }
231
232 for (ifa = start; ifa; ifa = ifa->ifa_next) {
233 int family = ifa->ifa_addr ? ifa->ifa_addr->sa_family : AF_UNSPEC;
234 char host[INET6_ADDRSTRLEN];
235 const char *tmp = NULL;
236
237 if ((family != AF_INET && family != AF_INET6) || ifa->ifa_flags & IFF_LOOPBACK)
238 continue;
239
240 if (family == AF_INET)
241 tmp = inet_ntop(family, &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr, host, sizeof(host));
242 else {
243 struct sockaddr_in6 *sockaddr = (struct sockaddr_in6 *)ifa->ifa_addr;
244 /* Peer-peer link-local communication is a big TODO. I am not sure
245 * how communicating link-local addresses is supposed to work, and
246 * it seems like it would require attempting the cartesian product
247 * of the local and remote interfaces to see if any match (eww).
248 */
249 if (!IN6_IS_ADDR_LINKLOCAL(&sockaddr->sin6_addr))
250 tmp = inet_ntop(family, &sockaddr->sin6_addr, host, sizeof(host));
251 }
252 if (tmp != NULL)
253 result = g_list_prepend(result, g_strdup(tmp));
254 }
255
256 freeifaddrs(start);
257
258 return g_list_reverse(result);
259 #else /* HAVE_GETIFADDRS && HAVE_INET_NTOP */
260 GList *result = NULL;
261 int source = socket(PF_INET,SOCK_STREAM, 0);
262 char buffer[1024];
263 char *tmp;
264 struct ifconf ifc;
265 struct ifreq *ifr;
266
267 ifc.ifc_len = sizeof(buffer);
268 ifc.ifc_req = (struct ifreq *)buffer;
269 ioctl(source, SIOCGIFCONF, &ifc);
270 close(source);
271
272 tmp = buffer;
273 while (tmp < buffer + ifc.ifc_len) {
274 char dst[INET_ADDRSTRLEN];
275
276 ifr = (struct ifreq *)tmp;
277 tmp += HX_SIZE_OF_IFREQ(*ifr);
278
279 if (ifr->ifr_addr.sa_family == AF_INET) {
280 struct sockaddr_in *sinptr = (struct sockaddr_in *)&ifr->ifr_addr;
281
282 inet_ntop(AF_INET, &sinptr->sin_addr, dst,
283 sizeof(dst));
284 purple_debug_info("network",
285 "found local i/f with address %s on IPv4\n", dst);
286 if (!purple_strequal(dst, "127.0.0.1")) {
287 result = g_list_append(result, g_strdup(dst));
288 }
289 }
290 }
291
292 return result;
293 #endif /* HAVE_GETIFADDRS && HAVE_INET_NTOP */
294 }
295
296 const char *
purple_network_get_my_ip(int fd)297 purple_network_get_my_ip(int fd)
298 {
299 const char *ip = NULL;
300 PurpleStunNatDiscovery *stun;
301
302 /* Check if the user specified an IP manually */
303 if (!purple_prefs_get_bool("/purple/network/auto_ip")) {
304 ip = purple_network_get_public_ip();
305 /* Make sure the IP address entered by the user is valid */
306 if ((ip != NULL) && (purple_network_ip_atoi(ip) != NULL))
307 return ip;
308 } else {
309 /* Check if STUN discovery was already done */
310 stun = purple_stun_discover(NULL);
311 if ((stun != NULL) && (stun->status == PURPLE_STUN_STATUS_DISCOVERED))
312 return stun->publicip;
313
314 /* Attempt to get the IP from a NAT device using UPnP */
315 ip = purple_upnp_get_public_ip();
316 if (ip != NULL)
317 return ip;
318
319 /* Attempt to get the IP from a NAT device using NAT-PMP */
320 ip = purple_pmp_get_public_ip();
321 if (ip != NULL)
322 return ip;
323 }
324
325 /* Just fetch the IP of the local system */
326 return purple_network_get_local_system_ip(fd);
327 }
328
329
330 static void
purple_network_set_upnp_port_mapping_cb(gboolean success,gpointer data)331 purple_network_set_upnp_port_mapping_cb(gboolean success, gpointer data)
332 {
333 PurpleNetworkListenData *listen_data;
334
335 listen_data = data;
336 /* TODO: Once we're keeping track of upnp requests... */
337 /* listen_data->pnp_data = NULL; */
338
339 if (!success) {
340 purple_debug_warning("network", "Couldn't create UPnP mapping\n");
341 if (listen_data->retry) {
342 listen_data->retry = FALSE;
343 listen_data->adding = FALSE;
344 listen_data->mapping_data = purple_upnp_remove_port_mapping(
345 purple_network_get_port_from_fd(listen_data->listenfd),
346 (listen_data->socket_type == SOCK_STREAM) ? "TCP" : "UDP",
347 purple_network_set_upnp_port_mapping_cb, listen_data);
348 return;
349 }
350 } else if (!listen_data->adding) {
351 /* We've tried successfully to remove the port mapping.
352 * Try to add it again */
353 listen_data->adding = TRUE;
354 listen_data->mapping_data = purple_upnp_set_port_mapping(
355 purple_network_get_port_from_fd(listen_data->listenfd),
356 (listen_data->socket_type == SOCK_STREAM) ? "TCP" : "UDP",
357 purple_network_set_upnp_port_mapping_cb, listen_data);
358 return;
359 }
360
361 if (success) {
362 /* add port mapping to hash table */
363 gint key = purple_network_get_port_from_fd(listen_data->listenfd);
364 gint value = listen_data->socket_type;
365 g_hash_table_insert(upnp_port_mappings, GINT_TO_POINTER(key), GINT_TO_POINTER(value));
366 }
367
368 if (listen_data->cb)
369 listen_data->cb(listen_data->listenfd, listen_data->cb_data);
370
371 /* Clear the UPnP mapping data, since it's complete and purple_network_listen_cancel() will try to cancel
372 * it otherwise. */
373 listen_data->mapping_data = NULL;
374 purple_network_listen_cancel(listen_data);
375 }
376
377 static gboolean
purple_network_finish_pmp_map_cb(gpointer data)378 purple_network_finish_pmp_map_cb(gpointer data)
379 {
380 PurpleNetworkListenData *listen_data;
381 gint key;
382 gint value;
383
384 listen_data = data;
385 listen_data->timer = 0;
386
387 /* add port mapping to hash table */
388 key = purple_network_get_port_from_fd(listen_data->listenfd);
389 value = listen_data->socket_type;
390 g_hash_table_insert(nat_pmp_port_mappings, GINT_TO_POINTER(key), GINT_TO_POINTER(value));
391
392 if (listen_data->cb)
393 listen_data->cb(listen_data->listenfd, listen_data->cb_data);
394
395 purple_network_listen_cancel(listen_data);
396
397 return FALSE;
398 }
399
400 static gboolean listen_map_external = TRUE;
purple_network_listen_map_external(gboolean map_external)401 void purple_network_listen_map_external(gboolean map_external)
402 {
403 listen_map_external = map_external;
404 }
405
406 static PurpleNetworkListenData *
purple_network_do_listen(unsigned short port,int socket_family,int socket_type,PurpleNetworkListenCallback cb,gpointer cb_data)407 purple_network_do_listen(unsigned short port, int socket_family, int socket_type, PurpleNetworkListenCallback cb, gpointer cb_data)
408 {
409 int listenfd = -1;
410 const int on = 1;
411 PurpleNetworkListenData *listen_data;
412 unsigned short actual_port;
413 #ifdef HAVE_GETADDRINFO
414 int errnum;
415 struct addrinfo hints, *res, *next;
416 char serv[6];
417
418 /*
419 * Get a list of addresses on this machine.
420 */
421 g_snprintf(serv, sizeof(serv), "%hu", port);
422 memset(&hints, 0, sizeof(struct addrinfo));
423 hints.ai_flags = AI_PASSIVE;
424 hints.ai_family = socket_family;
425 hints.ai_socktype = socket_type;
426 errnum = getaddrinfo(NULL /* any IP */, serv, &hints, &res);
427 if (errnum != 0) {
428 #ifndef _WIN32
429 purple_debug_warning("network", "getaddrinfo: %s\n", purple_gai_strerror(errnum));
430 if (errnum == EAI_SYSTEM)
431 purple_debug_warning("network", "getaddrinfo: system error: %s\n", g_strerror(errno));
432 #else
433 purple_debug_warning("network", "getaddrinfo: Error Code = %d\n", errnum);
434 #endif
435 return NULL;
436 }
437
438 /*
439 * Go through the list of addresses and attempt to listen on
440 * one of them.
441 * XXX - Try IPv6 addresses first?
442 */
443 for (next = res; next != NULL; next = next->ai_next) {
444 listenfd = socket(next->ai_family, next->ai_socktype, next->ai_protocol);
445 if (listenfd < 0)
446 continue;
447 if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) != 0)
448 purple_debug_warning("network", "setsockopt(SO_REUSEADDR): %s\n", g_strerror(errno));
449 if (bind(listenfd, next->ai_addr, next->ai_addrlen) == 0)
450 break; /* success */
451 /* XXX - It is unclear to me (datallah) whether we need to be
452 using a new socket each time */
453 close(listenfd);
454 }
455
456 freeaddrinfo(res);
457
458 if (next == NULL)
459 return NULL;
460 #else
461 struct sockaddr_in sockin;
462
463 if (socket_family != AF_INET && socket_family != AF_UNSPEC) {
464 purple_debug_warning("network", "Address family %d only "
465 "supported when built with getaddrinfo() "
466 "support\n", socket_family);
467 return NULL;
468 }
469
470 if ((listenfd = socket(AF_INET, socket_type, 0)) < 0) {
471 purple_debug_warning("network", "socket: %s\n", g_strerror(errno));
472 return NULL;
473 }
474
475 if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) != 0)
476 purple_debug_warning("network", "setsockopt: %s\n", g_strerror(errno));
477
478 memset(&sockin, 0, sizeof(struct sockaddr_in));
479 sockin.sin_family = PF_INET;
480 sockin.sin_port = htons(port);
481
482 if (bind(listenfd, (struct sockaddr *)&sockin, sizeof(struct sockaddr_in)) != 0) {
483 purple_debug_warning("network", "bind: %s\n", g_strerror(errno));
484 close(listenfd);
485 return NULL;
486 }
487 #endif
488
489 if (socket_type == SOCK_STREAM && listen(listenfd, 4) != 0) {
490 purple_debug_warning("network", "listen: %s\n", g_strerror(errno));
491 close(listenfd);
492 return NULL;
493 }
494 _purple_network_set_common_socket_flags(listenfd);
495 actual_port = purple_network_get_port_from_fd(listenfd);
496
497 purple_debug_info("network", "Listening on port: %hu\n", actual_port);
498
499 listen_data = g_new0(PurpleNetworkListenData, 1);
500 listen_data->listenfd = listenfd;
501 listen_data->adding = TRUE;
502 listen_data->retry = TRUE;
503 listen_data->cb = cb;
504 listen_data->cb_data = cb_data;
505 listen_data->socket_type = socket_type;
506
507 if (!purple_socket_speaks_ipv4(listenfd) || !listen_map_external ||
508 !purple_prefs_get_bool("/purple/network/map_ports"))
509 {
510 purple_debug_info("network", "Skipping external port mapping.\n");
511 /* The pmp_map_cb does what we want to do */
512 listen_data->timer = purple_timeout_add(0, purple_network_finish_pmp_map_cb, listen_data);
513 }
514 /* Attempt a NAT-PMP Mapping, which will return immediately */
515 else if (purple_pmp_create_map(((socket_type == SOCK_STREAM) ? PURPLE_PMP_TYPE_TCP : PURPLE_PMP_TYPE_UDP),
516 actual_port, actual_port, PURPLE_PMP_LIFETIME))
517 {
518 purple_debug_info("network", "Created NAT-PMP mapping on port %i\n", actual_port);
519 /* We want to return listen_data now, and on the next run loop trigger the cb and destroy listen_data */
520 listen_data->timer = purple_timeout_add(0, purple_network_finish_pmp_map_cb, listen_data);
521 }
522 else
523 {
524 /* Attempt a UPnP Mapping */
525 listen_data->mapping_data = purple_upnp_set_port_mapping(
526 actual_port,
527 (socket_type == SOCK_STREAM) ? "TCP" : "UDP",
528 purple_network_set_upnp_port_mapping_cb, listen_data);
529 }
530
531 return listen_data;
532 }
533
534 PurpleNetworkListenData *
purple_network_listen_family(unsigned short port,int socket_family,int socket_type,PurpleNetworkListenCallback cb,gpointer cb_data)535 purple_network_listen_family(unsigned short port, int socket_family,
536 int socket_type, PurpleNetworkListenCallback cb,
537 gpointer cb_data)
538 {
539 g_return_val_if_fail(port != 0, NULL);
540
541 return purple_network_do_listen(port, socket_family, socket_type,
542 cb, cb_data);
543 }
544
545 PurpleNetworkListenData *
purple_network_listen(unsigned short port,int socket_type,PurpleNetworkListenCallback cb,gpointer cb_data)546 purple_network_listen(unsigned short port, int socket_type,
547 PurpleNetworkListenCallback cb, gpointer cb_data)
548 {
549 return purple_network_listen_family(port, AF_UNSPEC, socket_type,
550 cb, cb_data);
551 }
552
553 PurpleNetworkListenData *
purple_network_listen_range_family(unsigned short start,unsigned short end,int socket_family,int socket_type,PurpleNetworkListenCallback cb,gpointer cb_data)554 purple_network_listen_range_family(unsigned short start, unsigned short end,
555 int socket_family, int socket_type,
556 PurpleNetworkListenCallback cb,
557 gpointer cb_data)
558 {
559 PurpleNetworkListenData *ret = NULL;
560
561 if (purple_prefs_get_bool("/purple/network/ports_range_use")) {
562 start = purple_prefs_get_int("/purple/network/ports_range_start");
563 end = purple_prefs_get_int("/purple/network/ports_range_end");
564 } else {
565 if (end < start)
566 end = start;
567 }
568
569 for (; start <= end; start++) {
570 ret = purple_network_do_listen(start, AF_UNSPEC, socket_type, cb, cb_data);
571 if (ret != NULL)
572 break;
573 }
574
575 return ret;
576 }
577
578 PurpleNetworkListenData *
purple_network_listen_range(unsigned short start,unsigned short end,int socket_type,PurpleNetworkListenCallback cb,gpointer cb_data)579 purple_network_listen_range(unsigned short start, unsigned short end,
580 int socket_type, PurpleNetworkListenCallback cb,
581 gpointer cb_data)
582 {
583 return purple_network_listen_range_family(start, end, AF_UNSPEC,
584 socket_type, cb, cb_data);
585 }
586
purple_network_listen_cancel(PurpleNetworkListenData * listen_data)587 void purple_network_listen_cancel(PurpleNetworkListenData *listen_data)
588 {
589 if (listen_data->mapping_data != NULL)
590 purple_upnp_cancel_port_mapping(listen_data->mapping_data);
591
592 if (listen_data->timer > 0)
593 purple_timeout_remove(listen_data->timer);
594
595 g_free(listen_data);
596 }
597
598 unsigned short
purple_network_get_port_from_fd(int fd)599 purple_network_get_port_from_fd(int fd)
600 {
601 struct sockaddr_in addr;
602 socklen_t len;
603
604 g_return_val_if_fail(fd >= 0, 0);
605
606 len = sizeof(addr);
607 if (getsockname(fd, (struct sockaddr *) &addr, &len) == -1) {
608 purple_debug_warning("network", "getsockname: %s\n", g_strerror(errno));
609 return 0;
610 }
611
612 return ntohs(addr.sin_port);
613 }
614
615 #ifdef _WIN32
616 #ifndef NS_NLA
617 #define NS_NLA 15
618 #endif
619 static gint
wpurple_get_connected_network_count(void)620 wpurple_get_connected_network_count(void)
621 {
622 gint net_cnt = 0;
623
624 WSAQUERYSET qs;
625 HANDLE h;
626 gint retval;
627 int errorid;
628
629 memset(&qs, 0, sizeof(WSAQUERYSET));
630 qs.dwSize = sizeof(WSAQUERYSET);
631 qs.dwNameSpace = NS_NLA;
632
633 retval = WSALookupServiceBeginA(&qs, LUP_RETURN_ALL, &h);
634 if (retval != ERROR_SUCCESS) {
635 gchar *msg;
636 errorid = WSAGetLastError();
637 msg = g_win32_error_message(errorid);
638 purple_debug_warning("network", "Couldn't retrieve NLA SP lookup handle. "
639 "NLA service is probably not running. Message: %s (%d).\n",
640 msg, errorid);
641 g_free(msg);
642
643 return -1;
644 } else {
645 gchar *buf = NULL;
646 WSAQUERYSET *res = (LPWSAQUERYSET) buf;
647 DWORD current_size = 0;
648 int iteration_count = 0;
649 while (iteration_count++ < 100) {
650 DWORD size = current_size;
651 retval = WSALookupServiceNextA(h, 0, &size, res);
652 if (retval == ERROR_SUCCESS) {
653 net_cnt++;
654 purple_debug_info("network", "found network '%s'\n",
655 res->lpszServiceInstanceName ? res->lpszServiceInstanceName : "(NULL)");
656 } else {
657 errorid = WSAGetLastError();
658 if (errorid == WSAEFAULT) {
659 if (size == 0 || size > 102400) {
660 purple_debug_warning("network", "Got unexpected NLA buffer size %" G_GUINT32_FORMAT ".\n", (guint32) size);
661 break;
662 }
663 buf = g_realloc(buf, size);
664 res = (LPWSAQUERYSET) buf;
665 current_size = size;
666 } else {
667 break;
668 }
669 }
670 }
671 g_free(buf);
672
673 if (!(errorid == WSA_E_NO_MORE || errorid == WSAENOMORE)) {
674 gchar *msg = g_win32_error_message(errorid);
675 purple_debug_error("network", "got unexpected NLA response %s (%d)\n", msg, errorid);
676 g_free(msg);
677
678 net_cnt = -1;
679 }
680
681 retval = WSALookupServiceEnd(h);
682 }
683
684 return net_cnt;
685
686 }
687
wpurple_network_change_thread_cb(gpointer data)688 static gboolean wpurple_network_change_thread_cb(gpointer data)
689 {
690 gint new_count;
691 PurpleConnectionUiOps *ui_ops = purple_connections_get_ui_ops();
692
693 new_count = wpurple_get_connected_network_count();
694
695 if (new_count < 0)
696 return FALSE;
697
698 purple_debug_info("network", "Received Network Change Notification. Current network count is %d, previous count was %d.\n", new_count, current_network_count);
699
700 purple_signal_emit(purple_network_get_handle(), "network-configuration-changed", NULL);
701
702 if (new_count > 0 && ui_ops != NULL && ui_ops->network_connected != NULL) {
703 ui_ops->network_connected();
704 } else if (new_count == 0 && current_network_count > 0 &&
705 ui_ops != NULL && ui_ops->network_disconnected != NULL) {
706 ui_ops->network_disconnected();
707 }
708
709 current_network_count = new_count;
710
711 return FALSE;
712 }
713
_print_debug_msg(gpointer data)714 static gboolean _print_debug_msg(gpointer data) {
715 gchar *msg = data;
716 purple_debug_warning("network", "%s", msg);
717 g_free(msg);
718 return FALSE;
719 }
720
wpurple_network_change_thread(gpointer data)721 static gpointer wpurple_network_change_thread(gpointer data)
722 {
723 WSAQUERYSET qs;
724 WSAEVENT *nla_event;
725 time_t last_trigger = time(NULL) - 31;
726 gchar *buf = NULL;
727 WSAQUERYSET *res = (LPWSAQUERYSET) buf;
728 DWORD current_size = 0;
729
730 if ((nla_event = WSACreateEvent()) == WSA_INVALID_EVENT) {
731 int errorid = WSAGetLastError();
732 gchar *msg = g_win32_error_message(errorid);
733 purple_timeout_add(0, _print_debug_msg,
734 g_strdup_printf("Couldn't create WSA event. "
735 "Message: %s (%d).\n", msg, errorid));
736 g_free(msg);
737 g_thread_exit(NULL);
738 return NULL;
739 }
740
741 while (TRUE) {
742 int retval;
743 int iteration_count;
744 DWORD retLen = 0;
745 WSACOMPLETION completion;
746 WSAOVERLAPPED overlapped;
747
748 g_static_mutex_lock(&mutex);
749 if (network_initialized == FALSE) {
750 /* purple_network_uninit has been called */
751 WSACloseEvent(nla_event);
752 g_static_mutex_unlock(&mutex);
753 g_thread_exit(NULL);
754 return NULL;
755 }
756
757 if (network_change_handle == NULL) {
758 memset(&qs, 0, sizeof(WSAQUERYSET));
759 qs.dwSize = sizeof(WSAQUERYSET);
760 qs.dwNameSpace = NS_NLA;
761 if (WSALookupServiceBeginA(&qs, 0, &network_change_handle) == SOCKET_ERROR) {
762 int errorid = WSAGetLastError();
763 gchar *msg = g_win32_error_message(errorid);
764 purple_timeout_add(0, _print_debug_msg,
765 g_strdup_printf("Couldn't retrieve NLA SP lookup handle. "
766 "NLA service is probably not running. Message: %s (%d).\n",
767 msg, errorid));
768 g_free(msg);
769 WSACloseEvent(nla_event);
770 g_static_mutex_unlock(&mutex);
771 g_thread_exit(NULL);
772 return NULL;
773 }
774 }
775 g_static_mutex_unlock(&mutex);
776
777 memset(&completion, 0, sizeof(WSACOMPLETION));
778 completion.Type = NSP_NOTIFY_EVENT;
779 overlapped.hEvent = nla_event;
780 completion.Parameters.Event.lpOverlapped = &overlapped;
781
782 if (MyWSANSPIoctl(network_change_handle, SIO_NSP_NOTIFY_CHANGE, NULL, 0, NULL, 0, &retLen, &completion) == SOCKET_ERROR) {
783 int errorid = WSAGetLastError();
784 if (errorid == WSA_INVALID_HANDLE) {
785 purple_timeout_add(0, _print_debug_msg,
786 g_strdup("Invalid NLA handle; resetting.\n"));
787 g_static_mutex_lock(&mutex);
788 retval = WSALookupServiceEnd(network_change_handle);
789 network_change_handle = NULL;
790 g_static_mutex_unlock(&mutex);
791 continue;
792 /* WSA_IO_PENDING indicates successful async notification will happen */
793 } else if (errorid != WSA_IO_PENDING) {
794 gchar *msg = g_win32_error_message(errorid);
795 purple_timeout_add(0, _print_debug_msg,
796 g_strdup_printf("Unable to wait for changes. Message: %s (%d).\n",
797 msg, errorid));
798 g_free(msg);
799 }
800 }
801
802 /* Make sure at least 30 seconds have elapsed since the last
803 * notification so we don't peg the cpu if this keeps changing. */
804 if ((time(NULL) - last_trigger) < 30)
805 Sleep(30000);
806
807 /* This will block until NLA notifies us */
808 retval = WaitForSingleObjectEx(nla_event, WSA_INFINITE, TRUE);
809
810 last_trigger = time(NULL);
811
812 g_static_mutex_lock(&mutex);
813 if (network_initialized == FALSE) {
814 /* Time to die */
815 WSACloseEvent(nla_event);
816 g_static_mutex_unlock(&mutex);
817 g_thread_exit(NULL);
818 return NULL;
819 }
820
821 iteration_count = 0;
822 while (iteration_count++ < 100) {
823 DWORD size = current_size;
824 retval = WSALookupServiceNextA(network_change_handle, 0, &size, res);
825 if (retval == ERROR_SUCCESS) {
826 /*purple_timeout_add(0, _print_debug_msg,
827 g_strdup_printf("thread found network '%s'\n",
828 res->lpszServiceInstanceName ? res->lpszServiceInstanceName : "(NULL)"));*/
829 } else {
830 int errorid = WSAGetLastError();
831 if (errorid == WSAEFAULT) {
832 if (size == 0 || size > 102400) {
833 purple_timeout_add(0, _print_debug_msg,
834 g_strdup_printf("Thread got unexpected NLA buffer size %" G_GUINT32_FORMAT ".\n", (guint32) size));
835 break;
836 }
837 buf = g_realloc(buf, size);
838 res = (LPWSAQUERYSET) buf;
839 current_size = size;
840 } else {
841 break;
842 }
843 }
844
845 }
846 g_free(buf);
847 buf = NULL;
848 current_size = 0;
849
850 WSAResetEvent(nla_event);
851 g_static_mutex_unlock(&mutex);
852
853 purple_timeout_add(0, wpurple_network_change_thread_cb, NULL);
854 }
855
856 g_thread_exit(NULL);
857 return NULL;
858 }
859 #endif
860
861 gboolean
purple_network_is_available(void)862 purple_network_is_available(void)
863 {
864 #ifdef HAVE_NETWORKMANAGER
865 if (force_online)
866 return TRUE;
867
868 if (!have_nm_state)
869 {
870 have_nm_state = TRUE;
871 nm_state = nm_get_network_state();
872 if (nm_state == NM_STATE_UNKNOWN)
873 purple_debug_warning("network", "NetworkManager not active. Assuming connection exists.\n");
874 }
875
876 switch (nm_state)
877 {
878 case NM_STATE_UNKNOWN:
879 #if NM_CHECK_VERSION(0,8,992)
880 case NM_STATE_CONNECTED_LOCAL:
881 case NM_STATE_CONNECTED_SITE:
882 case NM_STATE_CONNECTED_GLOBAL:
883 #else
884 case NM_STATE_CONNECTED:
885 #endif
886 return TRUE;
887 default:
888 break;
889 }
890
891 return FALSE;
892
893 #elif defined _WIN32
894 return (current_network_count > 0 || force_online);
895 #else
896 return TRUE;
897 #endif
898 }
899
900 void
purple_network_force_online()901 purple_network_force_online()
902 {
903 #if defined(HAVE_NETWORKMANAGER) || defined(_WIN32)
904 force_online = TRUE;
905 #endif
906 }
907
908 #ifdef HAVE_NETWORKMANAGER
909 static void
nm_update_state(NMState state)910 nm_update_state(NMState state)
911 {
912 NMState prev = nm_state;
913 PurpleConnectionUiOps *ui_ops = purple_connections_get_ui_ops();
914
915 have_nm_state = TRUE;
916 nm_state = state;
917
918 purple_signal_emit(purple_network_get_handle(), "network-configuration-changed", NULL);
919
920 switch(state)
921 {
922 #if NM_CHECK_VERSION(0,8,992)
923 case NM_STATE_CONNECTED_LOCAL:
924 case NM_STATE_CONNECTED_SITE:
925 case NM_STATE_CONNECTED_GLOBAL:
926 #else
927 case NM_STATE_CONNECTED:
928 #endif
929 /* Call res_init in case DNS servers have changed */
930 res_init();
931 /* update STUN IP in case we it changed (theoretically we could
932 have gone from IPv4 to IPv6, f.ex. or we were previously
933 offline */
934 purple_network_set_stun_server(
935 purple_prefs_get_string("/purple/network/stun_server"));
936 purple_network_set_turn_server(
937 purple_prefs_get_string("/purple/network/turn_server"));
938
939 if (ui_ops != NULL && ui_ops->network_connected != NULL)
940 ui_ops->network_connected();
941 break;
942 case NM_STATE_ASLEEP:
943 case NM_STATE_CONNECTING:
944 case NM_STATE_DISCONNECTED:
945 #if NM_CHECK_VERSION(0,8,992)
946 case NM_STATE_DISCONNECTING:
947 #endif
948 #if NM_CHECK_VERSION(1,0,0)
949 if (prev != NM_STATE_CONNECTED_GLOBAL && prev != NM_STATE_UNKNOWN)
950 break;
951 #else
952 if (prev != NM_STATE_CONNECTED && prev != NM_STATE_UNKNOWN)
953 break;
954 #endif
955 if (ui_ops != NULL && ui_ops->network_disconnected != NULL)
956 ui_ops->network_disconnected();
957 break;
958 case NM_STATE_UNKNOWN:
959 default:
960 break;
961 }
962 }
963
964 static void
nm_state_change_cb(DBusGProxy * proxy,NMState state,gpointer user_data)965 nm_state_change_cb(DBusGProxy *proxy, NMState state, gpointer user_data)
966 {
967 purple_debug_info("network", "Got StateChange from NetworkManager: %d.\n", state);
968 nm_update_state(state);
969 }
970
971 static NMState
nm_get_network_state(void)972 nm_get_network_state(void)
973 {
974 GError *err = NULL;
975 NMState state = NM_STATE_UNKNOWN;
976
977 if (!nm_proxy)
978 return NM_STATE_UNKNOWN;
979
980 if (!dbus_g_proxy_call(nm_proxy, "state", &err, G_TYPE_INVALID, G_TYPE_UINT, &state, G_TYPE_INVALID)) {
981 g_error_free(err);
982 return NM_STATE_UNKNOWN;
983 }
984
985 return state;
986 }
987
988 static void
nm_dbus_name_owner_changed_cb(DBusGProxy * proxy,char * service,char * old_owner,char * new_owner,gpointer user_data)989 nm_dbus_name_owner_changed_cb(DBusGProxy *proxy, char *service, char *old_owner, char *new_owner, gpointer user_data)
990 {
991 if (purple_strequal(service, NM_DBUS_SERVICE)) {
992 gboolean old_owner_good = old_owner && (old_owner[0] != '\0');
993 gboolean new_owner_good = new_owner && (new_owner[0] != '\0');
994
995 purple_debug_info("network", "Got NameOwnerChanged signal, service = '%s', old_owner = '%s', new_owner = '%s'\n", service, old_owner, new_owner);
996 if (!old_owner_good && new_owner_good) { /* Equivalent to old ServiceCreated signal */
997 purple_debug_info("network", "NetworkManager has started.\n");
998 nm_update_state(nm_get_network_state());
999 } else if (old_owner_good && !new_owner_good) { /* Equivalent to old ServiceDeleted signal */
1000 purple_debug_info("network", "NetworkManager has gone away.\n");
1001 nm_update_state(NM_STATE_UNKNOWN);
1002 }
1003 }
1004 }
1005
1006 #endif
1007
1008 static void
purple_network_ip_lookup_cb(GSList * hosts,gpointer data,const char * error_message)1009 purple_network_ip_lookup_cb(GSList *hosts, gpointer data,
1010 const char *error_message)
1011 {
1012 const gchar **ip = (const gchar **) data;
1013
1014 if (error_message) {
1015 purple_debug_error("network", "lookup of IP address failed: %s\n",
1016 error_message);
1017 g_slist_free(hosts);
1018 return;
1019 }
1020
1021 if (hosts && g_slist_next(hosts)) {
1022 struct sockaddr *addr = g_slist_next(hosts)->data;
1023 char dst[INET6_ADDRSTRLEN];
1024
1025 if (addr->sa_family == AF_INET6) {
1026 inet_ntop(addr->sa_family, &((struct sockaddr_in6 *) addr)->sin6_addr,
1027 dst, sizeof(dst));
1028 } else {
1029 inet_ntop(addr->sa_family, &((struct sockaddr_in *) addr)->sin_addr,
1030 dst, sizeof(dst));
1031 }
1032
1033 *ip = g_strdup(dst);
1034 purple_debug_info("network", "set IP address: %s\n", *ip);
1035 }
1036
1037 while (hosts != NULL) {
1038 hosts = g_slist_delete_link(hosts, hosts);
1039 /* Free the address */
1040 g_free(hosts->data);
1041 hosts = g_slist_delete_link(hosts, hosts);
1042 }
1043 }
1044
1045 void
purple_network_set_stun_server(const gchar * stun_server)1046 purple_network_set_stun_server(const gchar *stun_server)
1047 {
1048 if (stun_server && stun_server[0] != '\0') {
1049 if (purple_network_is_available()) {
1050 purple_debug_info("network", "running DNS query for STUN server\n");
1051 purple_dnsquery_a_account(NULL, stun_server, 3478, purple_network_ip_lookup_cb,
1052 &stun_ip);
1053 } else {
1054 purple_debug_info("network",
1055 "network is unavailable, don't try to update STUN IP");
1056 }
1057 } else if (stun_ip) {
1058 g_free(stun_ip);
1059 stun_ip = NULL;
1060 }
1061 }
1062
1063 void
purple_network_set_turn_server(const gchar * turn_server)1064 purple_network_set_turn_server(const gchar *turn_server)
1065 {
1066 if (turn_server && turn_server[0] != '\0') {
1067 if (purple_network_is_available()) {
1068 purple_debug_info("network", "running DNS query for TURN server\n");
1069 purple_dnsquery_a_account(NULL, turn_server,
1070 purple_prefs_get_int("/purple/network/turn_port"),
1071 purple_network_ip_lookup_cb, &turn_ip);
1072 } else {
1073 purple_debug_info("network",
1074 "network is unavailable, don't try to update TURN IP");
1075 }
1076 } else if (turn_ip) {
1077 g_free(turn_ip);
1078 turn_ip = NULL;
1079 }
1080 }
1081
1082
1083 const gchar *
purple_network_get_stun_ip(void)1084 purple_network_get_stun_ip(void)
1085 {
1086 return stun_ip;
1087 }
1088
1089 const gchar *
purple_network_get_turn_ip(void)1090 purple_network_get_turn_ip(void)
1091 {
1092 return turn_ip;
1093 }
1094
1095 void *
purple_network_get_handle(void)1096 purple_network_get_handle(void)
1097 {
1098 static int handle;
1099
1100 return &handle;
1101 }
1102
1103 static void
purple_network_upnp_mapping_remove_cb(gboolean sucess,gpointer data)1104 purple_network_upnp_mapping_remove_cb(gboolean sucess, gpointer data)
1105 {
1106 purple_debug_info("network", "done removing UPnP port mapping\n");
1107 }
1108
1109 /* the reason for these functions to have these signatures is to be able to
1110 use them for g_hash_table_foreach to clean remaining port mappings, which is
1111 not yet done */
1112 static void
purple_network_upnp_mapping_remove(gpointer key,gpointer value,gpointer user_data)1113 purple_network_upnp_mapping_remove(gpointer key, gpointer value,
1114 gpointer user_data)
1115 {
1116 gint port = GPOINTER_TO_INT(key);
1117 gint protocol = GPOINTER_TO_INT(value);
1118 purple_debug_info("network", "removing UPnP port mapping for port %d\n",
1119 port);
1120 purple_upnp_remove_port_mapping(port,
1121 protocol == SOCK_STREAM ? "TCP" : "UDP",
1122 purple_network_upnp_mapping_remove_cb, NULL);
1123 g_hash_table_remove(upnp_port_mappings, GINT_TO_POINTER(port));
1124 }
1125
1126 static void
purple_network_nat_pmp_mapping_remove(gpointer key,gpointer value,gpointer user_data)1127 purple_network_nat_pmp_mapping_remove(gpointer key, gpointer value,
1128 gpointer user_data)
1129 {
1130 gint port = GPOINTER_TO_INT(key);
1131 gint protocol = GPOINTER_TO_INT(value);
1132 purple_debug_info("network", "removing NAT-PMP port mapping for port %d\n",
1133 port);
1134 purple_pmp_destroy_map(
1135 protocol == SOCK_STREAM ? PURPLE_PMP_TYPE_TCP : PURPLE_PMP_TYPE_UDP,
1136 port);
1137 g_hash_table_remove(nat_pmp_port_mappings, GINT_TO_POINTER(port));
1138 }
1139
1140 void
purple_network_remove_port_mapping(gint fd)1141 purple_network_remove_port_mapping(gint fd)
1142 {
1143 int port = purple_network_get_port_from_fd(fd);
1144 gint protocol = GPOINTER_TO_INT(g_hash_table_lookup(upnp_port_mappings, GINT_TO_POINTER(port)));
1145
1146 if (protocol) {
1147 purple_network_upnp_mapping_remove(GINT_TO_POINTER(port), GINT_TO_POINTER(protocol), NULL);
1148 } else {
1149 protocol = GPOINTER_TO_INT(g_hash_table_lookup(nat_pmp_port_mappings, GINT_TO_POINTER(port)));
1150 if (protocol) {
1151 purple_network_nat_pmp_mapping_remove(GINT_TO_POINTER(port), GINT_TO_POINTER(protocol), NULL);
1152 }
1153 }
1154 }
1155
purple_network_convert_idn_to_ascii(const gchar * in,gchar ** out)1156 int purple_network_convert_idn_to_ascii(const gchar *in, gchar **out)
1157 {
1158 #ifdef USE_IDN
1159 char *tmp;
1160 int ret;
1161
1162 g_return_val_if_fail(out != NULL, -1);
1163
1164 ret = idna_to_ascii_8z(in, &tmp, IDNA_USE_STD3_ASCII_RULES);
1165 if (ret != IDNA_SUCCESS) {
1166 *out = NULL;
1167 return ret;
1168 }
1169
1170 *out = g_strdup(tmp);
1171 /* This *MUST* be freed with free, not g_free */
1172 free(tmp);
1173 return 0;
1174 #else
1175 g_return_val_if_fail(out != NULL, -1);
1176
1177 *out = g_strdup(in);
1178 return 0;
1179 #endif
1180 }
1181
1182 gboolean
_purple_network_set_common_socket_flags(int fd)1183 _purple_network_set_common_socket_flags(int fd)
1184 {
1185 int flags;
1186 gboolean succ = TRUE;
1187
1188 g_return_val_if_fail(fd >= 0, FALSE);
1189
1190 flags = fcntl(fd, F_GETFL);
1191
1192 if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) != 0) {
1193 purple_debug_warning("network",
1194 "Couldn't set O_NONBLOCK flag\n");
1195 succ = FALSE;
1196 }
1197
1198 #ifndef _WIN32
1199 if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0) {
1200 purple_debug_warning("network",
1201 "Couldn't set FD_CLOEXEC flag\n");
1202 succ = FALSE;
1203 }
1204 #endif
1205
1206 return succ;
1207 }
1208
1209 void
purple_network_init(void)1210 purple_network_init(void)
1211 {
1212 #ifdef HAVE_NETWORKMANAGER
1213 GError *error = NULL;
1214 #endif
1215 #ifdef _WIN32
1216 GError *err = NULL;
1217 gint cnt = wpurple_get_connected_network_count();
1218
1219 network_initialized = TRUE;
1220 if (cnt < 0) /* Assume there is a network */
1221 current_network_count = 1;
1222 /* Don't listen for network changes if we can't tell anyway */
1223 else {
1224 current_network_count = cnt;
1225 if ((MyWSANSPIoctl = (void*) wpurple_find_and_loadproc("ws2_32.dll", "WSANSPIoctl"))) {
1226 if (!g_thread_create(wpurple_network_change_thread, NULL, FALSE, &err))
1227 purple_debug_error("network", "Couldn't create Network Monitor thread: %s\n", err ? err->message : "");
1228 }
1229 }
1230 #endif
1231
1232 purple_prefs_add_none ("/purple/network");
1233 purple_prefs_add_string("/purple/network/stun_server", "");
1234 purple_prefs_add_string("/purple/network/turn_server", "");
1235 purple_prefs_add_int ("/purple/network/turn_port", 3478);
1236 purple_prefs_add_int ("/purple/network/turn_port_tcp", 3478);
1237 purple_prefs_add_string("/purple/network/turn_username", "");
1238 purple_prefs_add_string("/purple/network/turn_password", "");
1239 purple_prefs_add_bool ("/purple/network/auto_ip", FALSE);
1240 purple_prefs_add_string("/purple/network/public_ip", "");
1241 purple_prefs_add_bool ("/purple/network/map_ports", FALSE);
1242 purple_prefs_add_bool ("/purple/network/ports_range_use", FALSE);
1243 purple_prefs_add_int ("/purple/network/ports_range_start", 1024);
1244 purple_prefs_add_int ("/purple/network/ports_range_end", 2048);
1245
1246 if(purple_prefs_get_bool("/purple/network/map_ports") || purple_prefs_get_bool("/purple/network/auto_ip"))
1247 purple_upnp_discover(NULL, NULL);
1248
1249 #ifdef HAVE_NETWORKMANAGER
1250 nm_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
1251 if (!nm_conn) {
1252 purple_debug_warning("network", "Error connecting to DBus System service: %s.\n", error->message);
1253 } else {
1254 nm_proxy = dbus_g_proxy_new_for_name(nm_conn,
1255 NM_DBUS_SERVICE,
1256 NM_DBUS_PATH,
1257 NM_DBUS_INTERFACE);
1258 /* NM 0.6 signal */
1259 dbus_g_proxy_add_signal(nm_proxy, "StateChange", G_TYPE_UINT, G_TYPE_INVALID);
1260 dbus_g_proxy_connect_signal(nm_proxy, "StateChange",
1261 G_CALLBACK(nm_state_change_cb), NULL, NULL);
1262 /* NM 0.7 and later signal */
1263 dbus_g_proxy_add_signal(nm_proxy, "StateChanged", G_TYPE_UINT, G_TYPE_INVALID);
1264 dbus_g_proxy_connect_signal(nm_proxy, "StateChanged",
1265 G_CALLBACK(nm_state_change_cb), NULL, NULL);
1266
1267 dbus_proxy = dbus_g_proxy_new_for_name(nm_conn,
1268 DBUS_SERVICE_DBUS,
1269 DBUS_PATH_DBUS,
1270 DBUS_INTERFACE_DBUS);
1271 dbus_g_proxy_add_signal(dbus_proxy, "NameOwnerChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
1272 dbus_g_proxy_connect_signal(dbus_proxy, "NameOwnerChanged",
1273 G_CALLBACK(nm_dbus_name_owner_changed_cb), NULL, NULL);
1274 }
1275 #endif
1276
1277 purple_signal_register(purple_network_get_handle(), "network-configuration-changed",
1278 purple_marshal_VOID, NULL, 0);
1279
1280 purple_pmp_init();
1281 purple_upnp_init();
1282
1283 purple_network_set_stun_server(
1284 purple_prefs_get_string("/purple/network/stun_server"));
1285 purple_network_set_turn_server(
1286 purple_prefs_get_string("/purple/network/turn_server"));
1287
1288 upnp_port_mappings = g_hash_table_new(g_direct_hash, g_direct_equal);
1289 nat_pmp_port_mappings = g_hash_table_new(g_direct_hash, g_direct_equal);
1290 }
1291
1292
1293
1294 void
purple_network_uninit(void)1295 purple_network_uninit(void)
1296 {
1297 #ifdef HAVE_NETWORKMANAGER
1298 if (nm_proxy) {
1299 dbus_g_proxy_disconnect_signal(nm_proxy, "StateChange", G_CALLBACK(nm_state_change_cb), NULL);
1300 dbus_g_proxy_disconnect_signal(nm_proxy, "StateChanged", G_CALLBACK(nm_state_change_cb), NULL);
1301 g_object_unref(G_OBJECT(nm_proxy));
1302 }
1303 if (dbus_proxy) {
1304 dbus_g_proxy_disconnect_signal(dbus_proxy, "NameOwnerChanged", G_CALLBACK(nm_dbus_name_owner_changed_cb), NULL);
1305 g_object_unref(G_OBJECT(dbus_proxy));
1306 }
1307 if (nm_conn)
1308 dbus_g_connection_unref(nm_conn);
1309 #endif
1310
1311 #ifdef _WIN32
1312 g_static_mutex_lock(&mutex);
1313 network_initialized = FALSE;
1314 if (network_change_handle != NULL) {
1315 int retval;
1316 /* Trigger the NLA thread to stop waiting for network changes. Not
1317 * doing this can cause hangs on WSACleanup. */
1318 purple_debug_warning("network", "Terminating the NLA thread\n");
1319 if ((retval = WSALookupServiceEnd(network_change_handle)) == SOCKET_ERROR) {
1320 int errorid = WSAGetLastError();
1321 gchar *msg = g_win32_error_message(errorid);
1322 purple_debug_warning("network", "Unable to kill NLA thread. Message: %s (%d).\n",
1323 msg, errorid);
1324 g_free(msg);
1325 }
1326 network_change_handle = NULL;
1327
1328 }
1329 g_static_mutex_unlock(&mutex);
1330
1331 #endif
1332 purple_signal_unregister(purple_network_get_handle(),
1333 "network-configuration-changed");
1334
1335 if (stun_ip)
1336 g_free(stun_ip);
1337
1338 g_hash_table_destroy(upnp_port_mappings);
1339 g_hash_table_destroy(nat_pmp_port_mappings);
1340
1341 /* TODO: clean up remaining port mappings, note calling
1342 purple_upnp_remove_port_mapping from here doesn't quite work... */
1343 }
1344