vcs.maemo.org Git - connman/blob - plugins/ipv4.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 <unistd.h>
  27 #include <string.h>
  28 #include <sys/ioctl.h>
  29 #include <sys/socket.h>
  30 #include <netinet/in.h>
  31 #include <arpa/inet.h>
  32 #include <net/if.h>
  33 #include <net/route.h>
  34
  35 #include <linux/netlink.h>
  36 #include <linux/rtnetlink.h>
  37
  38 #define CONNMAN_API_SUBJECT_TO_CHANGE
  39 #include <connman/plugin.h>
  40 #include <connman/driver.h>
  41 #include <connman/resolver.h>
  42 #include <connman/rtnl.h>
  43 #include <connman/log.h>
  44
  45 #include "inet.h"
  46
  47 enum connman_ipv4_method {
  48         CONNMAN_IPV4_METHOD_UNKNOWN = 0,
  49         CONNMAN_IPV4_METHOD_OFF     = 1,
  50         CONNMAN_IPV4_METHOD_STATIC  = 2,
  51         CONNMAN_IPV4_METHOD_DHCP    = 3,
  52 };
  53
  54 struct connman_ipv4 {
  55         enum connman_ipv4_method method;
  56         struct in_addr address;
  57         struct in_addr netmask;
  58         struct in_addr broadcast;
  59 };
  60
  61 struct gateway_data {
  62         int index;
  63         char *gateway;
  64 };
  65
  66 static GSList *gateway_list = NULL;
  67
  68 static struct gateway_data *find_gateway(int index, const char *gateway)
  69 {
  70         GSList *list;
  71
  72         if (gateway == NULL)
  73                 return NULL;
  74
  75         for (list = gateway_list; list; list = list->next) {
  76                 struct gateway_data *data = list->data;
  77
  78                 if (data->gateway == NULL)
  79                         continue;
  80
  81                 if (data->index == index &&
  82                                 g_str_equal(data->gateway, gateway) == TRUE)
  83                         return data;
  84         }
  85
  86         return NULL;
  87 }
  88
  89 static int set_ipv4(struct connman_element *element,
  90                         struct connman_ipv4 *ipv4, const char *nameserver)
  91 {
  92         struct ifreq ifr;
  93         struct sockaddr_in *addr;
  94         int sk, err;
  95
  96         DBG("element %p ipv4 %p", element, ipv4);
  97
  98         sk = socket(PF_INET, SOCK_DGRAM, 0);
  99         if (sk < 0)
 100                 return -1;
 101
 102         memset(&ifr, 0, sizeof(ifr));
 103         ifr.ifr_ifindex = element->index;
 104
 105         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 106                 close(sk);
 107                 return -1;
 108         }
 109
 110         DBG("ifname %s", ifr.ifr_name);
 111
 112         addr = (struct sockaddr_in *) &ifr.ifr_addr;
 113         addr->sin_family = AF_INET;
 114         addr->sin_addr = ipv4->address;
 115
 116         err = ioctl(sk, SIOCSIFADDR, &ifr);
 117
 118         if (err < 0)
 119                 DBG("address setting failed (%s)", strerror(errno));
 120
 121         addr = (struct sockaddr_in *) &ifr.ifr_netmask;
 122         addr->sin_family = AF_INET;
 123         addr->sin_addr = ipv4->netmask;
 124
 125         err = ioctl(sk, SIOCSIFNETMASK, &ifr);
 126
 127         if (err < 0)
 128                 DBG("netmask setting failed (%s)", strerror(errno));
 129
 130         addr = (struct sockaddr_in *) &ifr.ifr_broadaddr;
 131         addr->sin_family = AF_INET;
 132         addr->sin_addr = ipv4->broadcast;
 133
 134         err = ioctl(sk, SIOCSIFBRDADDR, &ifr);
 135
 136         if (err < 0)
 137                 DBG("broadcast setting failed (%s)", strerror(errno));
 138
 139         close(sk);
 140
 141         connman_resolver_append(ifr.ifr_name, NULL, nameserver);
 142
 143         return 0;
 144 }
 145
 146 static int clear_ipv4(struct connman_element *element)
 147 {
 148         struct ifreq ifr;
 149         struct sockaddr_in *addr;
 150         int sk, err;
 151
 152         DBG("element %p", element);
 153
 154         sk = socket(PF_INET, SOCK_DGRAM, 0);
 155         if (sk < 0)
 156                 return -1;
 157
 158         memset(&ifr, 0, sizeof(ifr));
 159         ifr.ifr_ifindex = element->index;
 160
 161         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 162                 close(sk);
 163                 return -1;
 164         }
 165
 166         DBG("ifname %s", ifr.ifr_name);
 167
 168         connman_resolver_remove_all(ifr.ifr_name);
 169
 170         addr = (struct sockaddr_in *) &ifr.ifr_addr;
 171         addr->sin_family = AF_INET;
 172         addr->sin_addr.s_addr = INADDR_ANY;
 173
 174         //err = ioctl(sk, SIOCDIFADDR, &ifr);
 175         err = ioctl(sk, SIOCSIFADDR, &ifr);
 176
 177         close(sk);
 178
 179         if (err < 0 && errno != EADDRNOTAVAIL) {
 180                 DBG("address removal failed (%s)", strerror(errno));
 181                 return -1;
 182         }
 183
 184         return 0;
 185 }
 186
 187 static int set_route(struct connman_element *element, const char *gateway)
 188 {
 189         struct ifreq ifr;
 190         struct rtentry rt;
 191         struct sockaddr_in *addr;
 192         int sk, err;
 193
 194         DBG("element %p", element);
 195
 196         sk = socket(PF_INET, SOCK_DGRAM, 0);
 197         if (sk < 0)
 198                 return -1;
 199
 200         memset(&ifr, 0, sizeof(ifr));
 201         ifr.ifr_ifindex = element->index;
 202
 203         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 204                 close(sk);
 205                 return -1;
 206         }
 207
 208         DBG("ifname %s", ifr.ifr_name);
 209
 210         memset(&rt, 0, sizeof(rt));
 211         rt.rt_flags = RTF_UP | RTF_GATEWAY;
 212
 213         addr = (struct sockaddr_in *) &rt.rt_dst;
 214         addr->sin_family = AF_INET;
 215         addr->sin_addr.s_addr = INADDR_ANY;
 216
 217         addr = (struct sockaddr_in *) &rt.rt_gateway;
 218         addr->sin_family = AF_INET;
 219         addr->sin_addr.s_addr = inet_addr(gateway);
 220
 221         addr = (struct sockaddr_in *) &rt.rt_genmask;
 222         addr->sin_family = AF_INET;
 223         addr->sin_addr.s_addr = INADDR_ANY;
 224
 225         err = ioctl(sk, SIOCADDRT, &rt);
 226         if (err < 0)
 227                 DBG("default route setting failed (%s)", strerror(errno));
 228
 229         close(sk);
 230
 231         return err;
 232 }
 233
 234 static int del_route(struct connman_element *element, const char *gateway)
 235 {
 236         struct ifreq ifr;
 237         struct rtentry rt;
 238         struct sockaddr_in *addr;
 239         int sk, err;
 240
 241         DBG("element %p", element);
 242
 243         sk = socket(PF_INET, SOCK_DGRAM, 0);
 244         if (sk < 0)
 245                 return -1;
 246
 247         memset(&ifr, 0, sizeof(ifr));
 248         ifr.ifr_ifindex = element->index;
 249
 250         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 251                 close(sk);
 252                 return -1;
 253         }
 254
 255         DBG("ifname %s", ifr.ifr_name);
 256
 257         memset(&rt, 0, sizeof(rt));
 258         rt.rt_flags = RTF_UP | RTF_GATEWAY;
 259
 260         addr = (struct sockaddr_in *) &rt.rt_dst;
 261         addr->sin_family = AF_INET;
 262         addr->sin_addr.s_addr = INADDR_ANY;
 263
 264         addr = (struct sockaddr_in *) &rt.rt_gateway;
 265         addr->sin_family = AF_INET;
 266         addr->sin_addr.s_addr = inet_addr(gateway);
 267
 268         addr = (struct sockaddr_in *) &rt.rt_genmask;
 269         addr->sin_family = AF_INET;
 270         addr->sin_addr.s_addr = INADDR_ANY;
 271
 272         err = ioctl(sk, SIOCDELRT, &rt);
 273         if (err < 0)
 274                 DBG("default route removal failed (%s)", strerror(errno));
 275
 276         close(sk);
 277
 278         return err;
 279 }
 280
 281 static int conn_probe(struct connman_element *element)
 282 {
 283         const char *gateway = NULL;
 284
 285         DBG("element %p name %s", element, element->name);
 286
 287         if (element->parent == NULL)
 288                 return -ENODEV;
 289
 290         if (element->parent->type != CONNMAN_ELEMENT_TYPE_IPV4)
 291                 return -ENODEV;
 292
 293         connman_element_get_value(element,
 294                                 CONNMAN_PROPERTY_ID_IPV4_GATEWAY, &gateway);
 295
 296         DBG("gateway %s", gateway);
 297
 298         if (gateway == NULL)
 299                 return 0;
 300
 301         if (g_slist_length(gateway_list) > 0) {
 302                 DBG("default already present");
 303                 return 0;
 304         }
 305
 306         set_route(element, gateway);
 307
 308         connman_element_set_enabled(element, TRUE);
 309
 310         return 0;
 311 }
 312
 313 static void conn_remove(struct connman_element *element)
 314 {
 315         DBG("element %p name %s", element, element->name);
 316 }
 317
 318 static int conn_enable(struct connman_element *element)
 319 {
 320         const char *gateway = NULL;
 321
 322         DBG("element %p name %s", element, element->name);
 323
 324         connman_element_get_value(element,
 325                                 CONNMAN_PROPERTY_ID_IPV4_GATEWAY, &gateway);
 326
 327         DBG("gateway %s", gateway);
 328
 329         if (gateway == NULL)
 330                 return -EINVAL;
 331
 332         set_route(element, gateway);
 333
 334         return 0;
 335 }
 336
 337 static int conn_disable(struct connman_element *element)
 338 {
 339         const char *gateway = NULL;
 340
 341         DBG("element %p name %s", element, element->name);
 342
 343         connman_element_get_value(element,
 344                                 CONNMAN_PROPERTY_ID_IPV4_GATEWAY, &gateway);
 345
 346         DBG("gateway %s", gateway);
 347
 348         if (gateway == NULL)
 349                 return -EINVAL;
 350
 351         del_route(element, gateway);
 352
 353         return 0;
 354 }
 355
 356 static struct connman_driver conn_driver = {
 357         .name           = "ipv4-connection",
 358         .type           = CONNMAN_ELEMENT_TYPE_CONNECTION,
 359         .probe          = conn_probe,
 360         .remove         = conn_remove,
 361         .enable         = conn_enable,
 362         .disable        = conn_disable,
 363 };
 364
 365 static int ipv4_probe(struct connman_element *element)
 366 {
 367         struct connman_element *connection;
 368         struct connman_ipv4 ipv4;
 369         const char *address = NULL, *netmask = NULL, *broadcast = NULL;
 370         const char *nameserver = NULL;
 371
 372         DBG("element %p name %s", element, element->name);
 373
 374         connman_element_get_value(element,
 375                                 CONNMAN_PROPERTY_ID_IPV4_ADDRESS, &address);
 376         connman_element_get_value(element,
 377                                 CONNMAN_PROPERTY_ID_IPV4_NETMASK, &netmask);
 378         connman_element_get_value(element,
 379                                 CONNMAN_PROPERTY_ID_IPV4_BROADCAST, &broadcast);
 380
 381         connman_element_get_value(element,
 382                         CONNMAN_PROPERTY_ID_IPV4_NAMESERVER, &nameserver);
 383
 384         DBG("address %s", address);
 385         DBG("netmask %s", netmask);
 386         DBG("broadcast %s", broadcast);
 387
 388         if (address == NULL || netmask == NULL)
 389                 return -EINVAL;
 390
 391         memset(&ipv4, 0, sizeof(ipv4));
 392         ipv4.address.s_addr = inet_addr(address);
 393         ipv4.netmask.s_addr = inet_addr(netmask);
 394         ipv4.broadcast.s_addr = inet_addr(broadcast);
 395
 396         set_ipv4(element, &ipv4, nameserver);
 397
 398         connection = connman_element_create(NULL);
 399
 400         connection->type    = CONNMAN_ELEMENT_TYPE_CONNECTION;
 401         connection->index   = element->index;
 402         connection->devname = inet_index2name(element->index);
 403
 404         if (connman_element_register(connection, element) < 0)
 405                 connman_element_unref(connection);
 406
 407         return 0;
 408 }
 409
 410 static void ipv4_remove(struct connman_element *element)
 411 {
 412         DBG("element %p name %s", element, element->name);
 413
 414         clear_ipv4(element);
 415 }
 416
 417 static struct connman_driver ipv4_driver = {
 418         .name           = "ipv4-address",
 419         .type           = CONNMAN_ELEMENT_TYPE_IPV4,
 420         .probe          = ipv4_probe,
 421         .remove         = ipv4_remove,
 422 };
 423
 424 static void ipv4_newgateway(int index, const char *gateway)
 425 {
 426         struct gateway_data *data;
 427
 428         DBG("index %d gateway %s", index, gateway);
 429
 430         data = find_gateway(index, gateway);
 431         if (data != NULL)
 432                 return;
 433
 434         data = g_try_new0(struct gateway_data, 1);
 435         if (data == NULL)
 436                 return;
 437
 438         data->index = index;
 439         data->gateway = g_strdup(gateway);
 440
 441         gateway_list = g_slist_append(gateway_list, data);
 442 }
 443
 444 static void ipv4_delgateway(int index, const char *gateway)
 445 {
 446         struct gateway_data *data;
 447
 448         DBG("index %d gateway %s", index, gateway);
 449
 450         data = find_gateway(index, gateway);
 451         if (data == NULL)
 452                 return;
 453
 454         gateway_list = g_slist_remove(gateway_list, data);
 455
 456         g_free(data->gateway);
 457         g_free(data);
 458 }
 459
 460 static struct connman_rtnl ipv4_rtnl = {
 461         .name           = "ipv4-rtnl",
 462         .newgateway     = ipv4_newgateway,
 463         .delgateway     = ipv4_delgateway,
 464 };
 465
 466 static int ipv4_init(void)
 467 {
 468         int err;
 469
 470         err = connman_rtnl_register(&ipv4_rtnl);
 471         if (err < 0)
 472                 return err;
 473
 474         connman_rtnl_send_getroute();
 475
 476         err = connman_driver_register(&conn_driver);
 477         if (err < 0) {
 478                 connman_rtnl_unregister(&ipv4_rtnl);
 479                 return err;
 480         }
 481
 482         err = connman_driver_register(&ipv4_driver);
 483         if (err < 0) {
 484                 connman_driver_unregister(&conn_driver);
 485                 connman_rtnl_unregister(&ipv4_rtnl);
 486         }
 487
 488         return err;
 489 }
 490
 491 static void ipv4_exit(void)
 492 {
 493         GSList *list;
 494
 495         connman_driver_unregister(&conn_driver);
 496         connman_driver_unregister(&ipv4_driver);
 497
 498         connman_rtnl_unregister(&ipv4_rtnl);
 499
 500         for (list = gateway_list; list; list = list->next) {
 501                 struct gateway_data *data = list->data;
 502
 503                 DBG("index %d gateway %s", data->index, data->gateway);
 504
 505                 g_free(data->gateway);
 506                 g_free(data);
 507                 list->data = NULL;
 508         }
 509
 510         g_slist_free(gateway_list);
 511         gateway_list = NULL;
 512 }
 513
 514 CONNMAN_PLUGIN_DEFINE(ipv4, "IPv4 configuration plugin", VERSION,
 515                                                         ipv4_init, ipv4_exit)