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