vpn/vpn-provider.c

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