Move the network device type detection into its own function
[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 enum connman_device_type __connman_inet_get_device_type(int index)
292 {
293         enum connman_device_type devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
294         unsigned short type = index2type(index);
295         const char *devname;
296         struct ifreq ifr;
297         int sk;
298
299         sk = socket(PF_INET, SOCK_DGRAM, 0);
300         if (sk < 0)
301                 return devtype;
302
303         memset(&ifr, 0, sizeof(ifr));
304         ifr.ifr_ifindex = index;
305
306         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0)
307                 goto done;
308
309         devname = ifr.ifr_name;
310
311         if (type == ARPHRD_ETHER) {
312                 char bridge_path[PATH_MAX], wimax_path[PATH_MAX];
313                 struct stat st;
314                 struct iwreq iwr;
315
316                 snprintf(bridge_path, PATH_MAX,
317                                         "/sys/class/net/%s/bridge", devname);
318                 snprintf(wimax_path, PATH_MAX,
319                                         "/sys/class/net/%s/wimax", devname);
320
321                 memset(&iwr, 0, sizeof(iwr));
322                 strncpy(iwr.ifr_ifrn.ifrn_name, devname, IFNAMSIZ);
323
324                 if (g_str_has_prefix(devname, "vmnet") == TRUE ||
325                                 g_str_has_prefix(ifr.ifr_name, "vboxnet") == TRUE) {
326                         devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
327                 } else if (g_str_has_prefix(devname, "bnep") == TRUE)
328                         devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
329                 else if (g_str_has_prefix(devname, "wmx") == TRUE)
330                         devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
331                 else if (g_str_has_prefix(devname, "usb") == TRUE)
332                         devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
333                 else if (stat(wimax_path, &st) == 0 && (st.st_mode & S_IFDIR))
334                         devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
335                 else if (stat(bridge_path, &st) == 0 && (st.st_mode & S_IFDIR))
336                         devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
337                 else if (ioctl(sk, SIOCGIWNAME, &iwr) == 0)
338                         devtype = CONNMAN_DEVICE_TYPE_WIFI;
339                 else
340                         devtype = CONNMAN_DEVICE_TYPE_ETHERNET;
341         } else if (type == ARPHRD_NONE) {
342                 if (g_str_has_prefix(devname, "hso") == TRUE)
343                         devtype = CONNMAN_DEVICE_TYPE_HSO;
344         }
345
346 done:
347         close(sk);
348
349         return devtype;
350 }
351
352 struct connman_device *connman_inet_create_device(int index)
353 {
354         enum connman_device_mode mode = CONNMAN_DEVICE_MODE_UNKNOWN;
355         enum connman_device_type type;
356         struct connman_device *device;
357         char *addr, *name, *devname, *ident = NULL;
358
359         if (index < 0)
360                 return NULL;
361
362         devname = connman_inet_ifname(index);
363         if (devname == NULL)
364                 return NULL;
365
366         __connman_udev_get_devtype(devname);
367
368         type = __connman_inet_get_device_type(index);
369
370         switch (type) {
371         case CONNMAN_DEVICE_TYPE_UNKNOWN:
372                 connman_info("Ignoring network interface %s", devname);
373                 g_free(devname);
374                 return NULL;
375         case CONNMAN_DEVICE_TYPE_ETHERNET:
376         case CONNMAN_DEVICE_TYPE_WIFI:
377         case CONNMAN_DEVICE_TYPE_WIMAX:
378                 name = index2ident(index, "");
379                 addr = index2addr(index);
380                 break;
381         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
382         case CONNMAN_DEVICE_TYPE_GPS:
383         case CONNMAN_DEVICE_TYPE_MBM:
384         case CONNMAN_DEVICE_TYPE_HSO:
385         case CONNMAN_DEVICE_TYPE_NOZOMI:
386         case CONNMAN_DEVICE_TYPE_HUAWEI:
387         case CONNMAN_DEVICE_TYPE_NOVATEL:
388         case CONNMAN_DEVICE_TYPE_VENDOR:
389                 name = strdup(devname);
390                 addr = NULL;
391                 break;
392         }
393
394         device = connman_device_create(name, type);
395         if (device == NULL) {
396                 g_free(devname);
397                 g_free(name);
398                 g_free(addr);
399                 return NULL;
400         }
401
402         switch (type) {
403         case CONNMAN_DEVICE_TYPE_UNKNOWN:
404         case CONNMAN_DEVICE_TYPE_VENDOR:
405         case CONNMAN_DEVICE_TYPE_NOZOMI:
406         case CONNMAN_DEVICE_TYPE_HUAWEI:
407         case CONNMAN_DEVICE_TYPE_NOVATEL:
408         case CONNMAN_DEVICE_TYPE_GPS:
409                 mode = CONNMAN_DEVICE_MODE_UNKNOWN;
410                 break;
411         case CONNMAN_DEVICE_TYPE_ETHERNET:
412                 mode = CONNMAN_DEVICE_MODE_TRANSPORT_IP;
413                 ident = index2ident(index, NULL);
414                 break;
415         case CONNMAN_DEVICE_TYPE_WIFI:
416         case CONNMAN_DEVICE_TYPE_WIMAX:
417                 mode = CONNMAN_DEVICE_MODE_NETWORK_SINGLE;
418                 ident = index2ident(index, NULL);
419                 break;
420         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
421                 mode = CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE;
422                 break;
423         case CONNMAN_DEVICE_TYPE_MBM:
424         case CONNMAN_DEVICE_TYPE_HSO:
425                 mode = CONNMAN_DEVICE_MODE_NETWORK_SINGLE;
426                 break;
427         }
428
429         connman_device_set_mode(device, mode);
430
431         connman_device_set_index(device, index);
432         connman_device_set_interface(device, devname);
433
434         if (ident != NULL) {
435                 connman_device_set_ident(device, ident);
436                 g_free(ident);
437         }
438
439         connman_device_set_string(device, "Address", addr);
440
441         g_free(devname);
442         g_free(name);
443         g_free(addr);
444
445         return device;
446 }
447
448 int connman_inet_set_address(int index, struct in_addr address,
449                         struct in_addr netmask, struct in_addr broadcast)
450 {
451         struct ifreq ifr;
452         struct sockaddr_in *addr;
453         int sk, err;
454
455         sk = socket(PF_INET, SOCK_DGRAM, 0);
456         if (sk < 0)
457                 return -1;
458
459         memset(&ifr, 0, sizeof(ifr));
460         ifr.ifr_ifindex = index;
461
462         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
463                 close(sk);
464                 return -1;
465         }
466
467         DBG("ifname %s", ifr.ifr_name);
468
469         addr = (struct sockaddr_in *) &ifr.ifr_addr;
470         addr->sin_family = AF_INET;
471         addr->sin_addr = address;
472
473         err = ioctl(sk, SIOCSIFADDR, &ifr);
474
475         if (err < 0)
476                 DBG("address setting failed (%s)", strerror(errno));
477
478         addr = (struct sockaddr_in *) &ifr.ifr_netmask;
479         addr->sin_family = AF_INET;
480         addr->sin_addr = netmask;
481
482         err = ioctl(sk, SIOCSIFNETMASK, &ifr);
483
484         if (err < 0)
485                 DBG("netmask setting failed (%s)", strerror(errno));
486
487         addr = (struct sockaddr_in *) &ifr.ifr_broadaddr;
488         addr->sin_family = AF_INET;
489         addr->sin_addr = broadcast;
490
491         err = ioctl(sk, SIOCSIFBRDADDR, &ifr);
492
493         if (err < 0)
494                 DBG("broadcast setting failed (%s)", strerror(errno));
495
496         close(sk);
497
498         return 0;
499 }
500
501 int connman_inet_clear_address(int index)
502 {
503         struct ifreq ifr;
504         struct sockaddr_in *addr;
505         int sk, err;
506
507         sk = socket(PF_INET, SOCK_DGRAM, 0);
508         if (sk < 0)
509                 return -1;
510
511         memset(&ifr, 0, sizeof(ifr));
512         ifr.ifr_ifindex = index;
513
514         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
515                 close(sk);
516                 return -1;
517         }
518
519         DBG("ifname %s", ifr.ifr_name);
520
521         addr = (struct sockaddr_in *) &ifr.ifr_addr;
522         addr->sin_family = AF_INET;
523         addr->sin_addr.s_addr = INADDR_ANY;
524
525         //err = ioctl(sk, SIOCDIFADDR, &ifr);
526         err = ioctl(sk, SIOCSIFADDR, &ifr);
527
528         close(sk);
529
530         if (err < 0 && errno != EADDRNOTAVAIL) {
531                 DBG("address removal failed (%s)", strerror(errno));
532                 return -1;
533         }
534
535         return 0;
536 }
537
538 int connman_inet_set_gateway(int index, struct in_addr gateway)
539 {
540         struct ifreq ifr;
541         struct rtentry rt;
542         struct sockaddr_in *addr;
543         int sk, err;
544
545         sk = socket(PF_INET, SOCK_DGRAM, 0);
546         if (sk < 0)
547                 return -1;
548
549         memset(&ifr, 0, sizeof(ifr));
550         ifr.ifr_ifindex = index;
551
552         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
553                 close(sk);
554                 return -1;
555         }
556
557         DBG("ifname %s", ifr.ifr_name);
558
559         memset(&rt, 0, sizeof(rt));
560         rt.rt_flags = RTF_UP | RTF_HOST;
561
562         addr = (struct sockaddr_in *) &rt.rt_dst;
563         addr->sin_family = AF_INET;
564         addr->sin_addr = gateway;
565
566         addr = (struct sockaddr_in *) &rt.rt_gateway;
567         addr->sin_family = AF_INET;
568         addr->sin_addr.s_addr = INADDR_ANY;
569
570         addr = (struct sockaddr_in *) &rt.rt_genmask;
571         addr->sin_family = AF_INET;
572         addr->sin_addr.s_addr = INADDR_ANY;
573
574         rt.rt_dev = ifr.ifr_name;
575
576         err = ioctl(sk, SIOCADDRT, &rt);
577         if (err < 0)
578                 connman_error("Setting host gateway route failed (%s)",
579                                                         strerror(errno));
580
581         memset(&rt, 0, sizeof(rt));
582         rt.rt_flags = RTF_UP | RTF_GATEWAY;
583
584         addr = (struct sockaddr_in *) &rt.rt_dst;
585         addr->sin_family = AF_INET;
586         addr->sin_addr.s_addr = INADDR_ANY;
587
588         addr = (struct sockaddr_in *) &rt.rt_gateway;
589         addr->sin_family = AF_INET;
590         addr->sin_addr = gateway;
591
592         addr = (struct sockaddr_in *) &rt.rt_genmask;
593         addr->sin_family = AF_INET;
594         addr->sin_addr.s_addr = INADDR_ANY;
595
596         err = ioctl(sk, SIOCADDRT, &rt);
597         if (err < 0)
598                 connman_error("Setting default route failed (%s)",
599                                                         strerror(errno));
600
601         close(sk);
602
603         return err;
604 }