src/connection.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
   6  *  Copyright (C) 2011  BMW Car IT GmbH. All rights reserved.
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License version 2 as
  10  *  published by the Free Software Foundation.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <net/if.h>
  30
  31 #include <gdbus.h>
  32
  33 #include "connman.h"
  34
  35 struct gateway_config {
  36         gboolean active;
  37         char *gateway;
  38
  39         /* VPN extra data */
  40         gboolean vpn;
  41         char *vpn_ip;
  42         int vpn_phy_index;
  43         char *vpn_phy_ip;
  44 };
  45
  46 struct gateway_data {
  47         int index;
  48         struct connman_service *service;
  49         unsigned int order;
  50         struct gateway_config *ipv4_gateway;
  51         struct gateway_config *ipv6_gateway;
  52 };
  53
  54 static GHashTable *gateway_hash = NULL;
  55
  56 static struct gateway_config *find_gateway(int index, const char *gateway)
  57 {
  58         GHashTableIter iter;
  59         gpointer value, key;
  60
  61         if (gateway == NULL)
  62                 return NULL;
  63
  64         g_hash_table_iter_init(&iter, gateway_hash);
  65
  66         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
  67                 struct gateway_data *data = value;
  68
  69                 if (data->ipv4_gateway != NULL && data->index == index &&
  70                                 g_str_equal(data->ipv4_gateway->gateway,
  71                                         gateway) == TRUE)
  72                         return data->ipv4_gateway;
  73
  74                 if (data->ipv6_gateway != NULL && data->index == index &&
  75                                 g_str_equal(data->ipv6_gateway->gateway,
  76                                         gateway) == TRUE)
  77                         return data->ipv6_gateway;
  78         }
  79
  80         return NULL;
  81 }
  82
  83 static int del_routes(struct gateway_data *data,
  84                         enum connman_ipconfig_type type)
  85 {
  86         int status4 = 0, status6 = 0;
  87         int do_ipv4 = FALSE, do_ipv6 = FALSE;
  88
  89         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
  90                 do_ipv4 = TRUE;
  91         else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
  92                 do_ipv6 = TRUE;
  93         else
  94                 do_ipv4 = do_ipv6 = TRUE;
  95
  96         if (do_ipv4 == TRUE && data->ipv4_gateway != NULL) {
  97                 if (data->ipv4_gateway->vpn == TRUE) {
  98                         if (data->ipv4_gateway->vpn_phy_index >= 0)
  99                                 connman_inet_del_host_route(
 100                                         data->ipv4_gateway->vpn_phy_index,
 101                                         data->ipv4_gateway->gateway);
 102
 103                         status4 = connman_inet_clear_gateway_address(
 104                                                 data->index,
 105                                                 data->ipv4_gateway->vpn_ip);
 106
 107                 } else if (g_strcmp0(data->ipv4_gateway->gateway,
 108                                                         "0.0.0.0") == 0) {
 109                         status4 = connman_inet_clear_gateway_interface(
 110                                                                 data->index);
 111                 } else {
 112                         connman_inet_del_host_route(data->index,
 113                                                 data->ipv4_gateway->gateway);
 114                         status4 = connman_inet_clear_gateway_address(
 115                                                 data->index,
 116                                                 data->ipv4_gateway->gateway);
 117                 }
 118         }
 119
 120         if (do_ipv6 == TRUE && data->ipv6_gateway != NULL) {
 121                 if (data->ipv6_gateway->vpn == TRUE) {
 122                         if (data->ipv6_gateway->vpn_phy_index >= 0)
 123                                 connman_inet_del_host_route(
 124                                         data->ipv6_gateway->vpn_phy_index,
 125                                         data->ipv6_gateway->gateway);
 126
 127                         status6 = connman_inet_clear_ipv6_gateway_address(
 128                                                 data->index,
 129                                                 data->ipv6_gateway->vpn_ip);
 130
 131                 } else if (g_strcmp0(data->ipv6_gateway->gateway, "::") == 0) {
 132                         status6 = connman_inet_clear_ipv6_gateway_interface(
 133                                                                 data->index);
 134                 } else {
 135                         connman_inet_del_ipv6_host_route(data->index,
 136                                                 data->ipv6_gateway->gateway);
 137                         status6 = connman_inet_clear_ipv6_gateway_address(
 138                                                 data->index,
 139                                                 data->ipv6_gateway->gateway);
 140                 }
 141         }
 142
 143         return (status4 < 0 ? status4 : status6);
 144 }
 145
 146 static int disable_gateway(struct gateway_data *data,
 147                         enum connman_ipconfig_type type)
 148 {
 149         gboolean active = FALSE;
 150
 151         if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
 152                 if (data->ipv4_gateway != NULL)
 153                         active = data->ipv4_gateway->active;
 154         } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
 155                 if (data->ipv6_gateway != NULL)
 156                         active = data->ipv6_gateway->active;
 157         } else
 158                 active = TRUE;
 159
 160         DBG("type %d active %d", type, active);
 161
 162         if (active == TRUE)
 163                 return del_routes(data, type);
 164
 165         return 0;
 166 }
 167
 168 static struct gateway_data *add_gateway(struct connman_service *service,
 169                                         int index, const char *gateway,
 170                                         enum connman_ipconfig_type type)
 171 {
 172         struct gateway_data *data, *old;
 173         struct gateway_config *config;
 174
 175         if (gateway == NULL || strlen(gateway) == 0)
 176                 return NULL;
 177
 178         data = g_try_new0(struct gateway_data, 1);
 179         if (data == NULL)
 180                 return NULL;
 181
 182         data->index = index;
 183
 184         config = g_try_new0(struct gateway_config, 1);
 185         if (config == NULL) {
 186                 g_free(data);
 187                 return NULL;
 188         }
 189
 190         config->gateway = g_strdup(gateway);
 191         config->vpn_ip = NULL;
 192         config->vpn_phy_ip = NULL;
 193         config->vpn = FALSE;
 194         config->vpn_phy_index = -1;
 195         config->active = FALSE;
 196
 197         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
 198                 data->ipv4_gateway = config;
 199         else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
 200                 data->ipv6_gateway = config;
 201         else {
 202                 g_free(config->gateway);
 203                 g_free(config);
 204                 g_free(data);
 205                 return NULL;
 206         }
 207
 208         data->service = service;
 209
 210         data->order = __connman_service_get_order(service);
 211
 212         /*
 213          * If the service is already in the hash, then we
 214          * must not replace it blindly but disable the gateway
 215          * of the type we are replacing and take the other type
 216          * from old gateway settings.
 217          */
 218         old = g_hash_table_lookup(gateway_hash, service);
 219         if (old != NULL) {
 220                 DBG("Replacing gw %p ipv4 %p ipv6 %p", old,
 221                         old->ipv4_gateway, old->ipv6_gateway);
 222                 disable_gateway(old, type);
 223                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
 224                         data->ipv6_gateway = old->ipv6_gateway;
 225                         old->ipv6_gateway = NULL;
 226                 } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
 227                         data->ipv4_gateway = old->ipv4_gateway;
 228                         old->ipv4_gateway = NULL;
 229                 }
 230         } else {
 231                 /*
 232                  * Only take a ref if we are adding new stuff to hash.
 233                  */
 234                 connman_service_ref(service);
 235         }
 236
 237         g_hash_table_replace(gateway_hash, service, data);
 238
 239         return data;
 240 }
 241
 242 static void connection_newgateway(int index, const char *gateway)
 243 {
 244         struct gateway_config *config;
 245
 246         DBG("index %d gateway %s", index, gateway);
 247
 248         config = find_gateway(index, gateway);
 249         if (config == NULL)
 250                 return;
 251
 252         config->active = TRUE;
 253 }
 254
 255 static void set_default_gateway(struct gateway_data *data,
 256                                 enum connman_ipconfig_type type)
 257 {
 258         int index;
 259         int status4 = 0, status6 = 0;
 260         int do_ipv4 = FALSE, do_ipv6 = FALSE;
 261
 262         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
 263                 do_ipv4 = TRUE;
 264         else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
 265                 do_ipv6 = TRUE;
 266         else
 267                 do_ipv4 = do_ipv6 = TRUE;
 268
 269         DBG("type %d gateway ipv4 %p ipv6 %p", type, data->ipv4_gateway,
 270                                                 data->ipv6_gateway);
 271
 272         if (do_ipv4 == TRUE && data->ipv4_gateway != NULL &&
 273                                         data->ipv4_gateway->vpn == TRUE) {
 274                 connman_inet_set_gateway_address(data->index,
 275                                                 data->ipv4_gateway->vpn_ip);
 276                 connman_inet_add_host_route(data->ipv4_gateway->vpn_phy_index,
 277                                         data->ipv4_gateway->vpn_ip,
 278                                         data->ipv4_gateway->vpn_phy_ip);
 279                 data->ipv4_gateway->active = TRUE;
 280
 281                 __connman_service_indicate_default(data->service);
 282
 283                 return;
 284         }
 285
 286         if (do_ipv6 == TRUE && data->ipv6_gateway != NULL &&
 287                                         data->ipv6_gateway->vpn == TRUE) {
 288                 connman_inet_set_ipv6_gateway_address(data->index,
 289                                                 data->ipv6_gateway->vpn_ip);
 290                 connman_inet_add_ipv6_host_route(
 291                                         data->ipv6_gateway->vpn_phy_index,
 292                                         data->ipv6_gateway->vpn_ip,
 293                                         data->ipv6_gateway->vpn_phy_ip);
 294                 data->ipv6_gateway->active = TRUE;
 295
 296                 __connman_service_indicate_default(data->service);
 297
 298                 return;
 299         }
 300
 301         index = __connman_service_get_index(data->service);
 302
 303         if (do_ipv4 == TRUE && data->ipv4_gateway != NULL &&
 304                         g_strcmp0(data->ipv4_gateway->gateway,
 305                                                         "0.0.0.0") == 0) {
 306                 if (connman_inet_set_gateway_interface(index) < 0)
 307                         return;
 308                 goto done;
 309         }
 310
 311         if (do_ipv6 == TRUE && data->ipv6_gateway != NULL &&
 312                         g_strcmp0(data->ipv6_gateway->gateway,
 313                                                         "::") == 0) {
 314                 if (connman_inet_set_ipv6_gateway_interface(index) < 0)
 315                         return;
 316                 goto done;
 317         }
 318
 319         if (do_ipv6 == TRUE && data->ipv6_gateway != NULL)
 320                 status6 = connman_inet_set_ipv6_gateway_address(index,
 321                                                 data->ipv6_gateway->gateway);
 322
 323         if (do_ipv4 == TRUE && data->ipv4_gateway != NULL)
 324                 status4 = connman_inet_set_gateway_address(index,
 325                                                 data->ipv4_gateway->gateway);
 326
 327         if (status4 < 0 || status6 < 0)
 328                 return;
 329
 330 done:
 331         __connman_service_indicate_default(data->service);
 332 }
 333
 334 static void unset_default_gateway(struct gateway_data *data,
 335                                 enum connman_ipconfig_type type)
 336 {
 337         int index;
 338         int do_ipv4 = FALSE, do_ipv6 = FALSE;
 339
 340         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
 341                 do_ipv4 = TRUE;
 342         else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
 343                 do_ipv6 = TRUE;
 344         else
 345                 do_ipv4 = do_ipv6 = TRUE;
 346
 347         DBG("type %d gateway ipv4 %p ipv6 %p", type, data->ipv4_gateway,
 348                                                 data->ipv6_gateway);
 349
 350         if (do_ipv4 == TRUE && data->ipv4_gateway != NULL &&
 351                                         data->ipv4_gateway->vpn == TRUE) {
 352                 connman_inet_del_host_route(data->index,
 353                                                 data->ipv4_gateway->vpn_ip);
 354                 connman_inet_clear_gateway_address(data->index,
 355                                                 data->ipv4_gateway->vpn_ip);
 356                 data->ipv4_gateway->active = FALSE;
 357
 358                 return;
 359         }
 360
 361         if (do_ipv6 == TRUE && data->ipv6_gateway != NULL &&
 362                                         data->ipv6_gateway->vpn == TRUE) {
 363                 connman_inet_del_ipv6_host_route(data->index,
 364                                                 data->ipv6_gateway->vpn_ip);
 365                 connman_inet_clear_ipv6_gateway_address(data->index,
 366                                                 data->ipv6_gateway->vpn_ip);
 367                 data->ipv6_gateway->active = FALSE;
 368
 369                 return;
 370         }
 371
 372         index = __connman_service_get_index(data->service);
 373
 374         if (do_ipv4 == TRUE && data->ipv4_gateway != NULL &&
 375                         g_strcmp0(data->ipv4_gateway->gateway,
 376                                                         "0.0.0.0") == 0) {
 377                 connman_inet_clear_gateway_interface(index);
 378                 return;
 379         }
 380
 381         if (do_ipv6 == TRUE && data->ipv6_gateway != NULL &&
 382                         g_strcmp0(data->ipv6_gateway->gateway,
 383                                                         "::") == 0) {
 384                 connman_inet_clear_ipv6_gateway_interface(index);
 385                 return;
 386         }
 387
 388         if (do_ipv6 == TRUE && data->ipv6_gateway != NULL)
 389                 connman_inet_clear_ipv6_gateway_address(index,
 390                                                 data->ipv6_gateway->gateway);
 391
 392         if (do_ipv4 == TRUE && data->ipv4_gateway != NULL)
 393                 connman_inet_clear_gateway_address(index,
 394                                                 data->ipv4_gateway->gateway);
 395 }
 396
 397 static struct gateway_data *find_default_gateway(void)
 398 {
 399         struct gateway_data *found = NULL;
 400         unsigned int order = 0;
 401         GHashTableIter iter;
 402         gpointer value, key;
 403
 404         g_hash_table_iter_init(&iter, gateway_hash);
 405
 406         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 407                 struct gateway_data *data = value;
 408
 409                 if (found == NULL || data->order > order) {
 410                         found = data;
 411                         order = data->order;
 412                 }
 413         }
 414
 415         return found;
 416 }
 417
 418 static void remove_gateway(gpointer user_data)
 419 {
 420         struct gateway_data *data = user_data;
 421
 422         DBG("gateway ipv4 %p ipv6 %p", data->ipv4_gateway, data->ipv6_gateway);
 423
 424         if (data->ipv4_gateway != NULL) {
 425                 g_free(data->ipv4_gateway->gateway);
 426                 g_free(data->ipv4_gateway->vpn_ip);
 427                 g_free(data->ipv4_gateway->vpn_phy_ip);
 428                 g_free(data->ipv4_gateway);
 429         }
 430
 431         if (data->ipv6_gateway != NULL) {
 432                 g_free(data->ipv6_gateway->gateway);
 433                 g_free(data->ipv6_gateway->vpn_ip);
 434                 g_free(data->ipv6_gateway->vpn_phy_ip);
 435                 g_free(data->ipv6_gateway);
 436         }
 437
 438         g_free(data);
 439 }
 440
 441 static void connection_delgateway(int index, const char *gateway)
 442 {
 443         struct gateway_config *config;
 444         struct gateway_data *data;
 445
 446         DBG("index %d gateway %s", index, gateway);
 447
 448         config = find_gateway(index, gateway);
 449         if (config != NULL)
 450                 config->active = FALSE;
 451
 452         data = find_default_gateway();
 453         if (data != NULL)
 454                 set_default_gateway(data, CONNMAN_IPCONFIG_TYPE_ALL);
 455 }
 456
 457 static struct connman_rtnl connection_rtnl = {
 458         .name           = "connection",
 459         .newgateway     = connection_newgateway,
 460         .delgateway     = connection_delgateway,
 461 };
 462
 463 static struct gateway_data *find_active_gateway(void)
 464 {
 465         GHashTableIter iter;
 466         gpointer value, key;
 467
 468         DBG("");
 469
 470         g_hash_table_iter_init(&iter, gateway_hash);
 471
 472         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 473                 struct gateway_data *data = value;
 474
 475                 if (data->ipv4_gateway != NULL &&
 476                                 data->ipv4_gateway->active == TRUE)
 477                         return data;
 478
 479                 if (data->ipv6_gateway != NULL &&
 480                                 data->ipv6_gateway->active == TRUE)
 481                         return data;
 482         }
 483
 484         return NULL;
 485 }
 486
 487 static void update_order(void)
 488 {
 489         GHashTableIter iter;
 490         gpointer value, key;
 491
 492         DBG("");
 493
 494         g_hash_table_iter_init(&iter, gateway_hash);
 495
 496         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 497                 struct gateway_data *data = value;
 498
 499                 data->order = __connman_service_get_order(data->service);
 500         }
 501 }
 502
 503 void __connman_connection_gateway_activate(struct connman_service *service,
 504                                         enum connman_ipconfig_type type)
 505 {
 506         struct gateway_data *data = NULL;
 507
 508         data = g_hash_table_lookup(gateway_hash, service);
 509         if (data == NULL)
 510                 return;
 511
 512         DBG("gateway %p/%p type %d", data->ipv4_gateway,
 513                                         data->ipv6_gateway, type);
 514
 515         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
 516                 data->ipv4_gateway->active = TRUE;
 517         else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
 518                 data->ipv6_gateway->active = TRUE;
 519 }
 520
 521 int __connman_connection_gateway_add(struct connman_service *service,
 522                                         const char *gateway,
 523                                         enum connman_ipconfig_type type,
 524                                         const char *peer)
 525 {
 526         struct gateway_data *active_gateway = NULL;
 527         struct gateway_data *new_gateway = NULL;
 528         int index;
 529
 530         index = __connman_service_get_index(service);
 531
 532         DBG("service %p index %d gateway %s vpn ip %s type %d",
 533                 service, index, gateway, peer, type);
 534
 535         /*
 536          * If gateway is NULL, it's a point to point link and the default
 537          * gateway for ipv4 is 0.0.0.0 and for ipv6 is ::, meaning the
 538          * interface
 539          */
 540         if (gateway == NULL && type == CONNMAN_IPCONFIG_TYPE_IPV4)
 541                 gateway = "0.0.0.0";
 542
 543         if (gateway == NULL && type == CONNMAN_IPCONFIG_TYPE_IPV6)
 544                 gateway = "::";
 545
 546         active_gateway = find_active_gateway();
 547         new_gateway = add_gateway(service, index, gateway, type);
 548         if (new_gateway == NULL)
 549                 return -EINVAL;
 550
 551         if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
 552                         new_gateway->ipv6_gateway != NULL &&
 553                         g_strcmp0(new_gateway->ipv6_gateway->gateway,
 554                                                                 "::") != 0)
 555                 connman_inet_add_ipv6_host_route(index,
 556                                         new_gateway->ipv6_gateway->gateway,
 557                                         NULL);
 558
 559         if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
 560                         new_gateway->ipv4_gateway != NULL &&
 561                         g_strcmp0(new_gateway->ipv4_gateway->gateway,
 562                                                         "0.0.0.0") != 0)
 563                 connman_inet_add_host_route(index,
 564                                         new_gateway->ipv4_gateway->gateway,
 565                                         NULL);
 566
 567         if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
 568                                 new_gateway->ipv4_gateway != NULL) {
 569                 __connman_service_nameserver_add_routes(service,
 570                                         new_gateway->ipv4_gateway->gateway);
 571                 __connman_service_ipconfig_indicate_state(service,
 572                                                 CONNMAN_SERVICE_STATE_READY,
 573                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
 574         }
 575
 576         if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
 577                                 new_gateway->ipv6_gateway != NULL) {
 578                 __connman_service_nameserver_add_routes(service,
 579                                         new_gateway->ipv6_gateway->gateway);
 580                 __connman_service_ipconfig_indicate_state(service,
 581                                                 CONNMAN_SERVICE_STATE_READY,
 582                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
 583         }
 584
 585         if (connman_service_get_type(service) == CONNMAN_SERVICE_TYPE_VPN) {
 586                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
 587                                         new_gateway->ipv4_gateway != NULL) {
 588                         new_gateway->ipv4_gateway->vpn = TRUE;
 589                         if (peer != NULL)
 590                                 new_gateway->ipv4_gateway->vpn_ip =
 591                                                         g_strdup(peer);
 592                         else if (gateway != NULL)
 593                                 new_gateway->ipv4_gateway->vpn_ip =
 594                                                         g_strdup(gateway);
 595                         if (active_gateway) {
 596                                 const char *new_ipv4_gateway;
 597
 598                                 new_ipv4_gateway =
 599                                         active_gateway->ipv4_gateway->gateway;
 600                                 if (new_ipv4_gateway != NULL &&
 601                                          g_strcmp0(new_ipv4_gateway,
 602                                                         "0.0.0.0") != 0)
 603                                         new_gateway->ipv4_gateway->vpn_phy_ip =
 604                                                 g_strdup(new_ipv4_gateway);
 605
 606                                 new_gateway->ipv4_gateway->vpn_phy_index =
 607                                                         active_gateway->index;
 608                         }
 609
 610                 } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
 611                                         new_gateway->ipv6_gateway != NULL) {
 612                         new_gateway->ipv6_gateway->vpn = TRUE;
 613                         if (peer != NULL)
 614                                 new_gateway->ipv6_gateway->vpn_ip =
 615                                                         g_strdup(peer);
 616                         else if (gateway != NULL)
 617                                 new_gateway->ipv6_gateway->vpn_ip =
 618                                                         g_strdup(gateway);
 619                         if (active_gateway) {
 620                                 const char *new_ipv6_gateway;
 621
 622                                 new_ipv6_gateway =
 623                                         active_gateway->ipv6_gateway->gateway;
 624                                 if (new_ipv6_gateway != NULL &&
 625                                         g_strcmp0(new_ipv6_gateway, "::") != 0)
 626                                         new_gateway->ipv6_gateway->vpn_phy_ip =
 627                                                 g_strdup(new_ipv6_gateway);
 628
 629                                 new_gateway->ipv6_gateway->vpn_phy_index =
 630                                                         active_gateway->index;
 631                         }
 632                 }
 633         } else {
 634                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
 635                                         new_gateway->ipv4_gateway != NULL)
 636                         new_gateway->ipv4_gateway->vpn = FALSE;
 637
 638                 if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
 639                                         new_gateway->ipv6_gateway != NULL)
 640                         new_gateway->ipv6_gateway->vpn = FALSE;
 641         }
 642
 643         if (active_gateway == NULL) {
 644                 set_default_gateway(new_gateway, type);
 645                 return 0;
 646         }
 647
 648         if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
 649                                 new_gateway->ipv4_gateway != NULL &&
 650                                 new_gateway->ipv4_gateway->vpn == TRUE) {
 651                 connman_inet_add_host_route(active_gateway->index,
 652                                         new_gateway->ipv4_gateway->gateway,
 653                                         active_gateway->ipv4_gateway->gateway);
 654                 connman_inet_clear_gateway_address(active_gateway->index,
 655                                         active_gateway->ipv4_gateway->gateway);
 656         }
 657
 658         if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
 659                                 new_gateway->ipv6_gateway != NULL &&
 660                                 new_gateway->ipv6_gateway->vpn == TRUE) {
 661                 connman_inet_add_ipv6_host_route(active_gateway->index,
 662                                         new_gateway->ipv6_gateway->gateway,
 663                                         active_gateway->ipv6_gateway->gateway);
 664                 connman_inet_clear_ipv6_gateway_address(active_gateway->index,
 665                                         active_gateway->ipv6_gateway->gateway);
 666         }
 667
 668         return 0;
 669 }
 670
 671 void __connman_connection_gateway_remove(struct connman_service *service,
 672                                         enum connman_ipconfig_type type)
 673 {
 674         struct gateway_data *data = NULL;
 675         gboolean set_default4 = FALSE, set_default6 = FALSE;
 676         int do_ipv4 = FALSE, do_ipv6 = FALSE;
 677         int err;
 678
 679         DBG("service %p type %d", service, type);
 680
 681         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
 682                 do_ipv4 = TRUE;
 683         else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
 684                 do_ipv6 = TRUE;
 685         else
 686                 do_ipv4 = do_ipv6 = TRUE;
 687
 688         __connman_service_nameserver_del_routes(service);
 689
 690         data = g_hash_table_lookup(gateway_hash, service);
 691         if (data == NULL)
 692                 return;
 693
 694         if (do_ipv4 == TRUE && data->ipv4_gateway != NULL)
 695                 set_default4 = data->ipv4_gateway->vpn;
 696
 697         if (do_ipv6 == TRUE && data->ipv6_gateway != NULL)
 698                 set_default6 = data->ipv6_gateway->vpn;
 699
 700         DBG("ipv4 gateway %s ipv6 gateway %s vpn %d/%d",
 701                 data->ipv4_gateway ? data->ipv4_gateway->gateway : "<null>",
 702                 data->ipv6_gateway ? data->ipv6_gateway->gateway : "<null>",
 703                 set_default4, set_default6);
 704
 705         if (do_ipv4 == TRUE && data->ipv4_gateway != NULL &&
 706                         data->ipv4_gateway->vpn == TRUE && data->index >= 0)
 707                 connman_inet_del_host_route(data->index,
 708                                                 data->ipv4_gateway->gateway);
 709
 710         if (do_ipv6 == TRUE && data->ipv6_gateway != NULL &&
 711                         data->ipv6_gateway->vpn == TRUE && data->index >= 0)
 712                 connman_inet_del_ipv6_host_route(data->index,
 713                                                 data->ipv6_gateway->gateway);
 714
 715         __connman_service_nameserver_del_routes(service);
 716
 717         err = disable_gateway(data, type);
 718
 719         /*
 720          * We remove the service from the hash only if all the gateway
 721          * settings are to be removed.
 722          */
 723         if (do_ipv4 == do_ipv6 ||
 724                 (data->ipv4_gateway != NULL && data->ipv6_gateway == NULL
 725                         && do_ipv4 == TRUE) ||
 726                 (data->ipv6_gateway != NULL && data->ipv4_gateway == NULL
 727                         && do_ipv6 == TRUE)
 728                 ) {
 729                 connman_service_unref(service);
 730                 g_hash_table_remove(gateway_hash, service);
 731         } else
 732                 DBG("Not yet removing gw ipv4 %p/%d ipv6 %p/%d",
 733                         data->ipv4_gateway, do_ipv4,
 734                         data->ipv6_gateway, do_ipv6);
 735
 736         /* with vpn this will be called after the network was deleted,
 737          * we need to call set_default here because we will not recieve any
 738          * gateway delete notification.
 739          * We hit the same issue if remove_gateway() fails.
 740          */
 741         if (set_default4 || set_default6 || err < 0) {
 742                 data = find_default_gateway();
 743                 if (data != NULL)
 744                         set_default_gateway(data, type);
 745         }
 746 }
 747
 748 gboolean __connman_connection_update_gateway(void)
 749 {
 750         struct gateway_data *active_gateway, *default_gateway;
 751         gboolean updated = FALSE;
 752
 753         if (gateway_hash == NULL)
 754                 return updated;
 755
 756         active_gateway = find_active_gateway();
 757
 758         update_order();
 759
 760         default_gateway = find_default_gateway();
 761
 762         if (active_gateway && active_gateway != default_gateway) {
 763                 updated = TRUE;
 764
 765                 if (active_gateway->ipv4_gateway)
 766                         unset_default_gateway(active_gateway,
 767                                         CONNMAN_IPCONFIG_TYPE_IPV4);
 768
 769                 if (active_gateway->ipv6_gateway)
 770                         unset_default_gateway(active_gateway,
 771                                         CONNMAN_IPCONFIG_TYPE_IPV6);
 772
 773                 if (default_gateway) {
 774                         if (default_gateway->ipv4_gateway)
 775                                 set_default_gateway(default_gateway,
 776                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
 777
 778                         if (default_gateway->ipv6_gateway)
 779                                 set_default_gateway(default_gateway,
 780                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
 781                 }
 782         }
 783
 784         return updated;
 785 }
 786
 787 int __connman_connection_init(void)
 788 {
 789         int err;
 790
 791         DBG("");
 792
 793         gateway_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
 794                                                         NULL, remove_gateway);
 795
 796         err = connman_rtnl_register(&connection_rtnl);
 797         if (err < 0)
 798                 connman_error("Failed to setup RTNL gateway driver");
 799
 800         return err;
 801 }
 802
 803 void __connman_connection_cleanup(void)
 804 {
 805         GHashTableIter iter;
 806         gpointer value, key;
 807
 808         DBG("");
 809
 810         connman_rtnl_unregister(&connection_rtnl);
 811
 812         g_hash_table_iter_init(&iter, gateway_hash);
 813
 814         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 815                 struct gateway_data *data = value;
 816
 817                 disable_gateway(data, CONNMAN_IPCONFIG_TYPE_ALL);
 818         }
 819
 820         g_hash_table_destroy(gateway_hash);
 821         gateway_hash = NULL;
 822 }