50389334634f572fe7848b3e304223c545e44dec
[framework/connectivity/connman.git] / src / inet.c
1 /*
2  *
3  *  Connection Manager
4  *
5  *  Copyright (C) 2007-2009  Intel Corporation. All rights reserved.
6  *
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License version 2 as
9  *  published by the Free Software Foundation.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <stdio.h>
27 #include <errno.h>
28 #include <unistd.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <sys/stat.h>
32 #include <sys/ioctl.h>
33 #include <sys/socket.h>
34 #include <arpa/inet.h>
35 #include <net/route.h>
36 #include <net/ethernet.h>
37 #include <linux/if_arp.h>
38 #include <linux/wireless.h>
39
40 #include "connman.h"
41
42 int connman_inet_ifindex(const char *name)
43 {
44         struct ifreq ifr;
45         int sk, err;
46
47         if (name == NULL)
48                 return -1;
49
50         sk = socket(PF_INET, SOCK_DGRAM, 0);
51         if (sk < 0)
52                 return -1;
53
54         memset(&ifr, 0, sizeof(ifr));
55         strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
56
57         err = ioctl(sk, SIOCGIFINDEX, &ifr);
58
59         close(sk);
60
61         if (err < 0)
62                 return -1;
63
64         return ifr.ifr_ifindex;
65 }
66
67 char *connman_inet_ifname(int index)
68 {
69         struct ifreq ifr;
70         int sk, err;
71
72         if (index < 0)
73                 return NULL;
74
75         sk = socket(PF_INET, SOCK_DGRAM, 0);
76         if (sk < 0)
77                 return NULL;
78
79         memset(&ifr, 0, sizeof(ifr));
80         ifr.ifr_ifindex = index;
81
82         err = ioctl(sk, SIOCGIFNAME, &ifr);
83
84         close(sk);
85
86         if (err < 0)
87                 return NULL;
88
89         return strdup(ifr.ifr_name);
90 }
91
92 int connman_inet_ifup(int index)
93 {
94         struct ifreq ifr;
95         int sk, err;
96
97         sk = socket(PF_INET, SOCK_DGRAM, 0);
98         if (sk < 0)
99                 return -errno;
100
101         memset(&ifr, 0, sizeof(ifr));
102         ifr.ifr_ifindex = index;
103
104         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
105                 err = -errno;
106                 goto done;
107         }
108
109         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
110                 err = -errno;
111                 goto done;
112         }
113
114         if (ifr.ifr_flags & IFF_UP) {
115                 err = -EALREADY;
116                 goto done;
117         }
118
119         ifr.ifr_flags |= IFF_UP;
120
121         if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0) {
122                 err = -errno;
123                 goto done;
124         }
125
126         err = 0;
127
128 done:
129         close(sk);
130
131         return err;
132 }
133
134 int connman_inet_ifdown(int index)
135 {
136         struct ifreq ifr;
137         int sk, err;
138
139         sk = socket(PF_INET, SOCK_DGRAM, 0);
140         if (sk < 0)
141                 return -errno;
142
143         memset(&ifr, 0, sizeof(ifr));
144         ifr.ifr_ifindex = index;
145
146         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
147                 err = -errno;
148                 goto done;
149         }
150
151         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
152                 err = -errno;
153                 goto done;
154         }
155
156         if (!(ifr.ifr_flags & IFF_UP)) {
157                 err = -EALREADY;
158                 goto done;
159         }
160
161         ifr.ifr_flags &= ~IFF_UP;
162
163         if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0)
164                 err = -errno;
165         else
166                 err = 0;
167
168 done:
169         close(sk);
170
171         return err;
172 }
173
174 static unsigned short index2type(int index)
175 {
176         struct ifreq ifr;
177         int sk, err;
178
179         if (index < 0)
180                 return ARPHRD_VOID;
181
182         sk = socket(PF_INET, SOCK_DGRAM, 0);
183         if (sk < 0)
184                 return ARPHRD_VOID;
185
186         memset(&ifr, 0, sizeof(ifr));
187         ifr.ifr_ifindex = index;
188
189         err = ioctl(sk, SIOCGIFNAME, &ifr);
190
191         if (err == 0)
192                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
193
194         close(sk);
195
196         if (err < 0)
197                 return ARPHRD_VOID;
198
199         return ifr.ifr_hwaddr.sa_family;
200 }
201
202 static char *index2addr(int index)
203 {
204         struct ifreq ifr;
205         struct ether_addr *eth;
206         char *str;
207         int sk, err;
208
209         if (index < 0)
210                 return NULL;
211
212         sk = socket(PF_INET, SOCK_DGRAM, 0);
213         if (sk < 0)
214                 return NULL;
215
216         memset(&ifr, 0, sizeof(ifr));
217         ifr.ifr_ifindex = index;
218
219         err = ioctl(sk, SIOCGIFNAME, &ifr);
220
221         if (err == 0)
222                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
223
224         close(sk);
225
226         if (err < 0)
227                 return NULL;
228
229         str = malloc(18);
230         if (!str)
231                 return NULL;
232
233         eth = (void *) &ifr.ifr_hwaddr.sa_data;
234         snprintf(str, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
235                                                 eth->ether_addr_octet[0],
236                                                 eth->ether_addr_octet[1],
237                                                 eth->ether_addr_octet[2],
238                                                 eth->ether_addr_octet[3],
239                                                 eth->ether_addr_octet[4],
240                                                 eth->ether_addr_octet[5]);
241
242         return str;
243 }
244
245 static char *index2ident(int index, const char *prefix)
246 {
247         struct ifreq ifr;
248         struct ether_addr *eth;
249         char *str;
250         int sk, err, len;
251
252         if (index < 0)
253                 return NULL;
254
255         sk = socket(PF_INET, SOCK_DGRAM, 0);
256         if (sk < 0)
257                 return NULL;
258
259         memset(&ifr, 0, sizeof(ifr));
260         ifr.ifr_ifindex = index;
261
262         err = ioctl(sk, SIOCGIFNAME, &ifr);
263
264         if (err == 0)
265                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
266
267         close(sk);
268
269         if (err < 0)
270                 return NULL;
271
272         len = prefix ? strlen(prefix) + 18 : 18;
273
274         str = malloc(len);
275         if (!str)
276                 return NULL;
277
278         eth = (void *) &ifr.ifr_hwaddr.sa_data;
279         snprintf(str, len, "%s%02x%02x%02x%02x%02x%02x",
280                                                 prefix ? prefix : "",
281                                                 eth->ether_addr_octet[0],
282                                                 eth->ether_addr_octet[1],
283                                                 eth->ether_addr_octet[2],
284                                                 eth->ether_addr_octet[3],
285                                                 eth->ether_addr_octet[4],
286                                                 eth->ether_addr_octet[5]);
287
288         return str;
289 }
290
291 struct connman_device *connman_inet_create_device(int index)
292 {
293         enum connman_device_type devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
294         enum connman_device_mode mode = CONNMAN_DEVICE_MODE_UNKNOWN;
295         struct connman_device *device;
296         unsigned short type = index2type(index);
297         char *addr, *name, *devname, *ident = NULL;
298
299         if (index < 0)
300                 return NULL;
301
302         devname = connman_inet_ifname(index);
303         if (devname == NULL)
304                 return NULL;
305
306         __connman_udev_get_devtype(devname);
307
308         if (type == ARPHRD_ETHER) {
309                 char bridge_path[PATH_MAX], wimax_path[PATH_MAX];
310                 struct stat st;
311                 struct iwreq iwr;
312                 int sk;
313
314                 snprintf(bridge_path, PATH_MAX,
315                                         "/sys/class/net/%s/bridge", devname);
316                 snprintf(wimax_path, PATH_MAX,
317                                         "/sys/class/net/%s/wimax", devname);
318
319                 memset(&iwr, 0, sizeof(iwr));
320                 strncpy(iwr.ifr_ifrn.ifrn_name, devname, IFNAMSIZ);
321
322                 sk = socket(PF_INET, SOCK_DGRAM, 0);
323
324                 if (g_str_has_prefix(devname, "vmnet") == TRUE ||
325                                 g_str_has_prefix(devname, "vboxnet") == TRUE) {
326                         connman_info("Ignoring network interface %s", devname);
327                         devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
328                 } else if (g_str_has_prefix(devname, "bnep") == TRUE)
329                         devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
330                 else if (g_str_has_prefix(devname, "wmx") == TRUE)
331                         devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
332                 else if (stat(wimax_path, &st) == 0 && (st.st_mode & S_IFDIR))
333                         devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
334                 else if (stat(bridge_path, &st) == 0 && (st.st_mode & S_IFDIR))
335                         devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
336                 else if (ioctl(sk, SIOCGIWNAME, &iwr) == 0)
337                         devtype = CONNMAN_DEVICE_TYPE_WIFI;
338                 else
339                         devtype = CONNMAN_DEVICE_TYPE_ETHERNET;
340
341                 close(sk);
342         } else if (type == ARPHRD_NONE) {
343                 if (g_str_has_prefix(devname, "hso") == TRUE)
344                         devtype = CONNMAN_DEVICE_TYPE_HSO;
345         }
346
347         switch (devtype) {
348         case CONNMAN_DEVICE_TYPE_UNKNOWN:
349                 g_free(devname);
350                 return NULL;
351         case CONNMAN_DEVICE_TYPE_ETHERNET:
352         case CONNMAN_DEVICE_TYPE_WIFI:
353         case CONNMAN_DEVICE_TYPE_WIMAX:
354                 name = index2ident(index, "");
355                 addr = index2addr(index);
356                 break;
357         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
358         case CONNMAN_DEVICE_TYPE_GPS:
359         case CONNMAN_DEVICE_TYPE_HSO:
360         case CONNMAN_DEVICE_TYPE_NOZOMI:
361         case CONNMAN_DEVICE_TYPE_HUAWEI:
362         case CONNMAN_DEVICE_TYPE_NOVATEL:
363         case CONNMAN_DEVICE_TYPE_VENDOR:
364                 name = strdup(devname);
365                 addr = NULL;
366                 break;
367         }
368
369         device = connman_device_create(name, devtype);
370         if (device == NULL) {
371                 g_free(devname);
372                 g_free(name);
373                 g_free(addr);
374                 return NULL;
375         }
376
377         switch (devtype) {
378         case CONNMAN_DEVICE_TYPE_UNKNOWN:
379         case CONNMAN_DEVICE_TYPE_VENDOR:
380         case CONNMAN_DEVICE_TYPE_NOZOMI:
381         case CONNMAN_DEVICE_TYPE_HUAWEI:
382         case CONNMAN_DEVICE_TYPE_NOVATEL:
383         case CONNMAN_DEVICE_TYPE_GPS:
384                 mode = CONNMAN_DEVICE_MODE_UNKNOWN;
385                 break;
386         case CONNMAN_DEVICE_TYPE_ETHERNET:
387                 mode = CONNMAN_DEVICE_MODE_TRANSPORT_IP;
388                 ident = index2ident(index, NULL);
389                 break;
390         case CONNMAN_DEVICE_TYPE_WIFI:
391         case CONNMAN_DEVICE_TYPE_WIMAX:
392                 mode = CONNMAN_DEVICE_MODE_NETWORK_SINGLE;
393                 ident = index2ident(index, NULL);
394                 break;
395         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
396                 mode = CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE;
397                 break;
398         case CONNMAN_DEVICE_TYPE_HSO:
399                 mode = CONNMAN_DEVICE_MODE_NETWORK_SINGLE;
400                 break;
401         }
402
403         connman_device_set_mode(device, mode);
404
405         connman_device_set_index(device, index);
406         connman_device_set_interface(device, devname);
407
408         if (ident != NULL) {
409                 connman_device_set_ident(device, ident);
410                 g_free(ident);
411         }
412
413         connman_device_set_string(device, "Address", addr);
414
415         g_free(devname);
416         g_free(name);
417         g_free(addr);
418
419         return device;
420 }
421
422 int connman_inet_set_address(int index, struct in_addr address,
423                         struct in_addr netmask, struct in_addr broadcast)
424 {
425         struct ifreq ifr;
426         struct sockaddr_in *addr;
427         int sk, err;
428
429         sk = socket(PF_INET, SOCK_DGRAM, 0);
430         if (sk < 0)
431                 return -1;
432
433         memset(&ifr, 0, sizeof(ifr));
434         ifr.ifr_ifindex = index;
435
436         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
437                 close(sk);
438                 return -1;
439         }
440
441         DBG("ifname %s", ifr.ifr_name);
442
443         addr = (struct sockaddr_in *) &ifr.ifr_addr;
444         addr->sin_family = AF_INET;
445         addr->sin_addr = address;
446
447         err = ioctl(sk, SIOCSIFADDR, &ifr);
448
449         if (err < 0)
450                 DBG("address setting failed (%s)", strerror(errno));
451
452         addr = (struct sockaddr_in *) &ifr.ifr_netmask;
453         addr->sin_family = AF_INET;
454         addr->sin_addr = netmask;
455
456         err = ioctl(sk, SIOCSIFNETMASK, &ifr);
457
458         if (err < 0)
459                 DBG("netmask setting failed (%s)", strerror(errno));
460
461         addr = (struct sockaddr_in *) &ifr.ifr_broadaddr;
462         addr->sin_family = AF_INET;
463         addr->sin_addr = broadcast;
464
465         err = ioctl(sk, SIOCSIFBRDADDR, &ifr);
466
467         if (err < 0)
468                 DBG("broadcast setting failed (%s)", strerror(errno));
469
470         close(sk);
471
472         return 0;
473 }
474
475 int connman_inet_clear_address(int index)
476 {
477         struct ifreq ifr;
478         struct sockaddr_in *addr;
479         int sk, err;
480
481         sk = socket(PF_INET, SOCK_DGRAM, 0);
482         if (sk < 0)
483                 return -1;
484
485         memset(&ifr, 0, sizeof(ifr));
486         ifr.ifr_ifindex = index;
487
488         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
489                 close(sk);
490                 return -1;
491         }
492
493         DBG("ifname %s", ifr.ifr_name);
494
495         addr = (struct sockaddr_in *) &ifr.ifr_addr;
496         addr->sin_family = AF_INET;
497         addr->sin_addr.s_addr = INADDR_ANY;
498
499         //err = ioctl(sk, SIOCDIFADDR, &ifr);
500         err = ioctl(sk, SIOCSIFADDR, &ifr);
501
502         close(sk);
503
504         if (err < 0 && errno != EADDRNOTAVAIL) {
505                 DBG("address removal failed (%s)", strerror(errno));
506                 return -1;
507         }
508
509         return 0;
510 }
511
512 int connman_inet_set_gateway(int index, struct in_addr gateway)
513 {
514         struct ifreq ifr;
515         struct rtentry rt;
516         struct sockaddr_in *addr;
517         int sk, err;
518
519         sk = socket(PF_INET, SOCK_DGRAM, 0);
520         if (sk < 0)
521                 return -1;
522
523         memset(&ifr, 0, sizeof(ifr));
524         ifr.ifr_ifindex = index;
525
526         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
527                 close(sk);
528                 return -1;
529         }
530
531         DBG("ifname %s", ifr.ifr_name);
532
533         memset(&rt, 0, sizeof(rt));
534         rt.rt_flags = RTF_UP | RTF_HOST;
535
536         addr = (struct sockaddr_in *) &rt.rt_dst;
537         addr->sin_family = AF_INET;
538         addr->sin_addr = gateway;
539
540         addr = (struct sockaddr_in *) &rt.rt_gateway;
541         addr->sin_family = AF_INET;
542         addr->sin_addr.s_addr = INADDR_ANY;
543
544         addr = (struct sockaddr_in *) &rt.rt_genmask;
545         addr->sin_family = AF_INET;
546         addr->sin_addr.s_addr = INADDR_ANY;
547
548         rt.rt_dev = ifr.ifr_name;
549
550         err = ioctl(sk, SIOCADDRT, &rt);
551         if (err < 0)
552                 connman_error("Setting host gateway route failed (%s)",
553                                                         strerror(errno));
554
555         memset(&rt, 0, sizeof(rt));
556         rt.rt_flags = RTF_UP | RTF_GATEWAY;
557
558         addr = (struct sockaddr_in *) &rt.rt_dst;
559         addr->sin_family = AF_INET;
560         addr->sin_addr.s_addr = INADDR_ANY;
561
562         addr = (struct sockaddr_in *) &rt.rt_gateway;
563         addr->sin_family = AF_INET;
564         addr->sin_addr = gateway;
565
566         addr = (struct sockaddr_in *) &rt.rt_genmask;
567         addr->sin_family = AF_INET;
568         addr->sin_addr.s_addr = INADDR_ANY;
569
570         err = ioctl(sk, SIOCADDRT, &rt);
571         if (err < 0)
572                 connman_error("Setting default route failed (%s)",
573                                                         strerror(errno));
574
575         close(sk);
576
577         return err;
578 }