14192
|
1 /**
|
|
2 * @file network.c Network Implementation
|
|
3 * @ingroup core
|
|
4 *
|
|
5 * gaim
|
|
6 *
|
|
7 * Gaim is the legal property of its developers, whose names are too numerous
|
|
8 * to list here. Please refer to the COPYRIGHT file distributed with this
|
|
9 * source distribution.
|
|
10 *
|
|
11 * This program is free software; you can redistribute it and/or modify
|
|
12 * it under the terms of the GNU General Public License as published by
|
|
13 * the Free Software Foundation; either version 2 of the License, or
|
|
14 * (at your option) any later version.
|
|
15 *
|
|
16 * This program is distributed in the hope that it will be useful,
|
|
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
19 * GNU General Public License for more details.
|
|
20 *
|
|
21 * You should have received a copy of the GNU General Public License
|
|
22 * along with this program; if not, write to the Free Software
|
|
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
24 */
|
|
25
|
|
26 #include "internal.h"
|
|
27
|
|
28 #ifndef _WIN32
|
|
29 #include <net/if.h>
|
|
30 #include <sys/ioctl.h>
|
|
31 #endif
|
|
32
|
|
33 /* Solaris */
|
|
34 #if defined (__SVR4) && defined (__sun)
|
|
35 #include <sys/sockio.h>
|
|
36 #endif
|
|
37
|
|
38 #include "debug.h"
|
|
39 #include "account.h"
|
|
40 #include "network.h"
|
|
41 #include "prefs.h"
|
|
42 #include "stun.h"
|
|
43 #include "upnp.h"
|
|
44
|
14696
|
45 #ifdef HAVE_LIBNM
|
|
46 #include <libnm_glib.h>
|
|
47
|
|
48 libnm_glib_ctx *nm_context = NULL;
|
|
49 guint nm_callback_idx = 0;
|
|
50
|
|
51 #endif
|
|
52
|
14267
|
53 struct _GaimNetworkListenData {
|
14192
|
54 int listenfd;
|
|
55 int socket_type;
|
|
56 gboolean retry;
|
|
57 gboolean adding;
|
|
58 GaimNetworkListenCallback cb;
|
|
59 gpointer cb_data;
|
14267
|
60 };
|
14192
|
61
|
14696
|
62 #ifdef HAVE_LIBNM
|
|
63 void nm_callback_func(libnm_glib_ctx* ctx, gpointer user_data);
|
|
64 #endif
|
|
65
|
14192
|
66 const unsigned char *
|
|
67 gaim_network_ip_atoi(const char *ip)
|
|
68 {
|
|
69 static unsigned char ret[4];
|
|
70 gchar *delimiter = ".";
|
|
71 gchar **split;
|
|
72 int i;
|
|
73
|
|
74 g_return_val_if_fail(ip != NULL, NULL);
|
|
75
|
|
76 split = g_strsplit(ip, delimiter, 4);
|
|
77 for (i = 0; split[i] != NULL; i++)
|
|
78 ret[i] = atoi(split[i]);
|
|
79 g_strfreev(split);
|
|
80
|
|
81 /* i should always be 4 */
|
|
82 if (i != 4)
|
|
83 return NULL;
|
|
84
|
|
85 return ret;
|
|
86 }
|
|
87
|
|
88 void
|
|
89 gaim_network_set_public_ip(const char *ip)
|
|
90 {
|
|
91 g_return_if_fail(ip != NULL);
|
|
92
|
|
93 /* XXX - Ensure the IP address is valid */
|
|
94
|
|
95 gaim_prefs_set_string("/core/network/public_ip", ip);
|
|
96 }
|
|
97
|
|
98 const char *
|
|
99 gaim_network_get_public_ip(void)
|
|
100 {
|
|
101 return gaim_prefs_get_string("/core/network/public_ip");
|
|
102 }
|
|
103
|
|
104 const char *
|
|
105 gaim_network_get_local_system_ip(int fd)
|
|
106 {
|
|
107 char buffer[1024];
|
|
108 static char ip[16];
|
|
109 char *tmp;
|
|
110 struct ifconf ifc;
|
|
111 struct ifreq *ifr;
|
|
112 struct sockaddr_in *sinptr;
|
|
113 guint32 lhost = htonl(127 * 256 * 256 * 256 + 1);
|
|
114 long unsigned int add;
|
|
115 int source = fd;
|
|
116
|
|
117 if (fd < 0)
|
|
118 source = socket(PF_INET,SOCK_STREAM, 0);
|
|
119
|
|
120 ifc.ifc_len = sizeof(buffer);
|
|
121 ifc.ifc_req = (struct ifreq *)buffer;
|
|
122 ioctl(source, SIOCGIFCONF, &ifc);
|
|
123
|
|
124 if (fd < 0)
|
|
125 close(source);
|
|
126
|
|
127 tmp = buffer;
|
|
128 while (tmp < buffer + ifc.ifc_len)
|
|
129 {
|
|
130 ifr = (struct ifreq *)tmp;
|
|
131 tmp += sizeof(struct ifreq);
|
|
132
|
|
133 if (ifr->ifr_addr.sa_family == AF_INET)
|
|
134 {
|
|
135 sinptr = (struct sockaddr_in *)&ifr->ifr_addr;
|
|
136 if (sinptr->sin_addr.s_addr != lhost)
|
|
137 {
|
|
138 add = ntohl(sinptr->sin_addr.s_addr);
|
|
139 g_snprintf(ip, 16, "%lu.%lu.%lu.%lu",
|
|
140 ((add >> 24) & 255),
|
|
141 ((add >> 16) & 255),
|
|
142 ((add >> 8) & 255),
|
|
143 add & 255);
|
|
144
|
|
145 return ip;
|
|
146 }
|
|
147 }
|
|
148 }
|
|
149
|
|
150 return "0.0.0.0";
|
|
151 }
|
|
152
|
|
153 const char *
|
|
154 gaim_network_get_my_ip(int fd)
|
|
155 {
|
|
156 const char *ip = NULL;
|
|
157 GaimStunNatDiscovery *stun;
|
|
158
|
|
159 /* Check if the user specified an IP manually */
|
|
160 if (!gaim_prefs_get_bool("/core/network/auto_ip")) {
|
|
161 ip = gaim_network_get_public_ip();
|
|
162 if ((ip != NULL) && (*ip != '\0'))
|
|
163 return ip;
|
|
164 }
|
|
165
|
|
166 /* Check if STUN discovery was already done */
|
|
167 stun = gaim_stun_discover(NULL);
|
|
168 if ((stun != NULL) && (stun->status == GAIM_STUN_STATUS_DISCOVERED))
|
|
169 return stun->publicip;
|
|
170
|
|
171 /* Attempt to get the IP from a NAT device using UPnP */
|
|
172 ip = gaim_upnp_get_public_ip();
|
|
173 if (ip != NULL)
|
|
174 return ip;
|
|
175
|
|
176 /* Just fetch the IP of the local system */
|
|
177 return gaim_network_get_local_system_ip(fd);
|
|
178 }
|
|
179
|
|
180
|
|
181 static void
|
|
182 gaim_network_set_upnp_port_mapping_cb(gboolean success, gpointer data)
|
|
183 {
|
14267
|
184 GaimNetworkListenData *listen_data;
|
|
185
|
|
186 listen_data = data;
|
|
187 /* TODO: Once we're keeping track of upnp requests... */
|
|
188 /* listen_data->pnp_data = NULL; */
|
14192
|
189
|
|
190 if (!success) {
|
|
191 gaim_debug_info("network", "Couldn't create UPnP mapping\n");
|
14267
|
192 if (listen_data->retry) {
|
|
193 listen_data->retry = FALSE;
|
|
194 listen_data->adding = FALSE;
|
|
195 /* TODO: Need to keep track of this return value! */
|
14192
|
196 gaim_upnp_remove_port_mapping(
|
14267
|
197 gaim_network_get_port_from_fd(listen_data->listenfd),
|
|
198 (listen_data->socket_type == SOCK_STREAM) ? "TCP" : "UDP",
|
|
199 gaim_network_set_upnp_port_mapping_cb, listen_data);
|
14192
|
200 return;
|
|
201 }
|
14267
|
202 } else if (!listen_data->adding) {
|
14192
|
203 /* We've tried successfully to remove the port mapping.
|
|
204 * Try to add it again */
|
14267
|
205 listen_data->adding = TRUE;
|
|
206 /* TODO: Need to keep track of this return value! */
|
14192
|
207 gaim_upnp_set_port_mapping(
|
14267
|
208 gaim_network_get_port_from_fd(listen_data->listenfd),
|
|
209 (listen_data->socket_type == SOCK_STREAM) ? "TCP" : "UDP",
|
|
210 gaim_network_set_upnp_port_mapping_cb, listen_data);
|
14192
|
211 return;
|
|
212 }
|
|
213
|
14267
|
214 if (listen_data->cb)
|
|
215 listen_data->cb(listen_data->listenfd, listen_data->cb_data);
|
14192
|
216
|
14267
|
217 gaim_network_listen_cancel(listen_data);
|
14192
|
218 }
|
|
219
|
|
220
|
14267
|
221 static GaimNetworkListenData *
|
14192
|
222 gaim_network_do_listen(unsigned short port, int socket_type, GaimNetworkListenCallback cb, gpointer cb_data)
|
|
223 {
|
|
224 int listenfd = -1;
|
|
225 const int on = 1;
|
14267
|
226 GaimNetworkListenData *listen_data;
|
14192
|
227 #ifdef HAVE_GETADDRINFO
|
|
228 int errnum;
|
|
229 struct addrinfo hints, *res, *next;
|
|
230 char serv[6];
|
|
231
|
|
232 /*
|
|
233 * Get a list of addresses on this machine.
|
|
234 */
|
|
235 snprintf(serv, sizeof(serv), "%hu", port);
|
|
236 memset(&hints, 0, sizeof(struct addrinfo));
|
|
237 hints.ai_flags = AI_PASSIVE;
|
|
238 hints.ai_family = AF_UNSPEC;
|
|
239 hints.ai_socktype = socket_type;
|
|
240 errnum = getaddrinfo(NULL /* any IP */, serv, &hints, &res);
|
|
241 if (errnum != 0) {
|
|
242 #ifndef _WIN32
|
|
243 gaim_debug_warning("network", "getaddrinfo: %s\n", gai_strerror(errnum));
|
|
244 if (errnum == EAI_SYSTEM)
|
|
245 gaim_debug_warning("network", "getaddrinfo: system error: %s\n", strerror(errno));
|
|
246 #else
|
|
247 gaim_debug_warning("network", "getaddrinfo: Error Code = %d\n", errnum);
|
|
248 #endif
|
14267
|
249 return NULL;
|
14192
|
250 }
|
|
251
|
|
252 /*
|
|
253 * Go through the list of addresses and attempt to listen on
|
|
254 * one of them.
|
|
255 * XXX - Try IPv6 addresses first?
|
|
256 */
|
|
257 for (next = res; next != NULL; next = next->ai_next) {
|
|
258 listenfd = socket(next->ai_family, next->ai_socktype, next->ai_protocol);
|
|
259 if (listenfd < 0)
|
|
260 continue;
|
|
261 if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) != 0)
|
|
262 gaim_debug_warning("network", "setsockopt: %s\n", strerror(errno));
|
|
263 if (bind(listenfd, next->ai_addr, next->ai_addrlen) == 0)
|
|
264 break; /* success */
|
|
265 /* XXX - It is unclear to me (datallah) whether we need to be
|
|
266 using a new socket each time */
|
|
267 close(listenfd);
|
|
268 }
|
|
269
|
|
270 freeaddrinfo(res);
|
|
271
|
|
272 if (next == NULL)
|
14267
|
273 return NULL;
|
14192
|
274 #else
|
|
275 struct sockaddr_in sockin;
|
|
276
|
|
277 if ((listenfd = socket(AF_INET, socket_type, 0)) < 0) {
|
|
278 gaim_debug_warning("network", "socket: %s\n", strerror(errno));
|
14267
|
279 return NULL;
|
14192
|
280 }
|
|
281
|
|
282 if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) != 0)
|
|
283 gaim_debug_warning("network", "setsockopt: %s\n", strerror(errno));
|
|
284
|
|
285 memset(&sockin, 0, sizeof(struct sockaddr_in));
|
|
286 sockin.sin_family = PF_INET;
|
|
287 sockin.sin_port = htons(port);
|
|
288
|
|
289 if (bind(listenfd, (struct sockaddr *)&sockin, sizeof(struct sockaddr_in)) != 0) {
|
|
290 gaim_debug_warning("network", "bind: %s\n", strerror(errno));
|
|
291 close(listenfd);
|
14267
|
292 return NULL;
|
14192
|
293 }
|
|
294 #endif
|
|
295
|
|
296 if (socket_type == SOCK_STREAM && listen(listenfd, 4) != 0) {
|
|
297 gaim_debug_warning("network", "listen: %s\n", strerror(errno));
|
|
298 close(listenfd);
|
14267
|
299 return NULL;
|
14192
|
300 }
|
|
301 fcntl(listenfd, F_SETFL, O_NONBLOCK);
|
|
302
|
|
303 gaim_debug_info("network", "Listening on port: %hu\n", gaim_network_get_port_from_fd(listenfd));
|
|
304
|
14267
|
305 listen_data = g_new0(GaimNetworkListenData, 1);
|
|
306 listen_data->listenfd = listenfd;
|
|
307 listen_data->adding = TRUE;
|
|
308 listen_data->retry = TRUE;
|
|
309 listen_data->cb = cb;
|
|
310 listen_data->cb_data = cb_data;
|
14192
|
311
|
14267
|
312 /* TODO: Need to keep track of this return value! */
|
14192
|
313 gaim_upnp_set_port_mapping(
|
|
314 gaim_network_get_port_from_fd(listenfd),
|
|
315 (socket_type == SOCK_STREAM) ? "TCP" : "UDP",
|
14267
|
316 gaim_network_set_upnp_port_mapping_cb, listen_data);
|
14192
|
317
|
14267
|
318 return listen_data;
|
14192
|
319 }
|
|
320
|
14267
|
321 GaimNetworkListenData *
|
14192
|
322 gaim_network_listen(unsigned short port, int socket_type,
|
|
323 GaimNetworkListenCallback cb, gpointer cb_data)
|
|
324 {
|
14267
|
325 g_return_val_if_fail(port != 0, NULL);
|
14192
|
326
|
|
327 return gaim_network_do_listen(port, socket_type, cb, cb_data);
|
|
328 }
|
|
329
|
14267
|
330 GaimNetworkListenData *
|
14192
|
331 gaim_network_listen_range(unsigned short start, unsigned short end,
|
|
332 int socket_type, GaimNetworkListenCallback cb, gpointer cb_data)
|
|
333 {
|
14267
|
334 GaimNetworkListenData *ret = NULL;
|
14192
|
335
|
|
336 if (gaim_prefs_get_bool("/core/network/ports_range_use")) {
|
|
337 start = gaim_prefs_get_int("/core/network/ports_range_start");
|
|
338 end = gaim_prefs_get_int("/core/network/ports_range_end");
|
|
339 } else {
|
|
340 if (end < start)
|
|
341 end = start;
|
|
342 }
|
|
343
|
|
344 for (; start <= end; start++) {
|
|
345 ret = gaim_network_do_listen(start, socket_type, cb, cb_data);
|
14267
|
346 if (ret != NULL)
|
14192
|
347 break;
|
|
348 }
|
|
349
|
|
350 return ret;
|
|
351 }
|
|
352
|
14267
|
353 void gaim_network_listen_cancel(GaimNetworkListenData *listen_data)
|
|
354 {
|
|
355 g_free(listen_data);
|
|
356 }
|
|
357
|
14192
|
358 unsigned short
|
|
359 gaim_network_get_port_from_fd(int fd)
|
|
360 {
|
|
361 struct sockaddr_in addr;
|
|
362 socklen_t len;
|
|
363
|
|
364 g_return_val_if_fail(fd >= 0, 0);
|
|
365
|
|
366 len = sizeof(addr);
|
|
367 if (getsockname(fd, (struct sockaddr *) &addr, &len) == -1) {
|
|
368 gaim_debug_warning("network", "getsockname: %s\n", strerror(errno));
|
|
369 return 0;
|
|
370 }
|
|
371
|
|
372 return ntohs(addr.sin_port);
|
|
373 }
|
|
374
|
14696
|
375 gboolean
|
|
376 gaim_network_is_available(void)
|
|
377 {
|
|
378 #ifdef HAVE_LIBNM
|
|
379 /* Try NetworkManager first, maybe we'll get lucky */
|
|
380 int libnm_retval = -1;
|
|
381
|
|
382 if (nm_context)
|
|
383 {
|
|
384 if ((libnm_retval = libnm_glib_get_network_state(nm_context)) == LIBNM_NO_NETWORK_CONNECTION)
|
|
385 {
|
|
386 gaim_debug_warning("network", "NetworkManager not active or reports no connection (retval = %i)\n", libnm_retval);
|
|
387 return FALSE;
|
|
388 }
|
|
389 if (libnm_retval == LIBNM_ACTIVE_NETWORK_CONNECTION) return TRUE;
|
|
390 }
|
|
391 #endif
|
|
392 return TRUE;
|
|
393 }
|
|
394
|
|
395 #ifdef HAVE_LIBNM
|
|
396 void
|
|
397 nm_callback_func(libnm_glib_ctx* ctx, gpointer user_data)
|
|
398 {
|
|
399 GList *l;
|
|
400 GaimAccount *account;
|
|
401 static libnm_glib_state prev = LIBNM_NO_DBUS;
|
|
402 libnm_glib_state current;
|
|
403 GaimConnectionUiOps *ui_ops = gaim_connections_get_ui_ops();
|
|
404
|
|
405 current = libnm_glib_get_network_state(ctx);
|
|
406 gaim_debug_info("network","Entering nm_callback_func!\n");
|
|
407
|
|
408 switch(current)
|
|
409 {
|
|
410 case LIBNM_ACTIVE_NETWORK_CONNECTION:
|
|
411 ui_ops->network_connected();
|
|
412 prev = current;
|
|
413 break;
|
|
414 case LIBNM_NO_NETWORK_CONNECTION:
|
|
415 if (prev != LIBNM_ACTIVE_NETWORK_CONNECTION)
|
|
416 break;
|
|
417 ui_ops->network_disconnected();
|
|
418 prev = current;
|
|
419 break;
|
|
420 case LIBNM_NO_DBUS:
|
|
421 case LIBNM_NO_NETWORKMANAGER:
|
|
422 case LIBNM_INVALID_CONTEXT:
|
|
423 default:
|
|
424 break;
|
|
425 }
|
|
426 }
|
|
427 #endif
|
|
428
|
14192
|
429 void
|
|
430 gaim_network_init(void)
|
|
431 {
|
|
432 gaim_prefs_add_none ("/core/network");
|
|
433 gaim_prefs_add_bool ("/core/network/auto_ip", TRUE);
|
|
434 gaim_prefs_add_string("/core/network/public_ip", "");
|
|
435 gaim_prefs_add_bool ("/core/network/ports_range_use", FALSE);
|
|
436 gaim_prefs_add_int ("/core/network/ports_range_start", 1024);
|
|
437 gaim_prefs_add_int ("/core/network/ports_range_end", 2048);
|
|
438
|
|
439 gaim_upnp_discover(NULL, NULL);
|
14696
|
440
|
|
441 #ifdef HAVE_LIBNM
|
|
442 nm_context = libnm_glib_init();
|
|
443 if(nm_context)
|
|
444 nm_callback_idx = libnm_glib_register_callback(nm_context, nm_callback_func, NULL, g_main_context_default());
|
|
445 #endif
|
14192
|
446 }
|
14696
|
447
|
|
448 void
|
|
449 gaim_network_uninit(void)
|
|
450 {
|
|
451 #ifdef HAVE_LIBNM
|
|
452 /* FIXME: If anyone can think of a more clever way to shut down libnm without
|
|
453 * using a global variable + this function, please do. */
|
|
454 if(nm_context && nm_callback_idx)
|
|
455 libnm_glib_unregister_callback(nm_context, nm_callback_idx);
|
|
456
|
|
457 if(nm_context)
|
|
458 libnm_glib_shutdown(nm_context);
|
|
459 #endif
|
|
460 }
|