vpn/vpn-provider.c

   1 /*
   2  *
   3  *  ConnMan VPN daemon
   4  *
   5  *  Copyright (C) 2012-2013  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 <errno.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <gdbus.h>
  31 #include <connman/log.h>
  32 #include <gweb/gresolv.h>
  33 #include <netdb.h>
  34
  35 #include "../src/connman.h"
  36 #include "connman/agent.h"
  37 #include "connman/vpn-dbus.h"
  38 #include "vpn-provider.h"
  39 #include "vpn.h"
  40 #include "plugins/vpn.h"
  41
  42 static DBusConnection *connection;
  43 static GHashTable *provider_hash;
  44 static GSList *driver_list;
  45 static int configuration_count;
  46 static bool handle_routes;
  47
  48 struct vpn_route {
  49         int family;
  50         char *network;
  51         char *netmask;
  52         char *gateway;
  53 };
  54
  55 struct vpn_setting {
  56         bool hide_value;
  57         bool immutable;
  58         char *value;
  59 };
  60
  61 struct vpn_provider {
  62         int refcount;
  63         int index;
  64         int fd;
  65         enum vpn_provider_state state;
  66         char *path;
  67         char *identifier;
  68         char *name;
  69         char *type;
  70         char *host;
  71         char *domain;
  72         int family;
  73         GHashTable *routes;
  74         struct vpn_provider_driver *driver;
  75         void *driver_data;
  76         GHashTable *setting_strings;
  77         GHashTable *user_routes;
  78         GSList *user_networks;
  79         GResolv *resolv;
  80         char **host_ip;
  81         struct vpn_ipconfig *ipconfig_ipv4;
  82         struct vpn_ipconfig *ipconfig_ipv6;
  83         char **nameservers;
  84         guint notify_id;
  85         char *config_file;
  86         char *config_entry;
  87         bool immutable;
  88         struct connman_ipaddress *prev_ipv4_addr;
  89         struct connman_ipaddress *prev_ipv6_addr;
  90 };
  91
  92 static void append_properties(DBusMessageIter *iter,
  93                                 struct vpn_provider *provider);
  94
  95 static void free_route(gpointer data)
  96 {
  97         struct vpn_route *route = data;
  98
  99         g_free(route->network);
 100         g_free(route->netmask);
 101         g_free(route->gateway);
 102
 103         g_free(route);
 104 }
 105
 106 static void free_setting(gpointer data)
 107 {
 108         struct vpn_setting *setting = data;
 109
 110         g_free(setting->value);
 111         g_free(setting);
 112 }
 113
 114 static void append_route(DBusMessageIter *iter, void *user_data)
 115 {
 116         struct vpn_route *route = user_data;
 117         DBusMessageIter item;
 118         int family = 0;
 119
 120         connman_dbus_dict_open(iter, &item);
 121
 122         if (!route)
 123                 goto empty_dict;
 124
 125         if (route->family == AF_INET)
 126                 family = 4;
 127         else if (route->family == AF_INET6)
 128                 family = 6;
 129
 130         if (family != 0)
 131                 connman_dbus_dict_append_basic(&item, "ProtocolFamily",
 132                                         DBUS_TYPE_INT32, &family);
 133
 134         if (route->network)
 135                 connman_dbus_dict_append_basic(&item, "Network",
 136                                         DBUS_TYPE_STRING, &route->network);
 137
 138         if (route->netmask)
 139                 connman_dbus_dict_append_basic(&item, "Netmask",
 140                                         DBUS_TYPE_STRING, &route->netmask);
 141
 142         if (route->gateway)
 143                 connman_dbus_dict_append_basic(&item, "Gateway",
 144                                         DBUS_TYPE_STRING, &route->gateway);
 145
 146 empty_dict:
 147         connman_dbus_dict_close(iter, &item);
 148 }
 149
 150 static void append_routes(DBusMessageIter *iter, void *user_data)
 151 {
 152         GHashTable *routes = user_data;
 153         GHashTableIter hash;
 154         gpointer value, key;
 155
 156         if (!routes) {
 157                 append_route(iter, NULL);
 158                 return;
 159         }
 160
 161         g_hash_table_iter_init(&hash, routes);
 162
 163         while (g_hash_table_iter_next(&hash, &key, &value)) {
 164                 DBusMessageIter dict;
 165
 166                 dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL,
 167                                                 &dict);
 168                 append_route(&dict, value);
 169                 dbus_message_iter_close_container(iter, &dict);
 170         }
 171 }
 172
 173 static void send_routes(struct vpn_provider *provider, GHashTable *routes,
 174                         const char *name)
 175 {
 176         connman_dbus_property_changed_array(provider->path,
 177                                         VPN_CONNECTION_INTERFACE,
 178                                         name,
 179                                         DBUS_TYPE_DICT_ENTRY,
 180                                         append_routes,
 181                                         routes);
 182 }
 183
 184 static int provider_routes_changed(struct vpn_provider *provider)
 185 {
 186         DBG("provider %p", provider);
 187
 188         send_routes(provider, provider->routes, "ServerRoutes");
 189
 190         return 0;
 191 }
 192
 193 static GSList *read_route_dict(GSList *routes, DBusMessageIter *dicts)
 194 {
 195         DBusMessageIter dict, value, entry;
 196         const char *network, *netmask, *gateway;
 197         struct vpn_route *route;
 198         int family, type;
 199         const char *key;
 200
 201         dbus_message_iter_recurse(dicts, &entry);
 202
 203         network = netmask = gateway = NULL;
 204         family = PF_UNSPEC;
 205
 206         while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_DICT_ENTRY) {
 207
 208                 dbus_message_iter_recurse(&entry, &dict);
 209                 dbus_message_iter_get_basic(&dict, &key);
 210
 211                 dbus_message_iter_next(&dict);
 212                 dbus_message_iter_recurse(&dict, &value);
 213
 214                 type = dbus_message_iter_get_arg_type(&value);
 215
 216                 switch (type) {
 217                 case DBUS_TYPE_INT32:
 218                         if (g_str_equal(key, "ProtocolFamily"))
 219                                 dbus_message_iter_get_basic(&value, &family);
 220                         break;
 221
 222                 case DBUS_TYPE_STRING:
 223                         if (g_str_equal(key, "Network"))
 224                                 dbus_message_iter_get_basic(&value, &network);
 225                         else if (g_str_equal(key, "Netmask"))
 226                                 dbus_message_iter_get_basic(&value, &netmask);
 227                         else if (g_str_equal(key, "Gateway"))
 228                                 dbus_message_iter_get_basic(&value, &gateway);
 229                         break;
 230                 }
 231
 232                 dbus_message_iter_next(&entry);
 233         }
 234
 235         DBG("family %d network %s netmask %s gateway %s", family,
 236                 network, netmask, gateway);
 237
 238         if (!network || !netmask) {
 239                 DBG("Ignoring route as network/netmask is missing");
 240                 return routes;
 241         }
 242
 243         route = g_try_new(struct vpn_route, 1);
 244         if (!route) {
 245                 g_slist_free_full(routes, free_route);
 246                 return NULL;
 247         }
 248
 249         if (family == PF_UNSPEC) {
 250                 family = connman_inet_check_ipaddress(network);
 251                 if (family < 0) {
 252                         DBG("Cannot get address family of %s (%d/%s)", network,
 253                                 family, gai_strerror(family));
 254
 255                         g_free(route);
 256                         return routes;
 257                 }
 258         } else {
 259                 switch (family) {
 260                 case '4':
 261                         family = AF_INET;
 262                         break;
 263                 case '6':
 264                         family = AF_INET6;
 265                         break;
 266                 default:
 267                         family = PF_UNSPEC;
 268                         break;
 269                 }
 270         }
 271
 272         route->family = family;
 273         route->network = g_strdup(network);
 274         route->netmask = g_strdup(netmask);
 275         route->gateway = g_strdup(gateway);
 276
 277         routes = g_slist_prepend(routes, route);
 278         return routes;
 279 }
 280
 281 static GSList *get_user_networks(DBusMessageIter *array)
 282 {
 283         DBusMessageIter entry;
 284         GSList *list = NULL;
 285
 286         while (dbus_message_iter_get_arg_type(array) == DBUS_TYPE_ARRAY) {
 287
 288                 dbus_message_iter_recurse(array, &entry);
 289
 290                 while (dbus_message_iter_get_arg_type(&entry) ==
 291                                                         DBUS_TYPE_STRUCT) {
 292                         DBusMessageIter dicts;
 293
 294                         dbus_message_iter_recurse(&entry, &dicts);
 295
 296                         while (dbus_message_iter_get_arg_type(&dicts) ==
 297                                                         DBUS_TYPE_ARRAY) {
 298
 299                                 list = read_route_dict(list, &dicts);
 300                                 dbus_message_iter_next(&dicts);
 301                         }
 302
 303                         dbus_message_iter_next(&entry);
 304                 }
 305
 306                 dbus_message_iter_next(array);
 307         }
 308
 309         return list;
 310 }
 311
 312 static void set_user_networks(struct vpn_provider *provider, GSList *networks)
 313 {
 314         GSList *list;
 315
 316         for (list = networks; list; list = g_slist_next(list)) {
 317                 struct vpn_route *route = list->data;
 318
 319                 if (__vpn_provider_append_user_route(provider,
 320                                         route->family, route->network,
 321                                         route->netmask, route->gateway) != 0)
 322                         break;
 323         }
 324 }
 325
 326 static void del_routes(struct vpn_provider *provider)
 327 {
 328         GHashTableIter hash;
 329         gpointer value, key;
 330
 331         g_hash_table_iter_init(&hash, provider->user_routes);
 332         while (handle_routes && g_hash_table_iter_next(&hash,
 333                                                 &key, &value)) {
 334                 struct vpn_route *route = value;
 335                 if (route->family == AF_INET6) {
 336                         unsigned char prefixlen = atoi(route->netmask);
 337                         connman_inet_del_ipv6_network_route(provider->index,
 338                                                         route->network,
 339                                                         prefixlen);
 340                 } else
 341                         connman_inet_del_host_route(provider->index,
 342                                                 route->network);
 343         }
 344
 345         g_hash_table_remove_all(provider->user_routes);
 346         g_slist_free_full(provider->user_networks, free_route);
 347         provider->user_networks = NULL;
 348 }
 349
 350 static void send_value(const char *path, const char *key, const char *value)
 351 {
 352         const char *empty = "";
 353         const char *str;
 354
 355         if (value)
 356                 str = value;
 357         else
 358                 str = empty;
 359
 360         connman_dbus_property_changed_basic(path,
 361                                         VPN_CONNECTION_INTERFACE,
 362                                         key,
 363                                         DBUS_TYPE_STRING,
 364                                         &str);
 365 }
 366
 367 static gboolean provider_send_changed(gpointer data)
 368 {
 369         struct vpn_provider *provider = data;
 370
 371         provider_routes_changed(provider);
 372
 373         provider->notify_id = 0;
 374
 375         return FALSE;
 376 }
 377
 378 static void provider_schedule_changed(struct vpn_provider *provider)
 379 {
 380         if (provider->notify_id != 0)
 381                 g_source_remove(provider->notify_id);
 382
 383         provider->notify_id = g_timeout_add(100, provider_send_changed,
 384                                                                 provider);
 385 }
 386
 387 static DBusMessage *get_properties(DBusConnection *conn,
 388                                         DBusMessage *msg, void *data)
 389 {
 390         struct vpn_provider *provider = data;
 391         DBusMessage *reply;
 392         DBusMessageIter array;
 393
 394         DBG("provider %p", provider);
 395
 396         reply = dbus_message_new_method_return(msg);
 397         if (!reply)
 398                 return NULL;
 399
 400         dbus_message_iter_init_append(reply, &array);
 401
 402         append_properties(&array, provider);
 403
 404         return reply;
 405 }
 406
 407 static DBusMessage *set_property(DBusConnection *conn, DBusMessage *msg,
 408                                                                 void *data)
 409 {
 410         struct vpn_provider *provider = data;
 411         DBusMessageIter iter, value;
 412         const char *name;
 413         int type;
 414
 415         DBG("conn %p", conn);
 416
 417         if (provider->immutable)
 418                 return __connman_error_not_supported(msg);
 419
 420         if (!dbus_message_iter_init(msg, &iter))
 421                 return __connman_error_invalid_arguments(msg);
 422
 423         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
 424                 return __connman_error_invalid_arguments(msg);
 425
 426         dbus_message_iter_get_basic(&iter, &name);
 427         dbus_message_iter_next(&iter);
 428
 429         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
 430                 return __connman_error_invalid_arguments(msg);
 431
 432         dbus_message_iter_recurse(&iter, &value);
 433
 434         type = dbus_message_iter_get_arg_type(&value);
 435
 436         if (g_str_equal(name, "UserRoutes")) {
 437                 GSList *networks;
 438
 439                 if (type != DBUS_TYPE_ARRAY)
 440                         return __connman_error_invalid_arguments(msg);
 441
 442                 networks = get_user_networks(&value);
 443                 if (networks) {
 444                         del_routes(provider);
 445                         provider->user_networks = networks;
 446                         set_user_networks(provider, provider->user_networks);
 447
 448                         if (!handle_routes)
 449                                 send_routes(provider, provider->user_routes,
 450                                                                 "UserRoutes");
 451                 }
 452         } else {
 453                 const char *str;
 454
 455                 dbus_message_iter_get_basic(&value, &str);
 456                 vpn_provider_set_string(provider, name, str);
 457         }
 458
 459         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 460 }
 461
 462 static DBusMessage *clear_property(DBusConnection *conn, DBusMessage *msg,
 463                                                                 void *data)
 464 {
 465         struct vpn_provider *provider = data;
 466         const char *name;
 467
 468         DBG("conn %p", conn);
 469
 470         if (provider->immutable)
 471                 return __connman_error_not_supported(msg);
 472
 473         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
 474                                                         DBUS_TYPE_INVALID);
 475
 476         if (g_str_equal(name, "UserRoutes")) {
 477                 del_routes(provider);
 478
 479                 if (!handle_routes)
 480                         send_routes(provider, provider->user_routes, name);
 481         } else if (vpn_provider_get_string(provider, name)) {
 482                 vpn_provider_set_string(provider, name, NULL);
 483         } else {
 484                 return __connman_error_invalid_property(msg);
 485         }
 486
 487         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 488 }
 489
 490 static DBusMessage *do_connect(DBusConnection *conn, DBusMessage *msg,
 491                                                                 void *data)
 492 {
 493         struct vpn_provider *provider = data;
 494         int err;
 495
 496         DBG("conn %p provider %p", conn, provider);
 497
 498         err = __vpn_provider_connect(provider, msg);
 499         if (err < 0)
 500                 return __connman_error_failed(msg, -err);
 501
 502         return NULL;
 503 }
 504
 505 static DBusMessage *do_connect2(DBusConnection *conn, DBusMessage *msg,
 506                                                                 void *data)
 507 {
 508         return do_connect(conn, msg, data);
 509 }
 510
 511 static DBusMessage *do_disconnect(DBusConnection *conn, DBusMessage *msg,
 512                                                                 void *data)
 513 {
 514         struct vpn_provider *provider = data;
 515         int err;
 516
 517         DBG("conn %p provider %p", conn, provider);
 518
 519         err = __vpn_provider_disconnect(provider);
 520         if (err < 0 && err != -EINPROGRESS)
 521                 return __connman_error_failed(msg, -err);
 522
 523         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 524 }
 525
 526 static const GDBusMethodTable connection_methods[] = {
 527         { GDBUS_METHOD("GetProperties",
 528                         NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
 529                         get_properties) },
 530         { GDBUS_METHOD("SetProperty",
 531                         GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
 532                         NULL, set_property) },
 533         { GDBUS_METHOD("ClearProperty",
 534                         GDBUS_ARGS({ "name", "s" }), NULL,
 535                         clear_property) },
 536         { GDBUS_ASYNC_METHOD("Connect", NULL, NULL, do_connect) },
 537         { GDBUS_ASYNC_METHOD("Connect2",
 538                         GDBUS_ARGS({ "dbus_sender", "s" }),
 539                         NULL, do_connect2) },
 540         { GDBUS_METHOD("Disconnect", NULL, NULL, do_disconnect) },
 541         { },
 542 };
 543
 544 static const GDBusSignalTable connection_signals[] = {
 545         { GDBUS_SIGNAL("PropertyChanged",
 546                         GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
 547         { },
 548 };
 549
 550 static void resolv_result(GResolvResultStatus status,
 551                                         char **results, gpointer user_data)
 552 {
 553         struct vpn_provider *provider = user_data;
 554
 555         DBG("status %d", status);
 556
 557         if (status == G_RESOLV_RESULT_STATUS_SUCCESS && results &&
 558                                                 g_strv_length(results) > 0)
 559                 provider->host_ip = g_strdupv(results);
 560
 561         vpn_provider_unref(provider);
 562
 563         /* Remove the resolver here so that it will not be left
 564          * hanging around and cause double free in unregister_provider()
 565          */
 566         g_resolv_unref(provider->resolv);
 567         provider->resolv = NULL;
 568 }
 569
 570 static void provider_resolv_host_addr(struct vpn_provider *provider)
 571 {
 572         if (!provider->host)
 573                 return;
 574
 575         if (connman_inet_check_ipaddress(provider->host) > 0)
 576                 return;
 577
 578         if (provider->host_ip)
 579                 return;
 580
 581         /*
 582          * If the hostname is not numeric, try to resolv it. We do not wait
 583          * the result as it might take some time. We will get the result
 584          * before VPN will feed routes to us because VPN client will need
 585          * the IP address also before VPN connection can be established.
 586          */
 587         provider->resolv = g_resolv_new(0);
 588         if (!provider->resolv) {
 589                 DBG("Cannot resolv %s", provider->host);
 590                 return;
 591         }
 592
 593         DBG("Trying to resolv %s", provider->host);
 594
 595         vpn_provider_ref(provider);
 596
 597         g_resolv_lookup_hostname(provider->resolv, provider->host,
 598                                 resolv_result, provider);
 599 }
 600
 601 void __vpn_provider_append_properties(struct vpn_provider *provider,
 602                                                         DBusMessageIter *iter)
 603 {
 604         if (provider->host)
 605                 connman_dbus_dict_append_basic(iter, "Host",
 606                                         DBUS_TYPE_STRING, &provider->host);
 607
 608         if (provider->domain)
 609                 connman_dbus_dict_append_basic(iter, "Domain",
 610                                         DBUS_TYPE_STRING, &provider->domain);
 611
 612         if (provider->type)
 613                 connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING,
 614                                                  &provider->type);
 615 }
 616
 617 int __vpn_provider_append_user_route(struct vpn_provider *provider,
 618                                 int family, const char *network,
 619                                 const char *netmask, const char *gateway)
 620 {
 621         struct vpn_route *route;
 622         char *key = g_strdup_printf("%d/%s/%s/%s", family, network,
 623                                 netmask, gateway ? gateway : "");
 624
 625         DBG("family %d network %s netmask %s gw %s", family, network,
 626                                                         netmask, gateway);
 627
 628         route = g_hash_table_lookup(provider->user_routes, key);
 629         if (!route) {
 630                 route = g_try_new0(struct vpn_route, 1);
 631                 if (!route) {
 632                         connman_error("out of memory");
 633                         return -ENOMEM;
 634                 }
 635
 636                 route->family = family;
 637                 route->network = g_strdup(network);
 638                 route->netmask = g_strdup(netmask);
 639                 route->gateway = g_strdup(gateway);
 640
 641                 g_hash_table_replace(provider->user_routes, key, route);
 642         } else
 643                 g_free(key);
 644
 645         return 0;
 646 }
 647
 648 static struct vpn_route *get_route(char *route_str)
 649 {
 650         char **elems = g_strsplit(route_str, "/", 0);
 651         char *network, *netmask, *gateway, *family_str;
 652         int family = PF_UNSPEC;
 653         struct vpn_route *route = NULL;
 654
 655         if (!elems)
 656                 return NULL;
 657
 658         family_str = elems[0];
 659
 660         network = elems[1];
 661         if (!network || network[0] == '\0')
 662                 goto out;
 663
 664         netmask = elems[2];
 665         if (!netmask || netmask[0] == '\0')
 666                 goto out;
 667
 668         gateway = elems[3];
 669
 670         route = g_try_new0(struct vpn_route, 1);
 671         if (!route)
 672                 goto out;
 673
 674         if (family_str[0] == '\0' || atoi(family_str) == 0) {
 675                 family = PF_UNSPEC;
 676         } else {
 677                 switch (family_str[0]) {
 678                 case '4':
 679                         family = AF_INET;
 680                         break;
 681                 case '6':
 682                         family = AF_INET6;
 683                         break;
 684                 }
 685         }
 686
 687         if (g_strrstr(network, ":")) {
 688                 if (family != PF_UNSPEC && family != AF_INET6)
 689                         DBG("You have IPv6 address but you have non IPv6 route");
 690         } else if (g_strrstr(network, ".")) {
 691                 if (family != PF_UNSPEC && family != AF_INET)
 692                         DBG("You have IPv4 address but you have non IPv4 route");
 693
 694                 if (!g_strrstr(netmask, ".")) {
 695                         /* We have netmask length */
 696                         in_addr_t addr;
 697                         struct in_addr netmask_in;
 698                         unsigned char prefix_len = 32;
 699                         char *ptr;
 700                         long int value = strtol(netmask, &ptr, 10);
 701
 702                         if (ptr != netmask && *ptr == '\0' && value <= 32)
 703                                 prefix_len = value;
 704
 705                         addr = 0xffffffff << (32 - prefix_len);
 706                         netmask_in.s_addr = htonl(addr);
 707                         netmask = inet_ntoa(netmask_in);
 708
 709                         DBG("network %s netmask %s", network, netmask);
 710                 }
 711         }
 712
 713         if (family == PF_UNSPEC) {
 714                 family = connman_inet_check_ipaddress(network);
 715                 if (family < 0 || family == PF_UNSPEC)
 716                         goto out;
 717         }
 718
 719         route->family = family;
 720         route->network = g_strdup(network);
 721         route->netmask = g_strdup(netmask);
 722         route->gateway = g_strdup(gateway);
 723
 724 out:
 725         g_strfreev(elems);
 726         return route;
 727 }
 728
 729 static GSList *get_routes(gchar **networks)
 730 {
 731         struct vpn_route *route;
 732         GSList *routes = NULL;
 733         int i;
 734
 735         for (i = 0; networks[i]; i++) {
 736                 route = get_route(networks[i]);
 737                 if (route)
 738                         routes = g_slist_prepend(routes, route);
 739         }
 740
 741         return routes;
 742 }
 743
 744 static int provider_load_from_keyfile(struct vpn_provider *provider,
 745                 GKeyFile *keyfile)
 746 {
 747         gsize idx = 0;
 748         gchar **settings;
 749         gchar *key, *value;
 750         gsize length, num_user_networks;
 751         gchar **networks = NULL;
 752
 753         settings = g_key_file_get_keys(keyfile, provider->identifier, &length,
 754                                 NULL);
 755         if (!settings) {
 756                 g_key_file_free(keyfile);
 757                 return -ENOENT;
 758         }
 759
 760         while (idx < length) {
 761                 key = settings[idx];
 762                 if (key) {
 763                         if (g_str_equal(key, "Networks")) {
 764                                 networks = __vpn_config_get_string_list(keyfile,
 765                                                 provider->identifier,
 766                                                 key,
 767                                                 &num_user_networks,
 768                                                 NULL);
 769                                 provider->user_networks = get_routes(networks);
 770
 771                         } else {
 772                                 value = __vpn_config_get_string(keyfile,
 773                                                         provider->identifier,
 774                                                         key, NULL);
 775                                 vpn_provider_set_string(provider, key,
 776                                                         value);
 777                                 g_free(value);
 778                         }
 779                 }
 780                 idx += 1;
 781         }
 782         g_strfreev(settings);
 783         g_strfreev(networks);
 784
 785         if (provider->user_networks)
 786                 set_user_networks(provider, provider->user_networks);
 787
 788         return 0;
 789 }
 790
 791
 792 static int vpn_provider_load(struct vpn_provider *provider)
 793 {
 794         GKeyFile *keyfile;
 795
 796         DBG("provider %p", provider);
 797
 798         keyfile = __connman_storage_load_provider(provider->identifier);
 799         if (!keyfile)
 800                 return -ENOENT;
 801
 802         provider_load_from_keyfile(provider, keyfile);
 803
 804         g_key_file_free(keyfile);
 805         return 0;
 806 }
 807
 808 static gchar **create_network_list(GSList *networks, gsize *count)
 809 {
 810         GSList *list;
 811         gchar **result = NULL;
 812         gchar **prev_result;
 813         unsigned int num_elems = 0;
 814
 815         for (list = networks; list; list = g_slist_next(list)) {
 816                 struct vpn_route *route = list->data;
 817                 int family;
 818
 819                 prev_result = result;
 820                 result = g_try_realloc(result,
 821                                 (num_elems + 1) * sizeof(gchar *));
 822                 if (!result) {
 823                         g_free(prev_result);
 824                         return NULL;
 825                 }
 826
 827                 switch (route->family) {
 828                 case AF_INET:
 829                         family = 4;
 830                         break;
 831                 case AF_INET6:
 832                         family = 6;
 833                         break;
 834                 default:
 835                         family = 0;
 836                         break;
 837                 }
 838
 839                 result[num_elems] = g_strdup_printf("%d/%s/%s/%s",
 840                                 family, route->network, route->netmask,
 841                                 !route->gateway ? "" : route->gateway);
 842
 843                 num_elems++;
 844         }
 845
 846         prev_result = result;
 847         result = g_try_realloc(result, (num_elems + 1) * sizeof(gchar *));
 848         if (!result) {
 849                 g_free(prev_result);
 850                 return NULL;
 851         }
 852
 853         result[num_elems] = NULL;
 854         *count = num_elems;
 855         return result;
 856 }
 857
 858 static int vpn_provider_save(struct vpn_provider *provider)
 859 {
 860         GKeyFile *keyfile;
 861
 862         DBG("provider %p immutable %s", provider,
 863                                         provider->immutable ? "yes" : "no");
 864
 865         if (provider->immutable) {
 866                 /*
 867                  * Do not save providers that are provisioned via .config
 868                  * file.
 869                  */
 870                 return -EPERM;
 871         }
 872
 873         keyfile = g_key_file_new();
 874         if (!keyfile)
 875                 return -ENOMEM;
 876
 877         g_key_file_set_string(keyfile, provider->identifier,
 878                         "Name", provider->name);
 879         g_key_file_set_string(keyfile, provider->identifier,
 880                         "Type", provider->type);
 881         g_key_file_set_string(keyfile, provider->identifier,
 882                         "Host", provider->host);
 883         g_key_file_set_string(keyfile, provider->identifier,
 884                         "VPN.Domain", provider->domain);
 885         if (provider->user_networks) {
 886                 gchar **networks;
 887                 gsize network_count;
 888
 889                 networks = create_network_list(provider->user_networks,
 890                                                         &network_count);
 891                 if (networks) {
 892                         g_key_file_set_string_list(keyfile,
 893                                                 provider->identifier,
 894                                                 "Networks",
 895                                                 (const gchar ** const)networks,
 896                                                 network_count);
 897                         g_strfreev(networks);
 898                 }
 899         }
 900
 901         if (provider->config_file && strlen(provider->config_file) > 0)
 902                 g_key_file_set_string(keyfile, provider->identifier,
 903                                 "Config.file", provider->config_file);
 904
 905         if (provider->config_entry &&
 906                                         strlen(provider->config_entry) > 0)
 907                 g_key_file_set_string(keyfile, provider->identifier,
 908                                 "Config.ident", provider->config_entry);
 909
 910         if (provider->driver && provider->driver->save)
 911                 provider->driver->save(provider, keyfile);
 912
 913         __connman_storage_save_provider(keyfile, provider->identifier);
 914         g_key_file_free(keyfile);
 915
 916         return 0;
 917 }
 918
 919 struct vpn_provider *__vpn_provider_lookup(const char *identifier)
 920 {
 921         struct vpn_provider *provider = NULL;
 922
 923         provider = g_hash_table_lookup(provider_hash, identifier);
 924
 925         return provider;
 926 }
 927
 928 static bool match_driver(struct vpn_provider *provider,
 929                                 struct vpn_provider_driver *driver)
 930 {
 931         if (g_strcmp0(driver->name, provider->type) == 0)
 932                 return true;
 933
 934         return false;
 935 }
 936
 937 static int provider_probe(struct vpn_provider *provider)
 938 {
 939         GSList *list;
 940
 941         DBG("provider %p driver %p name %s", provider, provider->driver,
 942                                                 provider->name);
 943
 944         if (provider->driver)
 945                 return -EALREADY;
 946
 947         for (list = driver_list; list; list = list->next) {
 948                 struct vpn_provider_driver *driver = list->data;
 949
 950                 if (!match_driver(provider, driver))
 951                         continue;
 952
 953                 DBG("driver %p name %s", driver, driver->name);
 954
 955                 if (driver->probe && driver->probe(provider) == 0) {
 956                         provider->driver = driver;
 957                         break;
 958                 }
 959         }
 960
 961         if (!provider->driver)
 962                 return -ENODEV;
 963
 964         return 0;
 965 }
 966
 967 static void provider_remove(struct vpn_provider *provider)
 968 {
 969         if (provider->driver) {
 970                 provider->driver->remove(provider);
 971                 provider->driver = NULL;
 972         }
 973 }
 974
 975 static int provider_register(struct vpn_provider *provider)
 976 {
 977         return provider_probe(provider);
 978 }
 979
 980 static void provider_unregister(struct vpn_provider *provider)
 981 {
 982         provider_remove(provider);
 983 }
 984
 985 struct vpn_provider *
 986 vpn_provider_ref_debug(struct vpn_provider *provider,
 987                         const char *file, int line, const char *caller)
 988 {
 989         DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount + 1,
 990                 file, line, caller);
 991
 992         __sync_fetch_and_add(&provider->refcount, 1);
 993
 994         return provider;
 995 }
 996
 997 static void provider_destruct(struct vpn_provider *provider)
 998 {
 999         DBG("provider %p", provider);
1000
1001         if (provider->notify_id != 0)
1002                 g_source_remove(provider->notify_id);
1003
1004         g_free(provider->name);
1005         g_free(provider->type);
1006         g_free(provider->host);
1007         g_free(provider->domain);
1008         g_free(provider->identifier);
1009         g_free(provider->path);
1010         g_slist_free_full(provider->user_networks, free_route);
1011         g_strfreev(provider->nameservers);
1012         g_hash_table_destroy(provider->routes);
1013         g_hash_table_destroy(provider->user_routes);
1014         g_hash_table_destroy(provider->setting_strings);
1015         if (provider->resolv) {
1016                 g_resolv_unref(provider->resolv);
1017                 provider->resolv = NULL;
1018         }
1019         __vpn_ipconfig_unref(provider->ipconfig_ipv4);
1020         __vpn_ipconfig_unref(provider->ipconfig_ipv6);
1021
1022         g_strfreev(provider->host_ip);
1023         g_free(provider->config_file);
1024         g_free(provider->config_entry);
1025         connman_ipaddress_free(provider->prev_ipv4_addr);
1026         connman_ipaddress_free(provider->prev_ipv6_addr);
1027         g_free(provider);
1028 }
1029
1030 void vpn_provider_unref_debug(struct vpn_provider *provider,
1031                                 const char *file, int line, const char *caller)
1032 {
1033         DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount - 1,
1034                 file, line, caller);
1035
1036         if (__sync_fetch_and_sub(&provider->refcount, 1) != 1)
1037                 return;
1038
1039         provider_remove(provider);
1040
1041         provider_destruct(provider);
1042 }
1043
1044 static void configuration_count_add(void)
1045 {
1046         DBG("count %d", configuration_count + 1);
1047
1048         __sync_fetch_and_add(&configuration_count, 1);
1049 }
1050
1051 static void configuration_count_del(void)
1052 {
1053         DBG("count %d", configuration_count - 1);
1054
1055         if (__sync_fetch_and_sub(&configuration_count, 1) != 1)
1056                 return;
1057 }
1058
1059 int __vpn_provider_disconnect(struct vpn_provider *provider)
1060 {
1061         int err;
1062
1063         DBG("provider %p", provider);
1064
1065         if (provider->driver && provider->driver->disconnect)
1066                 err = provider->driver->disconnect(provider);
1067         else
1068                 return -EOPNOTSUPP;
1069
1070         if (err == -EINPROGRESS)
1071                 vpn_provider_set_state(provider, VPN_PROVIDER_STATE_CONNECT);
1072
1073         return err;
1074 }
1075
1076 static void connect_cb(struct vpn_provider *provider, void *user_data,
1077                                                                 int error)
1078 {
1079         DBusMessage *pending = user_data;
1080
1081         DBG("provider %p user %p error %d", provider, user_data, error);
1082
1083         if (error != 0) {
1084                 DBusMessage *reply = __connman_error_failed(pending, error);
1085                 if (reply)
1086                         g_dbus_send_message(connection, reply);
1087
1088                 vpn_provider_indicate_error(provider,
1089                                         VPN_PROVIDER_ERROR_CONNECT_FAILED);
1090                 vpn_provider_set_state(provider, VPN_PROVIDER_STATE_FAILURE);
1091         } else
1092                 g_dbus_send_reply(connection, pending, DBUS_TYPE_INVALID);
1093
1094         dbus_message_unref(pending);
1095 }
1096
1097 int __vpn_provider_connect(struct vpn_provider *provider, DBusMessage *msg)
1098 {
1099         int err;
1100
1101         DBG("provider %p", provider);
1102
1103         if (provider->driver && provider->driver->connect) {
1104                 const char *dbus_sender = dbus_message_get_sender(msg);
1105
1106                 dbus_message_ref(msg);
1107
1108                 if (dbus_message_has_signature(msg,
1109                                                 DBUS_TYPE_STRING_AS_STRING)) {
1110                         const char *sender = NULL;
1111
1112                         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING,
1113                                         &sender, DBUS_TYPE_INVALID);
1114                         if (sender && sender[0])
1115                                 dbus_sender = sender;
1116                 }
1117
1118                 err = provider->driver->connect(provider, connect_cb,
1119                                                 dbus_sender, msg);
1120         } else
1121                 return -EOPNOTSUPP;
1122
1123         if (err == -EINPROGRESS)
1124                 vpn_provider_set_state(provider, VPN_PROVIDER_STATE_CONNECT);
1125
1126         return err;
1127 }
1128
1129 static void connection_removed_signal(struct vpn_provider *provider)
1130 {
1131         DBusMessage *signal;
1132         DBusMessageIter iter;
1133
1134         signal = dbus_message_new_signal(VPN_MANAGER_PATH,
1135                         VPN_MANAGER_INTERFACE, "ConnectionRemoved");
1136         if (!signal)
1137                 return;
1138
1139         dbus_message_iter_init_append(signal, &iter);
1140         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
1141                                                         &provider->path);
1142         dbus_connection_send(connection, signal, NULL);
1143         dbus_message_unref(signal);
1144 }
1145
1146 static char *get_ident(const char *path)
1147 {
1148         char *pos;
1149
1150         if (*path != '/')
1151                 return NULL;
1152
1153         pos = strrchr(path, '/');
1154         if (!pos)
1155                 return NULL;
1156
1157         return pos + 1;
1158 }
1159
1160 int __vpn_provider_remove(const char *path)
1161 {
1162         struct vpn_provider *provider;
1163         char *ident;
1164
1165         DBG("path %s", path);
1166
1167         ident = get_ident(path);
1168
1169         provider = __vpn_provider_lookup(ident);
1170         if (provider)
1171                 return __vpn_provider_delete(provider);
1172
1173         return -ENXIO;
1174 }
1175
1176 int __vpn_provider_delete(struct vpn_provider *provider)
1177 {
1178         DBG("Deleting VPN %s", provider->identifier);
1179
1180         connection_removed_signal(provider);
1181
1182         provider_unregister(provider);
1183
1184         __connman_storage_remove_provider(provider->identifier);
1185
1186         g_hash_table_remove(provider_hash, provider->identifier);
1187
1188         return 0;
1189 }
1190
1191 static void append_ipv4(DBusMessageIter *iter, void *user_data)
1192 {
1193         struct vpn_provider *provider = user_data;
1194         const char *address, *gateway, *peer;
1195
1196         address = __vpn_ipconfig_get_local(provider->ipconfig_ipv4);
1197         if (address) {
1198                 in_addr_t addr;
1199                 struct in_addr netmask;
1200                 char *mask;
1201                 int prefixlen;
1202
1203                 prefixlen = __vpn_ipconfig_get_prefixlen(
1204                                                 provider->ipconfig_ipv4);
1205
1206                 addr = 0xffffffff << (32 - prefixlen);
1207                 netmask.s_addr = htonl(addr);
1208                 mask = inet_ntoa(netmask);
1209
1210                 connman_dbus_dict_append_basic(iter, "Address",
1211                                                 DBUS_TYPE_STRING, &address);
1212
1213                 connman_dbus_dict_append_basic(iter, "Netmask",
1214                                                 DBUS_TYPE_STRING, &mask);
1215         }
1216
1217         gateway = __vpn_ipconfig_get_gateway(provider->ipconfig_ipv4);
1218         if (gateway)
1219                 connman_dbus_dict_append_basic(iter, "Gateway",
1220                                                 DBUS_TYPE_STRING, &gateway);
1221
1222         peer = __vpn_ipconfig_get_peer(provider->ipconfig_ipv4);
1223         if (peer)
1224                 connman_dbus_dict_append_basic(iter, "Peer",
1225                                                 DBUS_TYPE_STRING, &peer);
1226 }
1227
1228 static void append_ipv6(DBusMessageIter *iter, void *user_data)
1229 {
1230         struct vpn_provider *provider = user_data;
1231         const char *address, *gateway, *peer;
1232
1233         address = __vpn_ipconfig_get_local(provider->ipconfig_ipv6);
1234         if (address) {
1235                 unsigned char prefixlen;
1236
1237                 connman_dbus_dict_append_basic(iter, "Address",
1238                                                 DBUS_TYPE_STRING, &address);
1239
1240                 prefixlen = __vpn_ipconfig_get_prefixlen(
1241                                                 provider->ipconfig_ipv6);
1242
1243                 connman_dbus_dict_append_basic(iter, "PrefixLength",
1244                                                 DBUS_TYPE_BYTE, &prefixlen);
1245         }
1246
1247         gateway = __vpn_ipconfig_get_gateway(provider->ipconfig_ipv6);
1248         if (gateway)
1249                 connman_dbus_dict_append_basic(iter, "Gateway",
1250                                                 DBUS_TYPE_STRING, &gateway);
1251
1252         peer = __vpn_ipconfig_get_peer(provider->ipconfig_ipv6);
1253         if (peer)
1254                 connman_dbus_dict_append_basic(iter, "Peer",
1255                                                 DBUS_TYPE_STRING, &peer);
1256 }
1257
1258 static const char *state2string(enum vpn_provider_state state)
1259 {
1260         switch (state) {
1261         case VPN_PROVIDER_STATE_UNKNOWN:
1262                 break;
1263         case VPN_PROVIDER_STATE_IDLE:
1264                 return "idle";
1265         case VPN_PROVIDER_STATE_CONNECT:
1266                 return "configuration";
1267         case VPN_PROVIDER_STATE_READY:
1268                 return "ready";
1269         case VPN_PROVIDER_STATE_DISCONNECT:
1270                 return "disconnect";
1271         case VPN_PROVIDER_STATE_FAILURE:
1272                 return "failure";
1273         }
1274
1275         return NULL;
1276 }
1277
1278 static void append_nameservers(DBusMessageIter *iter, char **servers)
1279 {
1280         int i;
1281
1282         DBG("%p", servers);
1283
1284         for (i = 0; servers[i]; i++) {
1285                 DBG("servers[%d] %s", i, servers[i]);
1286                 dbus_message_iter_append_basic(iter,
1287                                         DBUS_TYPE_STRING, &servers[i]);
1288         }
1289 }
1290
1291 static void append_dns(DBusMessageIter *iter, void *user_data)
1292 {
1293         struct vpn_provider *provider = user_data;
1294
1295         if (provider->nameservers)
1296                 append_nameservers(iter, provider->nameservers);
1297 }
1298
1299 static int provider_indicate_state(struct vpn_provider *provider,
1300                                 enum vpn_provider_state state)
1301 {
1302         const char *str;
1303         enum vpn_provider_state old_state;
1304
1305         str = state2string(state);
1306         DBG("provider %p state %s/%d", provider, str, state);
1307         if (!str)
1308                 return -EINVAL;
1309
1310         old_state = provider->state;
1311         provider->state = state;
1312
1313         if (state == VPN_PROVIDER_STATE_READY) {
1314                 connman_dbus_property_changed_basic(provider->path,
1315                                         VPN_CONNECTION_INTERFACE, "Index",
1316                                         DBUS_TYPE_INT32, &provider->index);
1317
1318                 if (provider->family == AF_INET)
1319                         connman_dbus_property_changed_dict(provider->path,
1320                                         VPN_CONNECTION_INTERFACE, "IPv4",
1321                                         append_ipv4, provider);
1322                 else if (provider->family == AF_INET6)
1323                         connman_dbus_property_changed_dict(provider->path,
1324                                         VPN_CONNECTION_INTERFACE, "IPv6",
1325                                         append_ipv6, provider);
1326
1327                 connman_dbus_property_changed_array(provider->path,
1328                                                 VPN_CONNECTION_INTERFACE,
1329                                                 "Nameservers",
1330                                                 DBUS_TYPE_STRING,
1331                                                 append_dns, provider);
1332
1333                 if (provider->domain)
1334                         connman_dbus_property_changed_basic(provider->path,
1335                                                 VPN_CONNECTION_INTERFACE,
1336                                                 "Domain",
1337                                                 DBUS_TYPE_STRING,
1338                                                 &provider->domain);
1339         }
1340
1341         if (old_state != state)
1342                 connman_dbus_property_changed_basic(provider->path,
1343                                         VPN_CONNECTION_INTERFACE, "State",
1344                                         DBUS_TYPE_STRING, &str);
1345
1346         return 0;
1347 }
1348
1349 static void append_state(DBusMessageIter *iter,
1350                                         struct vpn_provider *provider)
1351 {
1352         char *str;
1353
1354         switch (provider->state) {
1355         case VPN_PROVIDER_STATE_UNKNOWN:
1356         case VPN_PROVIDER_STATE_IDLE:
1357                 str = "idle";
1358                 break;
1359         case VPN_PROVIDER_STATE_CONNECT:
1360                 str = "configuration";
1361                 break;
1362         case VPN_PROVIDER_STATE_READY:
1363                 str = "ready";
1364                 break;
1365         case VPN_PROVIDER_STATE_DISCONNECT:
1366                 str = "disconnect";
1367                 break;
1368         case VPN_PROVIDER_STATE_FAILURE:
1369                 str = "failure";
1370                 break;
1371         }
1372
1373         connman_dbus_dict_append_basic(iter, "State",
1374                                 DBUS_TYPE_STRING, &str);
1375 }
1376
1377 static void append_properties(DBusMessageIter *iter,
1378                                         struct vpn_provider *provider)
1379 {
1380         DBusMessageIter dict;
1381         GHashTableIter hash;
1382         gpointer value, key;
1383         dbus_bool_t immutable;
1384
1385         connman_dbus_dict_open(iter, &dict);
1386
1387         append_state(&dict, provider);
1388
1389         if (provider->type)
1390                 connman_dbus_dict_append_basic(&dict, "Type",
1391                                         DBUS_TYPE_STRING, &provider->type);
1392
1393         if (provider->name)
1394                 connman_dbus_dict_append_basic(&dict, "Name",
1395                                         DBUS_TYPE_STRING, &provider->name);
1396
1397         if (provider->host)
1398                 connman_dbus_dict_append_basic(&dict, "Host",
1399                                         DBUS_TYPE_STRING, &provider->host);
1400         if (provider->index >= 0)
1401                 connman_dbus_dict_append_basic(&dict, "Index",
1402                                         DBUS_TYPE_INT32, &provider->index);
1403         if (provider->domain)
1404                 connman_dbus_dict_append_basic(&dict, "Domain",
1405                                         DBUS_TYPE_STRING, &provider->domain);
1406
1407         immutable = provider->immutable;
1408         connman_dbus_dict_append_basic(&dict, "Immutable", DBUS_TYPE_BOOLEAN,
1409                                         &immutable);
1410
1411         if (provider->family == AF_INET)
1412                 connman_dbus_dict_append_dict(&dict, "IPv4", append_ipv4,
1413                                                 provider);
1414         else if (provider->family == AF_INET6)
1415                 connman_dbus_dict_append_dict(&dict, "IPv6", append_ipv6,
1416                                                 provider);
1417
1418         connman_dbus_dict_append_array(&dict, "Nameservers",
1419                                 DBUS_TYPE_STRING, append_dns, provider);
1420
1421         connman_dbus_dict_append_array(&dict, "UserRoutes",
1422                                 DBUS_TYPE_DICT_ENTRY, append_routes,
1423                                 provider->user_routes);
1424
1425         connman_dbus_dict_append_array(&dict, "ServerRoutes",
1426                                 DBUS_TYPE_DICT_ENTRY, append_routes,
1427                                 provider->routes);
1428
1429         if (provider->setting_strings) {
1430                 g_hash_table_iter_init(&hash, provider->setting_strings);
1431
1432                 while (g_hash_table_iter_next(&hash, &key, &value)) {
1433                         struct vpn_setting *setting = value;
1434
1435                         if (!setting->hide_value &&
1436                                                         setting->value)
1437                                 connman_dbus_dict_append_basic(&dict, key,
1438                                                         DBUS_TYPE_STRING,
1439                                                         &setting->value);
1440                 }
1441         }
1442
1443         connman_dbus_dict_close(iter, &dict);
1444 }
1445
1446 static void connection_added_signal(struct vpn_provider *provider)
1447 {
1448         DBusMessage *signal;
1449         DBusMessageIter iter;
1450
1451         signal = dbus_message_new_signal(VPN_MANAGER_PATH,
1452                         VPN_MANAGER_INTERFACE, "ConnectionAdded");
1453         if (!signal)
1454                 return;
1455
1456         dbus_message_iter_init_append(signal, &iter);
1457         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
1458                                                         &provider->path);
1459         append_properties(&iter, provider);
1460
1461         dbus_connection_send(connection, signal, NULL);
1462         dbus_message_unref(signal);
1463 }
1464
1465 static bool check_host(char **hosts, char *host)
1466 {
1467         int i;
1468
1469         if (!hosts)
1470                 return false;
1471
1472         for (i = 0; hosts[i]; i++) {
1473                 if (g_strcmp0(hosts[i], host) == 0)
1474                         return true;
1475         }
1476
1477         return false;
1478 }
1479
1480 static void provider_append_routes(gpointer key, gpointer value,
1481                                         gpointer user_data)
1482 {
1483         struct vpn_route *route = value;
1484         struct vpn_provider *provider = user_data;
1485         int index = provider->index;
1486
1487         if (!handle_routes)
1488                 return;
1489
1490         /*
1491          * If the VPN administrator/user has given a route to
1492          * VPN server, then we must discard that because the
1493          * server cannot be contacted via VPN tunnel.
1494          */
1495         if (check_host(provider->host_ip, route->network)) {
1496                 DBG("Discarding VPN route to %s via %s at index %d",
1497                         route->network, route->gateway, index);
1498                 return;
1499         }
1500
1501         if (route->family == AF_INET6) {
1502                 unsigned char prefix_len = atoi(route->netmask);
1503
1504                 connman_inet_add_ipv6_network_route(index, route->network,
1505                                                         route->gateway,
1506                                                         prefix_len);
1507         } else {
1508                 connman_inet_add_network_route(index, route->network,
1509                                                 route->gateway,
1510                                                 route->netmask);
1511         }
1512 }
1513
1514 static int set_connected(struct vpn_provider *provider,
1515                                         bool connected)
1516 {
1517         struct vpn_ipconfig *ipconfig;
1518
1519         DBG("provider %p id %s connected %d", provider,
1520                                         provider->identifier, connected);
1521
1522         if (connected) {
1523                 if (provider->family == AF_INET6)
1524                         ipconfig = provider->ipconfig_ipv6;
1525                 else
1526                         ipconfig = provider->ipconfig_ipv4;
1527
1528                 __vpn_ipconfig_address_add(ipconfig, provider->family);
1529
1530                 if (handle_routes)
1531                         __vpn_ipconfig_gateway_add(ipconfig, provider->family);
1532
1533                 provider_indicate_state(provider,
1534                                         VPN_PROVIDER_STATE_READY);
1535
1536                 g_hash_table_foreach(provider->routes, provider_append_routes,
1537                                         provider);
1538
1539                 g_hash_table_foreach(provider->user_routes,
1540                                         provider_append_routes, provider);
1541
1542         } else {
1543                 provider_indicate_state(provider,
1544                                         VPN_PROVIDER_STATE_DISCONNECT);
1545
1546                 provider_indicate_state(provider,
1547                                         VPN_PROVIDER_STATE_IDLE);
1548         }
1549
1550         return 0;
1551 }
1552
1553 int vpn_provider_set_state(struct vpn_provider *provider,
1554                                         enum vpn_provider_state state)
1555 {
1556         if (!provider)
1557                 return -EINVAL;
1558
1559         switch (state) {
1560         case VPN_PROVIDER_STATE_UNKNOWN:
1561                 return -EINVAL;
1562         case VPN_PROVIDER_STATE_IDLE:
1563                 return set_connected(provider, false);
1564         case VPN_PROVIDER_STATE_CONNECT:
1565                 return provider_indicate_state(provider, state);
1566         case VPN_PROVIDER_STATE_READY:
1567                 return set_connected(provider, true);
1568         case VPN_PROVIDER_STATE_DISCONNECT:
1569                 return provider_indicate_state(provider, state);
1570         case VPN_PROVIDER_STATE_FAILURE:
1571                 return provider_indicate_state(provider, state);
1572         }
1573         return -EINVAL;
1574 }
1575
1576 int vpn_provider_indicate_error(struct vpn_provider *provider,
1577                                         enum vpn_provider_error error)
1578 {
1579         DBG("provider %p id %s error %d", provider, provider->identifier,
1580                                                                         error);
1581
1582         vpn_provider_set_state(provider, VPN_PROVIDER_STATE_FAILURE);
1583
1584         switch (error) {
1585         case VPN_PROVIDER_ERROR_UNKNOWN:
1586         case VPN_PROVIDER_ERROR_CONNECT_FAILED:
1587                 break;
1588
1589         case VPN_PROVIDER_ERROR_LOGIN_FAILED:
1590         case VPN_PROVIDER_ERROR_AUTH_FAILED:
1591                 vpn_provider_set_state(provider, VPN_PROVIDER_STATE_IDLE);
1592                 break;
1593         }
1594
1595         if (provider->driver && provider->driver->set_state)
1596                 provider->driver->set_state(provider, provider->state);
1597
1598         return 0;
1599 }
1600
1601 static int connection_unregister(struct vpn_provider *provider)
1602 {
1603         DBG("provider %p path %s", provider, provider->path);
1604
1605         if (!provider->path)
1606                 return -EALREADY;
1607
1608         g_dbus_unregister_interface(connection, provider->path,
1609                                 VPN_CONNECTION_INTERFACE);
1610
1611         g_free(provider->path);
1612         provider->path = NULL;
1613
1614         return 0;
1615 }
1616
1617 static int connection_register(struct vpn_provider *provider)
1618 {
1619         DBG("provider %p path %s", provider, provider->path);
1620
1621         if (provider->path)
1622                 return -EALREADY;
1623
1624         provider->path = g_strdup_printf("%s/connection/%s", VPN_PATH,
1625                                                 provider->identifier);
1626
1627         g_dbus_register_interface(connection, provider->path,
1628                                 VPN_CONNECTION_INTERFACE,
1629                                 connection_methods, connection_signals,
1630                                 NULL, provider, NULL);
1631
1632         return 0;
1633 }
1634
1635 static void unregister_provider(gpointer data)
1636 {
1637         struct vpn_provider *provider = data;
1638
1639         configuration_count_del();
1640
1641         connection_unregister(provider);
1642
1643         /* If the provider has any DNS resolver queries pending,
1644          * they need to be cleared here because the unref will not
1645          * be able to do that (because the provider_resolv_host_addr()
1646          * has increased the ref count by 1). This is quite rare as
1647          * normally the resolving either returns a value or has a
1648          * timeout which clears the memory. Typically resolv_result() will
1649          * unref the provider but in this case that call has not yet
1650          * happened.
1651          */
1652         if (provider->resolv)
1653                 vpn_provider_unref(provider);
1654
1655         vpn_provider_unref(provider);
1656 }
1657
1658 static void provider_initialize(struct vpn_provider *provider)
1659 {
1660         DBG("provider %p", provider);
1661
1662         provider->index = 0;
1663         provider->fd = -1;
1664         provider->name = NULL;
1665         provider->type = NULL;
1666         provider->domain = NULL;
1667         provider->identifier = NULL;
1668         provider->immutable = false;
1669         provider->user_networks = NULL;
1670         provider->routes = g_hash_table_new_full(g_direct_hash, g_direct_equal,
1671                                         NULL, free_route);
1672         provider->user_routes = g_hash_table_new_full(g_str_hash, g_str_equal,
1673                                         g_free, free_route);
1674         provider->setting_strings = g_hash_table_new_full(g_str_hash,
1675                                         g_str_equal, g_free, free_setting);
1676 }
1677
1678 static struct vpn_provider *vpn_provider_new(void)
1679 {
1680         struct vpn_provider *provider;
1681
1682         provider = g_try_new0(struct vpn_provider, 1);
1683         if (!provider)
1684                 return NULL;
1685
1686         provider->refcount = 1;
1687
1688         DBG("provider %p", provider);
1689         provider_initialize(provider);
1690
1691         return provider;
1692 }
1693
1694 static struct vpn_provider *vpn_provider_get(const char *identifier)
1695 {
1696         struct vpn_provider *provider;
1697
1698         provider = g_hash_table_lookup(provider_hash, identifier);
1699         if (provider)
1700                 return provider;
1701
1702         provider = vpn_provider_new();
1703         if (!provider)
1704                 return NULL;
1705
1706         DBG("provider %p", provider);
1707
1708         provider->identifier = g_strdup(identifier);
1709
1710         g_hash_table_insert(provider_hash, provider->identifier, provider);
1711
1712         configuration_count_add();
1713
1714         return provider;
1715 }
1716
1717 static void provider_dbus_ident(char *ident)
1718 {
1719         int i, len = strlen(ident);
1720
1721         for (i = 0; i < len; i++) {
1722                 if (ident[i] >= '0' && ident[i] <= '9')
1723                         continue;
1724                 if (ident[i] >= 'a' && ident[i] <= 'z')
1725                         continue;
1726                 if (ident[i] >= 'A' && ident[i] <= 'Z')
1727                         continue;
1728                 ident[i] = '_';
1729         }
1730 }
1731
1732 static struct vpn_provider *provider_create_from_keyfile(GKeyFile *keyfile,
1733                 const char *ident)
1734 {
1735         struct vpn_provider *provider;
1736
1737         if (!keyfile || !ident)
1738                 return NULL;
1739
1740         provider = __vpn_provider_lookup(ident);
1741         if (!provider) {
1742                 provider = vpn_provider_get(ident);
1743                 if (!provider) {
1744                         DBG("can not create provider");
1745                         return NULL;
1746                 }
1747
1748                 provider_load_from_keyfile(provider, keyfile);
1749
1750                 if (!provider->name || !provider->host ||
1751                                 !provider->domain) {
1752                         DBG("cannot get name, host or domain");
1753                         vpn_provider_unref(provider);
1754                         return NULL;
1755                 }
1756
1757                 if (provider_register(provider) == 0)
1758                         connection_register(provider);
1759         }
1760         return provider;
1761 }
1762
1763 static void provider_create_all_from_type(const char *provider_type)
1764 {
1765         unsigned int i;
1766         char **providers;
1767         char *id, *type;
1768         GKeyFile *keyfile;
1769
1770         DBG("provider type %s", provider_type);
1771
1772         providers = __connman_storage_get_providers();
1773
1774         if (!providers)
1775                 return;
1776
1777         for (i = 0; providers[i]; i += 1) {
1778
1779                 if (strncmp(providers[i], "provider_", 9) != 0)
1780                         continue;
1781
1782                 id = providers[i] + 9;
1783                 keyfile = __connman_storage_load_provider(id);
1784
1785                 if (!keyfile)
1786                         continue;
1787
1788                 type = __vpn_config_get_string(keyfile, id, "Type", NULL);
1789
1790                 DBG("keyfile %p id %s type %s", keyfile, id, type);
1791
1792                 if (strcmp(provider_type, type) != 0) {
1793                         g_free(type);
1794                         g_key_file_free(keyfile);
1795                         continue;
1796                 }
1797
1798                 if (!provider_create_from_keyfile(keyfile, id))
1799                         DBG("could not create provider");
1800
1801                 g_free(type);
1802                 g_key_file_free(keyfile);
1803         }
1804         g_strfreev(providers);
1805 }
1806
1807 char *__vpn_provider_create_identifier(const char *host, const char *domain)
1808 {
1809         char *ident;
1810
1811         ident = g_strdup_printf("%s_%s", host, domain);
1812         if (!ident)
1813                 return NULL;
1814
1815         provider_dbus_ident(ident);
1816
1817         return ident;
1818 }
1819
1820 int __vpn_provider_create(DBusMessage *msg)
1821 {
1822         struct vpn_provider *provider;
1823         DBusMessageIter iter, array;
1824         const char *type = NULL, *name = NULL;
1825         const char *host = NULL, *domain = NULL;
1826         GSList *networks = NULL;
1827         char *ident;
1828         int err;
1829
1830         dbus_message_iter_init(msg, &iter);
1831         dbus_message_iter_recurse(&iter, &array);
1832
1833         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
1834                 DBusMessageIter entry, value;
1835                 const char *key;
1836
1837                 dbus_message_iter_recurse(&array, &entry);
1838                 dbus_message_iter_get_basic(&entry, &key);
1839
1840                 dbus_message_iter_next(&entry);
1841                 dbus_message_iter_recurse(&entry, &value);
1842
1843                 switch (dbus_message_iter_get_arg_type(&value)) {
1844                 case DBUS_TYPE_STRING:
1845                         if (g_str_equal(key, "Type"))
1846                                 dbus_message_iter_get_basic(&value, &type);
1847                         else if (g_str_equal(key, "Name"))
1848                                 dbus_message_iter_get_basic(&value, &name);
1849                         else if (g_str_equal(key, "Host"))
1850                                 dbus_message_iter_get_basic(&value, &host);
1851                         else if (g_str_equal(key, "VPN.Domain") ||
1852                                         g_str_equal(key, "Domain"))
1853                                 dbus_message_iter_get_basic(&value, &domain);
1854                         break;
1855                 case DBUS_TYPE_ARRAY:
1856                         if (g_str_equal(key, "UserRoutes"))
1857                                 networks = get_user_networks(&value);
1858                         break;
1859                 }
1860
1861                 dbus_message_iter_next(&array);
1862         }
1863
1864         if (!host || !domain)
1865                 return -EINVAL;
1866
1867         DBG("Type %s name %s networks %p", type, name, networks);
1868
1869         if (!type || !name)
1870                 return -EOPNOTSUPP;
1871
1872         ident = __vpn_provider_create_identifier(host, domain);
1873         DBG("ident %s", ident);
1874
1875         provider = __vpn_provider_lookup(ident);
1876         if (!provider) {
1877                 provider = vpn_provider_get(ident);
1878                 if (!provider) {
1879                         DBG("can not create provider");
1880                         g_free(ident);
1881                         return -EOPNOTSUPP;
1882                 }
1883
1884                 provider->host = g_strdup(host);
1885                 provider->domain = g_strdup(domain);
1886                 provider->name = g_strdup(name);
1887                 provider->type = g_strdup(type);
1888
1889                 if (provider_register(provider) == 0)
1890                         vpn_provider_load(provider);
1891
1892                 provider_resolv_host_addr(provider);
1893         }
1894
1895         if (networks) {
1896                 g_slist_free_full(provider->user_networks, free_route);
1897                 provider->user_networks = networks;
1898                 set_user_networks(provider, provider->user_networks);
1899         }
1900
1901         dbus_message_iter_init(msg, &iter);
1902         dbus_message_iter_recurse(&iter, &array);
1903
1904         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
1905                 DBusMessageIter entry, value;
1906                 const char *key, *str;
1907
1908                 dbus_message_iter_recurse(&array, &entry);
1909                 dbus_message_iter_get_basic(&entry, &key);
1910
1911                 dbus_message_iter_next(&entry);
1912                 dbus_message_iter_recurse(&entry, &value);
1913
1914                 switch (dbus_message_iter_get_arg_type(&value)) {
1915                 case DBUS_TYPE_STRING:
1916                         dbus_message_iter_get_basic(&value, &str);
1917                         vpn_provider_set_string(provider, key, str);
1918                         break;
1919                 }
1920
1921                 dbus_message_iter_next(&array);
1922         }
1923
1924         g_free(ident);
1925
1926         vpn_provider_save(provider);
1927
1928         err = provider_register(provider);
1929         if (err != 0 && err != -EALREADY)
1930                 return err;
1931
1932         connection_register(provider);
1933
1934         DBG("provider %p index %d path %s", provider, provider->index,
1935                                                         provider->path);
1936
1937         g_dbus_send_reply(connection, msg,
1938                                 DBUS_TYPE_OBJECT_PATH, &provider->path,
1939                                 DBUS_TYPE_INVALID);
1940
1941         connection_added_signal(provider);
1942
1943         return 0;
1944 }
1945
1946 static const char *get_string(GHashTable *settings, const char *key)
1947 {
1948         DBG("settings %p key %s", settings, key);
1949
1950         return g_hash_table_lookup(settings, key);
1951 }
1952
1953 static GSList *parse_user_networks(const char *network_str)
1954 {
1955         GSList *networks = NULL;
1956         char **elems;
1957         int i = 0;
1958
1959         if (!network_str)
1960                 return NULL;
1961
1962         elems = g_strsplit(network_str, ",", 0);
1963         if (!elems)
1964                 return NULL;
1965
1966         while (elems[i]) {
1967                 struct vpn_route *vpn_route;
1968                 char *network, *netmask, *gateway;
1969                 int family;
1970                 char **route;
1971
1972                 route = g_strsplit(elems[i], "/", 0);
1973                 if (!route)
1974                         goto next;
1975
1976                 network = route[0];
1977                 if (!network || network[0] == '\0')
1978                         goto next;
1979
1980                 family = connman_inet_check_ipaddress(network);
1981                 if (family < 0) {
1982                         DBG("Cannot get address family of %s (%d/%s)", network,
1983                                 family, gai_strerror(family));
1984
1985                         goto next;
1986                 }
1987
1988                 switch (family) {
1989                 case AF_INET:
1990                         break;
1991                 case AF_INET6:
1992                         break;
1993                 default:
1994                         DBG("Unsupported address family %d", family);
1995                         goto next;
1996                 }
1997
1998                 netmask = route[1];
1999                 if (!netmask || netmask[0] == '\0')
2000                         goto next;
2001
2002                 gateway = route[2];
2003
2004                 vpn_route = g_try_new0(struct vpn_route, 1);
2005                 if (!vpn_route) {
2006                         g_strfreev(route);
2007                         break;
2008                 }
2009
2010                 vpn_route->family = family;
2011                 vpn_route->network = g_strdup(network);
2012                 vpn_route->netmask = g_strdup(netmask);
2013                 vpn_route->gateway = g_strdup(gateway);
2014
2015                 DBG("route %s/%s%s%s", network, netmask,
2016                         gateway ? " via " : "", gateway ? gateway : "");
2017
2018                 networks = g_slist_prepend(networks, vpn_route);
2019
2020         next:
2021                 g_strfreev(route);
2022                 i++;
2023         }
2024
2025         g_strfreev(elems);
2026
2027         return g_slist_reverse(networks);
2028 }
2029
2030 int __vpn_provider_create_from_config(GHashTable *settings,
2031                                 const char *config_ident,
2032                                 const char *config_entry)
2033 {
2034         struct vpn_provider *provider;
2035         const char *type, *name, *host, *domain, *networks_str;
2036         GSList *networks;
2037         char *ident = NULL;
2038         GHashTableIter hash;
2039         gpointer value, key;
2040         int err;
2041
2042         type = get_string(settings, "Type");
2043         name = get_string(settings, "Name");
2044         host = get_string(settings, "Host");
2045         domain = get_string(settings, "Domain");
2046         networks_str = get_string(settings, "Networks");
2047         networks = parse_user_networks(networks_str);
2048
2049         if (!host || !domain) {
2050                 err = -EINVAL;
2051                 goto fail;
2052         }
2053
2054         DBG("type %s name %s networks %s", type, name, networks_str);
2055
2056         if (!type || !name) {
2057                 err = -EOPNOTSUPP;
2058                 goto fail;
2059         }
2060
2061         ident = __vpn_provider_create_identifier(host, domain);
2062         DBG("ident %s", ident);
2063
2064         provider = __vpn_provider_lookup(ident);
2065         if (!provider) {
2066                 provider = vpn_provider_get(ident);
2067                 if (!provider) {
2068                         DBG("can not create provider");
2069                         err = -EOPNOTSUPP;
2070                         goto fail;
2071                 }
2072
2073                 provider->host = g_strdup(host);
2074                 provider->domain = g_strdup(domain);
2075                 provider->name = g_strdup(name);
2076                 provider->type = g_ascii_strdown(type, -1);
2077
2078                 provider->config_file = g_strdup(config_ident);
2079                 provider->config_entry = g_strdup(config_entry);
2080
2081                 provider_register(provider);
2082
2083                 provider_resolv_host_addr(provider);
2084         }
2085
2086         if (networks) {
2087                 g_slist_free_full(provider->user_networks, free_route);
2088                 provider->user_networks = networks;
2089                 set_user_networks(provider, provider->user_networks);
2090         }
2091
2092         g_hash_table_iter_init(&hash, settings);
2093
2094         while (g_hash_table_iter_next(&hash, &key, &value))
2095                 __vpn_provider_set_string_immutable(provider, key, value);
2096
2097         provider->immutable = true;
2098
2099         vpn_provider_save(provider);
2100
2101         err = provider_register(provider);
2102         if (err != 0 && err != -EALREADY)
2103                 goto fail;
2104
2105         connection_register(provider);
2106
2107         DBG("provider %p index %d path %s", provider, provider->index,
2108                                                         provider->path);
2109
2110         connection_added_signal(provider);
2111
2112         g_free(ident);
2113
2114         return 0;
2115
2116 fail:
2117         g_free(ident);
2118         g_slist_free_full(networks, free_route);
2119
2120         return err;
2121 }
2122
2123 static void append_connection_structs(DBusMessageIter *iter, void *user_data)
2124 {
2125         DBusMessageIter entry;
2126         GHashTableIter hash;
2127         gpointer value, key;
2128
2129         g_hash_table_iter_init(&hash, provider_hash);
2130
2131         while (g_hash_table_iter_next(&hash, &key, &value)) {
2132                 struct vpn_provider *provider = value;
2133
2134                 DBG("path %s", provider->path);
2135
2136                 if (!provider->identifier)
2137                         continue;
2138
2139                 dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT,
2140                                 NULL, &entry);
2141                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
2142                                 &provider->path);
2143                 append_properties(&entry, provider);
2144                 dbus_message_iter_close_container(iter, &entry);
2145         }
2146 }
2147
2148 DBusMessage *__vpn_provider_get_connections(DBusMessage *msg)
2149 {
2150         DBusMessage *reply;
2151
2152         DBG("");
2153
2154         reply = dbus_message_new_method_return(msg);
2155         if (!reply)
2156                 return NULL;
2157
2158         __connman_dbus_append_objpath_dict_array(reply,
2159                         append_connection_structs, NULL);
2160
2161         return reply;
2162 }
2163
2164 const char *__vpn_provider_get_ident(struct vpn_provider *provider)
2165 {
2166         if (!provider)
2167                 return NULL;
2168
2169         return provider->identifier;
2170 }
2171
2172 static int set_string(struct vpn_provider *provider,
2173                         const char *key, const char *value,
2174                         bool hide_value, bool immutable)
2175 {
2176         DBG("provider %p key %s immutable %s value %s", provider, key,
2177                 immutable ? "yes" : "no",
2178                 hide_value ? "<not printed>" : value);
2179
2180         if (g_str_equal(key, "Type")) {
2181                 g_free(provider->type);
2182                 provider->type = g_ascii_strdown(value, -1);
2183                 send_value(provider->path, "Type", provider->type);
2184         } else if (g_str_equal(key, "Name")) {
2185                 g_free(provider->name);
2186                 provider->name = g_strdup(value);
2187                 send_value(provider->path, "Name", provider->name);
2188         } else if (g_str_equal(key, "Host")) {
2189                 g_free(provider->host);
2190                 provider->host = g_strdup(value);
2191                 send_value(provider->path, "Host", provider->host);
2192         } else if (g_str_equal(key, "VPN.Domain") ||
2193                         g_str_equal(key, "Domain")) {
2194                 g_free(provider->domain);
2195                 provider->domain = g_strdup(value);
2196                 send_value(provider->path, "Domain", provider->domain);
2197         } else {
2198                 struct vpn_setting *setting;
2199
2200                 setting = g_hash_table_lookup(provider->setting_strings, key);
2201                 if (setting && !immutable &&
2202                                                 setting->immutable) {
2203                         DBG("Trying to set immutable variable %s", key);
2204                         return -EPERM;
2205                 }
2206
2207                 setting = g_try_new0(struct vpn_setting, 1);
2208                 if (!setting)
2209                         return -ENOMEM;
2210
2211                 setting->value = g_strdup(value);
2212                 setting->hide_value = hide_value;
2213
2214                 if (immutable)
2215                         setting->immutable = true;
2216
2217                 if (!hide_value)
2218                         send_value(provider->path, key, setting->value);
2219
2220                 g_hash_table_replace(provider->setting_strings,
2221                                 g_strdup(key), setting);
2222         }
2223
2224         return 0;
2225 }
2226
2227 int vpn_provider_set_string(struct vpn_provider *provider,
2228                                         const char *key, const char *value)
2229 {
2230         return set_string(provider, key, value, false, false);
2231 }
2232
2233 int vpn_provider_set_string_hide_value(struct vpn_provider *provider,
2234                                         const char *key, const char *value)
2235 {
2236         return set_string(provider, key, value, true, false);
2237 }
2238
2239 int __vpn_provider_set_string_immutable(struct vpn_provider *provider,
2240                                         const char *key, const char *value)
2241 {
2242         return set_string(provider, key, value, false, true);
2243 }
2244
2245 const char *vpn_provider_get_string(struct vpn_provider *provider,
2246                                                         const char *key)
2247 {
2248         struct vpn_setting *setting;
2249
2250         DBG("provider %p key %s", provider, key);
2251
2252         if (g_str_equal(key, "Type"))
2253                 return provider->type;
2254         else if (g_str_equal(key, "Name"))
2255                 return provider->name;
2256         else if (g_str_equal(key, "Host"))
2257                 return provider->host;
2258         else if (g_str_equal(key, "HostIP")) {
2259                 if (!provider->host_ip ||
2260                                 !provider->host_ip[0])
2261                         return provider->host;
2262                 else
2263                         return provider->host_ip[0];
2264         } else if (g_str_equal(key, "VPN.Domain") ||
2265                         g_str_equal(key, "Domain"))
2266                 return provider->domain;
2267
2268         setting = g_hash_table_lookup(provider->setting_strings, key);
2269         if (!setting)
2270                 return NULL;
2271
2272         return setting->value;
2273 }
2274
2275 bool __vpn_provider_check_routes(struct vpn_provider *provider)
2276 {
2277         if (!provider)
2278                 return false;
2279
2280         if (provider->user_routes &&
2281                         g_hash_table_size(provider->user_routes) > 0)
2282                 return true;
2283
2284         if (provider->routes &&
2285                         g_hash_table_size(provider->routes) > 0)
2286                 return true;
2287
2288         return false;
2289 }
2290
2291 void *vpn_provider_get_data(struct vpn_provider *provider)
2292 {
2293         return provider->driver_data;
2294 }
2295
2296 void vpn_provider_set_data(struct vpn_provider *provider, void *data)
2297 {
2298         provider->driver_data = data;
2299 }
2300
2301 void vpn_provider_set_index(struct vpn_provider *provider, int index)
2302 {
2303         DBG("index %d provider %p", index, provider);
2304
2305         if (!provider->ipconfig_ipv4) {
2306                 provider->ipconfig_ipv4 = __vpn_ipconfig_create(index,
2307                                                                 AF_INET);
2308                 if (!provider->ipconfig_ipv4) {
2309                         DBG("Couldnt create ipconfig for IPv4");
2310                         goto done;
2311                 }
2312         }
2313
2314         __vpn_ipconfig_set_index(provider->ipconfig_ipv4, index);
2315
2316         if (!provider->ipconfig_ipv6) {
2317                 provider->ipconfig_ipv6 = __vpn_ipconfig_create(index,
2318                                                                 AF_INET6);
2319                 if (!provider->ipconfig_ipv6) {
2320                         DBG("Couldnt create ipconfig for IPv6");
2321                         goto done;
2322                 }
2323         }
2324
2325         __vpn_ipconfig_set_index(provider->ipconfig_ipv6, index);
2326
2327 done:
2328         provider->index = index;
2329 }
2330
2331 int vpn_provider_get_index(struct vpn_provider *provider)
2332 {
2333         return provider->index;
2334 }
2335
2336 int vpn_provider_set_ipaddress(struct vpn_provider *provider,
2337                                         struct connman_ipaddress *ipaddress)
2338 {
2339         struct vpn_ipconfig *ipconfig = NULL;
2340
2341         switch (ipaddress->family) {
2342         case AF_INET:
2343                 ipconfig = provider->ipconfig_ipv4;
2344                 break;
2345         case AF_INET6:
2346                 ipconfig = provider->ipconfig_ipv6;
2347                 break;
2348         default:
2349                 break;
2350         }
2351
2352         DBG("provider %p state %d ipconfig %p family %d", provider,
2353                 provider->state, ipconfig, ipaddress->family);
2354
2355         if (!ipconfig)
2356                 return -EINVAL;
2357
2358         provider->family = ipaddress->family;
2359
2360         if (provider->state == VPN_PROVIDER_STATE_CONNECT ||
2361                         provider->state == VPN_PROVIDER_STATE_READY) {
2362                 struct connman_ipaddress *addr =
2363                                         __vpn_ipconfig_get_address(ipconfig);
2364
2365                 /*
2366                  * Remember the old address so that we can remove it in notify
2367                  * function in plugins/vpn.c if we ever restart
2368                  */
2369                 if (ipaddress->family == AF_INET6) {
2370                         connman_ipaddress_free(provider->prev_ipv6_addr);
2371                         provider->prev_ipv6_addr =
2372                                                 connman_ipaddress_copy(addr);
2373                 } else {
2374                         connman_ipaddress_free(provider->prev_ipv4_addr);
2375                         provider->prev_ipv4_addr =
2376                                                 connman_ipaddress_copy(addr);
2377                 }
2378         }
2379
2380         if (ipaddress->local) {
2381                 __vpn_ipconfig_set_local(ipconfig, ipaddress->local);
2382                 __vpn_ipconfig_set_peer(ipconfig, ipaddress->peer);
2383                 __vpn_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
2384                 __vpn_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
2385                 __vpn_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
2386         }
2387
2388         return 0;
2389 }
2390
2391 int vpn_provider_set_pac(struct vpn_provider *provider,
2392                                 const char *pac)
2393 {
2394         DBG("provider %p pac %s", provider, pac);
2395
2396         return 0;
2397 }
2398
2399
2400 int vpn_provider_set_domain(struct vpn_provider *provider,
2401                                         const char *domain)
2402 {
2403         DBG("provider %p domain %s", provider, domain);
2404
2405         g_free(provider->domain);
2406         provider->domain = g_strdup(domain);
2407
2408         return 0;
2409 }
2410
2411 int vpn_provider_set_nameservers(struct vpn_provider *provider,
2412                                         const char *nameservers)
2413 {
2414         DBG("provider %p nameservers %s", provider, nameservers);
2415
2416         g_strfreev(provider->nameservers);
2417         provider->nameservers = NULL;
2418
2419         if (!nameservers)
2420                 return 0;
2421
2422         provider->nameservers = g_strsplit(nameservers, " ", 0);
2423
2424         return 0;
2425 }
2426
2427 static int route_env_parse(struct vpn_provider *provider, const char *key,
2428                                 int *family, unsigned long *idx,
2429                                 enum vpn_provider_route_type *type)
2430 {
2431         if (!provider)
2432                 return -EINVAL;
2433
2434         DBG("name %s", provider->name);
2435
2436         if (provider->driver && provider->driver->route_env_parse)
2437                 return provider->driver->route_env_parse(provider, key, family, idx,
2438                                 type);
2439
2440         return 0;
2441 }
2442
2443 int vpn_provider_append_route(struct vpn_provider *provider,
2444                                         const char *key, const char *value)
2445 {
2446         struct vpn_route *route;
2447         int ret, family = 0;
2448         unsigned long idx = 0;
2449         enum vpn_provider_route_type type = VPN_PROVIDER_ROUTE_TYPE_NONE;
2450
2451         DBG("key %s value %s", key, value);
2452
2453         ret = route_env_parse(provider, key, &family, &idx, &type);
2454         if (ret < 0)
2455                 return ret;
2456
2457         DBG("idx %lu family %d type %d", idx, family, type);
2458
2459         route = g_hash_table_lookup(provider->routes, GINT_TO_POINTER(idx));
2460         if (!route) {
2461                 route = g_try_new0(struct vpn_route, 1);
2462                 if (!route) {
2463                         connman_error("out of memory");
2464                         return -ENOMEM;
2465                 }
2466
2467                 route->family = family;
2468
2469                 g_hash_table_replace(provider->routes, GINT_TO_POINTER(idx),
2470                                                 route);
2471         }
2472
2473         switch (type) {
2474         case VPN_PROVIDER_ROUTE_TYPE_NONE:
2475                 break;
2476         case VPN_PROVIDER_ROUTE_TYPE_MASK:
2477                 route->netmask = g_strdup(value);
2478                 break;
2479         case VPN_PROVIDER_ROUTE_TYPE_ADDR:
2480                 route->network = g_strdup(value);
2481                 break;
2482         case VPN_PROVIDER_ROUTE_TYPE_GW:
2483                 route->gateway = g_strdup(value);
2484                 break;
2485         }
2486
2487         if (!handle_routes) {
2488                 if (route->netmask && route->gateway &&
2489                                                         route->network)
2490                         provider_schedule_changed(provider);
2491         }
2492
2493         return 0;
2494 }
2495
2496 const char *vpn_provider_get_driver_name(struct vpn_provider *provider)
2497 {
2498         if (!provider->driver)
2499                 return NULL;
2500
2501         return provider->driver->name;
2502 }
2503
2504 const char *vpn_provider_get_save_group(struct vpn_provider *provider)
2505 {
2506         return provider->identifier;
2507 }
2508
2509 static gint compare_priority(gconstpointer a, gconstpointer b)
2510 {
2511         return 0;
2512 }
2513
2514 static void clean_provider(gpointer key, gpointer value, gpointer user_data)
2515 {
2516         struct vpn_provider *provider = value;
2517
2518         if (provider->driver && provider->driver->remove)
2519                 provider->driver->remove(provider);
2520
2521         connection_unregister(provider);
2522 }
2523
2524 int vpn_provider_driver_register(struct vpn_provider_driver *driver)
2525 {
2526         DBG("driver %p name %s", driver, driver->name);
2527
2528         driver_list = g_slist_insert_sorted(driver_list, driver,
2529                                                         compare_priority);
2530         provider_create_all_from_type(driver->name);
2531         return 0;
2532 }
2533
2534 void vpn_provider_driver_unregister(struct vpn_provider_driver *driver)
2535 {
2536         GHashTableIter iter;
2537         gpointer value, key;
2538
2539         DBG("driver %p name %s", driver, driver->name);
2540
2541         driver_list = g_slist_remove(driver_list, driver);
2542
2543         g_hash_table_iter_init(&iter, provider_hash);
2544         while (g_hash_table_iter_next(&iter, &key, &value)) {
2545                 struct vpn_provider *provider = value;
2546
2547                 if (provider && provider->driver &&
2548                                 provider->driver->type == driver->type &&
2549                                 g_strcmp0(provider->driver->name,
2550                                                         driver->name) == 0) {
2551                         provider->driver = NULL;
2552                 }
2553         }
2554 }
2555
2556 const char *vpn_provider_get_name(struct vpn_provider *provider)
2557 {
2558         return provider->name;
2559 }
2560
2561 const char *vpn_provider_get_host(struct vpn_provider *provider)
2562 {
2563         return provider->host;
2564 }
2565
2566 const char *vpn_provider_get_path(struct vpn_provider *provider)
2567 {
2568         return provider->path;
2569 }
2570
2571 void vpn_provider_change_address(struct vpn_provider *provider)
2572 {
2573         switch (provider->family) {
2574         case AF_INET:
2575                 connman_inet_set_address(provider->index,
2576                         __vpn_ipconfig_get_address(provider->ipconfig_ipv4));
2577                 break;
2578         case AF_INET6:
2579                 connman_inet_set_ipv6_address(provider->index,
2580                         __vpn_ipconfig_get_address(provider->ipconfig_ipv6));
2581                 break;
2582         default:
2583                 break;
2584         }
2585 }
2586
2587 void vpn_provider_clear_address(struct vpn_provider *provider, int family)
2588 {
2589         const char *address;
2590         unsigned char len;
2591
2592         DBG("provider %p family %d ipv4 %p ipv6 %p", provider, family,
2593                 provider->prev_ipv4_addr, provider->prev_ipv6_addr);
2594
2595         switch (family) {
2596         case AF_INET:
2597                 if (provider->prev_ipv4_addr) {
2598                         connman_ipaddress_get_ip(provider->prev_ipv4_addr,
2599                                                 &address, &len);
2600
2601                         DBG("ipv4 %s/%d", address, len);
2602
2603                         connman_inet_clear_address(provider->index,
2604                                         provider->prev_ipv4_addr);
2605                         connman_ipaddress_free(provider->prev_ipv4_addr);
2606                         provider->prev_ipv4_addr = NULL;
2607                 }
2608                 break;
2609         case AF_INET6:
2610                 if (provider->prev_ipv6_addr) {
2611                         connman_ipaddress_get_ip(provider->prev_ipv6_addr,
2612                                                 &address, &len);
2613
2614                         DBG("ipv6 %s/%d", address, len);
2615
2616                         connman_inet_clear_ipv6_address(provider->index,
2617                                                         address, len);
2618
2619                         connman_ipaddress_free(provider->prev_ipv6_addr);
2620                         provider->prev_ipv6_addr = NULL;
2621                 }
2622                 break;
2623         default:
2624                 break;
2625         }
2626 }
2627
2628 static int agent_probe(struct connman_agent *agent)
2629 {
2630         DBG("agent %p", agent);
2631         return 0;
2632 }
2633
2634 static void agent_remove(struct connman_agent *agent)
2635 {
2636         DBG("agent %p", agent);
2637 }
2638
2639 static struct connman_agent_driver agent_driver = {
2640         .name           = "vpn",
2641         .interface      = VPN_AGENT_INTERFACE,
2642         .probe          = agent_probe,
2643         .remove         = agent_remove,
2644 };
2645
2646 static void remove_unprovisioned_providers(void)
2647 {
2648         gchar **providers;
2649         GKeyFile *keyfile, *configkeyfile;
2650         char *file, *section;
2651         int i = 0;
2652
2653         providers = __connman_storage_get_providers();
2654         if (!providers)
2655                 return;
2656
2657         for (; providers[i]; i++) {
2658                 char *group = providers[i] + sizeof("provider_") - 1;
2659                 file = section = NULL;
2660                 keyfile = configkeyfile = NULL;
2661
2662                 keyfile = __connman_storage_load_provider(group);
2663                 if (!keyfile)
2664                         continue;
2665
2666                 file = __vpn_config_get_string(keyfile, group,
2667                                         "Config.file", NULL);
2668                 if (!file)
2669                         goto next;
2670
2671                 section = __vpn_config_get_string(keyfile, group,
2672                                         "Config.ident", NULL);
2673                 if (!section)
2674                         goto next;
2675
2676                 configkeyfile = __connman_storage_load_provider_config(file);
2677                 if (!configkeyfile) {
2678                         /*
2679                          * Config file is missing, remove the provisioned
2680                          * service.
2681                          */
2682                         __connman_storage_remove_provider(group);
2683                         goto next;
2684                 }
2685
2686                 if (!g_key_file_has_group(configkeyfile, section))
2687                         /*
2688                          * Config section is missing, remove the provisioned
2689                          * service.
2690                          */
2691                         __connman_storage_remove_provider(group);
2692
2693         next:
2694                 if (keyfile)
2695                         g_key_file_free(keyfile);
2696
2697                 if (configkeyfile)
2698                         g_key_file_free(configkeyfile);
2699
2700                 g_free(section);
2701                 g_free(file);
2702         }
2703
2704         g_strfreev(providers);
2705 }
2706
2707 int __vpn_provider_init(bool do_routes)
2708 {
2709         int err;
2710
2711         DBG("");
2712
2713         handle_routes = do_routes;
2714
2715         err = connman_agent_driver_register(&agent_driver);
2716         if (err < 0) {
2717                 connman_error("Cannot register agent driver for %s",
2718                                                 agent_driver.name);
2719                 return err;
2720         }
2721
2722         connection = connman_dbus_get_connection();
2723
2724         remove_unprovisioned_providers();
2725
2726         provider_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
2727                                                 NULL, unregister_provider);
2728         return 0;
2729 }
2730
2731 void __vpn_provider_cleanup(void)
2732 {
2733         DBG("");
2734
2735         connman_agent_driver_unregister(&agent_driver);
2736
2737         g_hash_table_foreach(provider_hash, clean_provider, NULL);
2738
2739         g_hash_table_destroy(provider_hash);
2740         provider_hash = NULL;
2741
2742         dbus_connection_unref(connection);
2743 }