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
1195         str = state2string(state);
1196         DBG("provider %p state %s/%d", provider, str, state);
1197         if (str == NULL)
1198                 return -EINVAL;
1199
1200         provider->state = state;
1201
1202         if (state == VPN_PROVIDER_STATE_READY) {
1203                 connman_dbus_property_changed_basic(provider->path,
1204                                         VPN_CONNECTION_INTERFACE, "Index",
1205                                         DBUS_TYPE_INT32, &provider->index);
1206
1207                 if (provider->family == AF_INET)
1208                         connman_dbus_property_changed_dict(provider->path,
1209                                         VPN_CONNECTION_INTERFACE, "IPv4",
1210                                         append_ipv4, provider);
1211                 else if (provider->family == AF_INET6)
1212                         connman_dbus_property_changed_dict(provider->path,
1213                                         VPN_CONNECTION_INTERFACE, "IPv6",
1214                                         append_ipv6, provider);
1215         }
1216
1217         connman_dbus_property_changed_basic(provider->path,
1218                                         VPN_CONNECTION_INTERFACE, "State",
1219                                         DBUS_TYPE_STRING, &str);
1220         /*
1221          * We do not stay in failure state as clients like connmand can
1222          * get confused about our current state.
1223          */
1224         if (provider->state == VPN_PROVIDER_STATE_FAILURE)
1225                 provider->state = VPN_PROVIDER_STATE_IDLE;
1226
1227         return 0;
1228 }
1229
1230 static void append_nameservers(DBusMessageIter *iter, char **servers)
1231 {
1232         int i;
1233
1234         DBG("%p", servers);
1235
1236         for (i = 0; servers[i] != NULL; i++) {
1237                 DBG("servers[%d] %s", i, servers[i]);
1238                 dbus_message_iter_append_basic(iter,
1239                                         DBUS_TYPE_STRING, &servers[i]);
1240         }
1241 }
1242
1243 static void append_dns(DBusMessageIter *iter, void *user_data)
1244 {
1245         struct vpn_provider *provider = user_data;
1246
1247         if (provider->nameservers != NULL)
1248                 append_nameservers(iter, provider->nameservers);
1249 }
1250
1251 static void append_state(DBusMessageIter *iter,
1252                                         struct vpn_provider *provider)
1253 {
1254         char *str;
1255
1256         switch (provider->state) {
1257         case VPN_PROVIDER_STATE_UNKNOWN:
1258         case VPN_PROVIDER_STATE_IDLE:
1259                 str = "idle";
1260                 break;
1261         case VPN_PROVIDER_STATE_CONNECT:
1262                 str = "configuration";
1263                 break;
1264         case VPN_PROVIDER_STATE_READY:
1265                 str = "ready";
1266                 break;
1267         case VPN_PROVIDER_STATE_DISCONNECT:
1268                 str = "disconnect";
1269                 break;
1270         case VPN_PROVIDER_STATE_FAILURE:
1271                 str = "failure";
1272                 break;
1273         }
1274
1275         connman_dbus_dict_append_basic(iter, "State",
1276                                 DBUS_TYPE_STRING, &str);
1277 }
1278
1279 static void append_properties(DBusMessageIter *iter,
1280                                         struct vpn_provider *provider)
1281 {
1282         DBusMessageIter dict;
1283
1284         connman_dbus_dict_open(iter, &dict);
1285
1286         append_state(&dict, provider);
1287
1288         if (provider->type != NULL)
1289                 connman_dbus_dict_append_basic(&dict, "Type",
1290                                         DBUS_TYPE_STRING, &provider->type);
1291
1292         if (provider->name != NULL)
1293                 connman_dbus_dict_append_basic(&dict, "Name",
1294                                         DBUS_TYPE_STRING, &provider->name);
1295
1296         if (provider->host != NULL)
1297                 connman_dbus_dict_append_basic(&dict, "Host",
1298                                         DBUS_TYPE_STRING, &provider->host);
1299         if (provider->index >= 0)
1300                 connman_dbus_dict_append_basic(&dict, "Index",
1301                                         DBUS_TYPE_INT32, &provider->index);
1302         if (provider->domain != NULL)
1303                 connman_dbus_dict_append_basic(&dict, "Domain",
1304                                         DBUS_TYPE_STRING, &provider->domain);
1305
1306         if (provider->family == AF_INET)
1307                 connman_dbus_dict_append_dict(&dict, "IPv4", append_ipv4,
1308                                                 provider);
1309         else if (provider->family == AF_INET6)
1310                 connman_dbus_dict_append_dict(&dict, "IPv6", append_ipv6,
1311                                                 provider);
1312
1313         connman_dbus_dict_append_array(&dict, "Nameservers",
1314                                 DBUS_TYPE_STRING, append_dns, provider);
1315
1316         connman_dbus_dict_append_array(&dict, "UserRoutes",
1317                                 DBUS_TYPE_DICT_ENTRY, append_routes,
1318                                 provider->user_routes);
1319
1320         connman_dbus_dict_append_array(&dict, "ServerRoutes",
1321                                 DBUS_TYPE_DICT_ENTRY, append_routes,
1322                                 provider->routes);
1323
1324         connman_dbus_dict_close(iter, &dict);
1325 }
1326
1327 static void connection_added_signal(struct vpn_provider *provider)
1328 {
1329         DBusMessage *signal;
1330         DBusMessageIter iter;
1331
1332         signal = dbus_message_new_signal(VPN_MANAGER_PATH,
1333                         VPN_MANAGER_INTERFACE, "ConnectionAdded");
1334         if (signal == NULL)
1335                 return;
1336
1337         dbus_message_iter_init_append(signal, &iter);
1338         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
1339                                                         &provider->path);
1340         append_properties(&iter, provider);
1341
1342         dbus_connection_send(connection, signal, NULL);
1343         dbus_message_unref(signal);
1344 }
1345
1346 static connman_bool_t check_host(char **hosts, char *host)
1347 {
1348         int i;
1349
1350         if (hosts == NULL)
1351                 return FALSE;
1352
1353         for (i = 0; hosts[i] != NULL; i++) {
1354                 if (g_strcmp0(hosts[i], host) == 0)
1355                         return TRUE;
1356         }
1357
1358         return FALSE;
1359 }
1360
1361 static void provider_append_routes(gpointer key, gpointer value,
1362                                         gpointer user_data)
1363 {
1364         struct vpn_route *route = value;
1365         struct vpn_provider *provider = user_data;
1366         int index = provider->index;
1367
1368         if (handle_routes == FALSE)
1369                 return;
1370
1371         /*
1372          * If the VPN administrator/user has given a route to
1373          * VPN server, then we must discard that because the
1374          * server cannot be contacted via VPN tunnel.
1375          */
1376         if (check_host(provider->host_ip, route->network) == TRUE) {
1377                 DBG("Discarding VPN route to %s via %s at index %d",
1378                         route->network, route->gateway, index);
1379                 return;
1380         }
1381
1382         if (route->family == AF_INET6) {
1383                 unsigned char prefix_len = atoi(route->netmask);
1384
1385                 connman_inet_add_ipv6_network_route(index, route->network,
1386                                                         route->gateway,
1387                                                         prefix_len);
1388         } else {
1389                 connman_inet_add_network_route(index, route->network,
1390                                                 route->gateway,
1391                                                 route->netmask);
1392         }
1393 }
1394
1395 static int set_connected(struct vpn_provider *provider,
1396                                         connman_bool_t connected)
1397 {
1398         struct vpn_ipconfig *ipconfig;
1399
1400         DBG("provider %p id %s connected %d", provider,
1401                                         provider->identifier, connected);
1402
1403         if (connected == TRUE) {
1404                 if (provider->family == AF_INET6)
1405                         ipconfig = provider->ipconfig_ipv6;
1406                 else
1407                         ipconfig = provider->ipconfig_ipv4;
1408
1409                 __vpn_ipconfig_address_add(ipconfig, provider->family);
1410
1411                 if (handle_routes == TRUE)
1412                         __vpn_ipconfig_gateway_add(ipconfig, provider->family);
1413
1414                 provider_indicate_state(provider,
1415                                         VPN_PROVIDER_STATE_READY);
1416
1417                 g_hash_table_foreach(provider->routes, provider_append_routes,
1418                                         provider);
1419
1420                 g_hash_table_foreach(provider->user_routes,
1421                                         provider_append_routes, provider);
1422
1423         } else {
1424                 provider_indicate_state(provider,
1425                                         VPN_PROVIDER_STATE_DISCONNECT);
1426
1427                 provider_indicate_state(provider,
1428                                         VPN_PROVIDER_STATE_IDLE);
1429         }
1430
1431         return 0;
1432 }
1433
1434 int vpn_provider_set_state(struct vpn_provider *provider,
1435                                         enum vpn_provider_state state)
1436 {
1437         if (provider == NULL)
1438                 return -EINVAL;
1439
1440         switch (state) {
1441         case VPN_PROVIDER_STATE_UNKNOWN:
1442                 return -EINVAL;
1443         case VPN_PROVIDER_STATE_IDLE:
1444                 return set_connected(provider, FALSE);
1445         case VPN_PROVIDER_STATE_CONNECT:
1446                 return provider_indicate_state(provider, state);
1447         case VPN_PROVIDER_STATE_READY:
1448                 return set_connected(provider, TRUE);
1449         case VPN_PROVIDER_STATE_DISCONNECT:
1450                 return provider_indicate_state(provider, state);
1451         case VPN_PROVIDER_STATE_FAILURE:
1452                 return provider_indicate_state(provider, state);
1453         }
1454         return -EINVAL;
1455 }
1456
1457 int vpn_provider_indicate_error(struct vpn_provider *provider,
1458                                         enum vpn_provider_error error)
1459 {
1460         DBG("provider %p id %s error %d", provider, provider->identifier,
1461                                                                         error);
1462
1463         switch (error) {
1464         case VPN_PROVIDER_ERROR_LOGIN_FAILED:
1465                 break;
1466         case VPN_PROVIDER_ERROR_AUTH_FAILED:
1467                 vpn_provider_set_state(provider, VPN_PROVIDER_STATE_FAILURE);
1468                 break;
1469         case VPN_PROVIDER_ERROR_CONNECT_FAILED:
1470                 break;
1471         default:
1472                 break;
1473         }
1474
1475         return 0;
1476 }
1477
1478 static int connection_unregister(struct vpn_provider *provider)
1479 {
1480         DBG("provider %p path %s", provider, provider->path);
1481
1482         if (provider->path == NULL)
1483                 return -EALREADY;
1484
1485         g_dbus_unregister_interface(connection, provider->path,
1486                                 VPN_CONNECTION_INTERFACE);
1487
1488         g_free(provider->path);
1489         provider->path = NULL;
1490
1491         return 0;
1492 }
1493
1494 static int connection_register(struct vpn_provider *provider)
1495 {
1496         DBG("provider %p path %s", provider, provider->path);
1497
1498         if (provider->path != NULL)
1499                 return -EALREADY;
1500
1501         provider->path = g_strdup_printf("%s/connection/%s", VPN_PATH,
1502                                                 provider->identifier);
1503
1504         g_dbus_register_interface(connection, provider->path,
1505                                 VPN_CONNECTION_INTERFACE,
1506                                 connection_methods, connection_signals,
1507                                 NULL, provider, NULL);
1508
1509         return 0;
1510 }
1511
1512 static void unregister_provider(gpointer data)
1513 {
1514         struct vpn_provider *provider = data;
1515
1516         configuration_count_del();
1517
1518         connection_unregister(provider);
1519
1520         vpn_provider_unref(provider);
1521 }
1522
1523 static void provider_initialize(struct vpn_provider *provider)
1524 {
1525         DBG("provider %p", provider);
1526
1527         provider->index = 0;
1528         provider->fd = -1;
1529         provider->name = NULL;
1530         provider->type = NULL;
1531         provider->domain = NULL;
1532         provider->identifier = NULL;
1533         provider->user_networks = NULL;
1534         provider->routes = g_hash_table_new_full(g_direct_hash, g_direct_equal,
1535                                         NULL, free_route);
1536         provider->user_routes = g_hash_table_new_full(g_str_hash, g_str_equal,
1537                                         g_free, free_route);
1538         provider->setting_strings = g_hash_table_new_full(g_str_hash,
1539                                         g_str_equal, g_free, free_setting);
1540 }
1541
1542 static struct vpn_provider *vpn_provider_new(void)
1543 {
1544         struct vpn_provider *provider;
1545
1546         provider = g_try_new0(struct vpn_provider, 1);
1547         if (provider == NULL)
1548                 return NULL;
1549
1550         provider->refcount = 1;
1551
1552         DBG("provider %p", provider);
1553         provider_initialize(provider);
1554
1555         return provider;
1556 }
1557
1558 static struct vpn_provider *vpn_provider_get(const char *identifier)
1559 {
1560         struct vpn_provider *provider;
1561
1562         provider = g_hash_table_lookup(provider_hash, identifier);
1563         if (provider != NULL)
1564                 return provider;
1565
1566         provider = vpn_provider_new();
1567         if (provider == NULL)
1568                 return NULL;
1569
1570         DBG("provider %p", provider);
1571
1572         provider->identifier = g_strdup(identifier);
1573
1574         g_hash_table_insert(provider_hash, provider->identifier, provider);
1575
1576         configuration_count_add();
1577
1578         return provider;
1579 }
1580
1581 static void provider_dbus_ident(char *ident)
1582 {
1583         int i, len = strlen(ident);
1584
1585         for (i = 0; i < len; i++) {
1586                 if (ident[i] >= '0' && ident[i] <= '9')
1587                         continue;
1588                 if (ident[i] >= 'a' && ident[i] <= 'z')
1589                         continue;
1590                 if (ident[i] >= 'A' && ident[i] <= 'Z')
1591                         continue;
1592                 ident[i] = '_';
1593         }
1594 }
1595
1596 static struct vpn_provider *provider_create_from_keyfile(GKeyFile *keyfile,
1597                 const char *ident)
1598 {
1599         struct vpn_provider *provider;
1600
1601         if (keyfile == NULL || ident == NULL)
1602                 return NULL;
1603
1604         provider = __vpn_provider_lookup(ident);
1605         if (provider == NULL) {
1606                 provider = vpn_provider_get(ident);
1607                 if (provider == NULL) {
1608                         DBG("can not create provider");
1609                         return NULL;
1610                 }
1611
1612                 provider_load_from_keyfile(provider, keyfile);
1613
1614                 if (provider->name == NULL || provider->host == NULL ||
1615                                 provider->domain == NULL) {
1616                         DBG("cannot get name, host or domain");
1617                         vpn_provider_unref(provider);
1618                         return NULL;
1619                 }
1620
1621                 if (provider_register(provider) == 0)
1622                         connection_register(provider);
1623         }
1624         return provider;
1625 }
1626
1627 static void provider_create_all_from_type(const char *provider_type)
1628 {
1629         unsigned int i;
1630         char **providers;
1631         char *id, *type;
1632         GKeyFile *keyfile;
1633
1634         DBG("provider type %s", provider_type);
1635
1636         providers = __connman_storage_get_providers();
1637
1638         if (providers == NULL)
1639                 return;
1640
1641         for (i = 0; providers[i] != NULL; i+=1) {
1642
1643                 if (strncmp(providers[i], "provider_", 9) != 0)
1644                         continue;
1645
1646                 id = providers[i] + 9;
1647                 keyfile = __connman_storage_load_provider(id);
1648
1649                 if (keyfile == NULL)
1650                         continue;
1651
1652                 type = g_key_file_get_string(keyfile, id, "Type", NULL);
1653
1654                 DBG("keyfile %p id %s type %s", keyfile, id, type);
1655
1656                 if (strcmp(provider_type, type) != 0) {
1657                         g_free(type);
1658                         g_key_file_free(keyfile);
1659                         continue;
1660                 }
1661
1662                 if (provider_create_from_keyfile(keyfile, id) == NULL)
1663                         DBG("could not create provider");
1664
1665                 g_free(type);
1666                 g_key_file_free(keyfile);
1667         }
1668         g_strfreev(providers);
1669 }
1670
1671 char *__vpn_provider_create_identifier(const char *host, const char *domain)
1672 {
1673         char *ident;
1674
1675         ident = g_strdup_printf("%s_%s", host, domain);
1676         if (ident == NULL)
1677                 return NULL;
1678
1679         provider_dbus_ident(ident);
1680
1681         return ident;
1682 }
1683
1684 int __vpn_provider_create(DBusMessage *msg)
1685 {
1686         struct vpn_provider *provider;
1687         DBusMessageIter iter, array;
1688         const char *type = NULL, *name = NULL;
1689         const char *host = NULL, *domain = NULL;
1690         GSList *networks = NULL;
1691         char *ident;
1692         int err;
1693
1694         dbus_message_iter_init(msg, &iter);
1695         dbus_message_iter_recurse(&iter, &array);
1696
1697         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
1698                 DBusMessageIter entry, value;
1699                 const char *key;
1700
1701                 dbus_message_iter_recurse(&array, &entry);
1702                 dbus_message_iter_get_basic(&entry, &key);
1703
1704                 dbus_message_iter_next(&entry);
1705                 dbus_message_iter_recurse(&entry, &value);
1706
1707                 switch (dbus_message_iter_get_arg_type(&value)) {
1708                 case DBUS_TYPE_STRING:
1709                         if (g_str_equal(key, "Type") == TRUE)
1710                                 dbus_message_iter_get_basic(&value, &type);
1711                         else if (g_str_equal(key, "Name") == TRUE)
1712                                 dbus_message_iter_get_basic(&value, &name);
1713                         else if (g_str_equal(key, "Host") == TRUE)
1714                                 dbus_message_iter_get_basic(&value, &host);
1715                         else if (g_str_equal(key, "VPN.Domain") == TRUE)
1716                                 dbus_message_iter_get_basic(&value, &domain);
1717                         break;
1718                 case DBUS_TYPE_ARRAY:
1719                         if (g_str_equal(key, "UserRoutes") == TRUE)
1720                                 networks = get_user_networks(&value);
1721                         break;
1722                 }
1723
1724                 dbus_message_iter_next(&array);
1725         }
1726
1727         if (host == NULL || domain == NULL)
1728                 return -EINVAL;
1729
1730         DBG("Type %s name %s networks %p", type, name, networks);
1731
1732         if (type == NULL || name == NULL)
1733                 return -EOPNOTSUPP;
1734
1735         ident = __vpn_provider_create_identifier(host, domain);
1736         DBG("ident %s", ident);
1737
1738         provider = __vpn_provider_lookup(ident);
1739         if (provider == NULL) {
1740                 provider = vpn_provider_get(ident);
1741                 if (provider == NULL) {
1742                         DBG("can not create provider");
1743                         g_free(ident);
1744                         return -EOPNOTSUPP;
1745                 }
1746
1747                 provider->host = g_strdup(host);
1748                 provider->domain = g_strdup(domain);
1749                 provider->name = g_strdup(name);
1750                 provider->type = g_strdup(type);
1751
1752                 if (provider_register(provider) == 0)
1753                         vpn_provider_load(provider);
1754
1755                 provider_resolv_host_addr(provider);
1756         }
1757
1758         if (networks != NULL) {
1759                 g_slist_free_full(provider->user_networks, free_route);
1760                 provider->user_networks = networks;
1761                 set_user_networks(provider, provider->user_networks);
1762         }
1763
1764         dbus_message_iter_init(msg, &iter);
1765         dbus_message_iter_recurse(&iter, &array);
1766
1767         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
1768                 DBusMessageIter entry, value;
1769                 const char *key, *str;
1770
1771                 dbus_message_iter_recurse(&array, &entry);
1772                 dbus_message_iter_get_basic(&entry, &key);
1773
1774                 dbus_message_iter_next(&entry);
1775                 dbus_message_iter_recurse(&entry, &value);
1776
1777                 switch (dbus_message_iter_get_arg_type(&value)) {
1778                 case DBUS_TYPE_STRING:
1779                         dbus_message_iter_get_basic(&value, &str);
1780                         vpn_provider_set_string(provider, key, str);
1781                         break;
1782                 }
1783
1784                 dbus_message_iter_next(&array);
1785         }
1786
1787         g_free(ident);
1788
1789         vpn_provider_save(provider);
1790
1791         err = provider_register(provider);
1792         if (err != 0 && err != -EALREADY)
1793                 return err;
1794
1795         connection_register(provider);
1796
1797         DBG("provider %p index %d path %s", provider, provider->index,
1798                                                         provider->path);
1799
1800         g_dbus_send_reply(connection, msg,
1801                                 DBUS_TYPE_OBJECT_PATH, &provider->path,
1802                                 DBUS_TYPE_INVALID);
1803
1804         connection_added_signal(provider);
1805
1806         return 0;
1807 }
1808
1809 static const char *get_string(GHashTable *settings, const char *key)
1810 {
1811         DBG("settings %p key %s", settings, key);
1812
1813         return g_hash_table_lookup(settings, key);
1814 }
1815
1816 static GSList *parse_user_networks(const char *network_str)
1817 {
1818         GSList *networks = NULL;
1819         char **elems = g_strsplit(network_str, ",", 0);
1820         int i = 0;
1821
1822         if (elems == NULL)
1823                 return NULL;
1824
1825         while (elems[i] != NULL) {
1826                 struct vpn_route *vpn_route;
1827                 char *network, *netmask, *gateway;
1828                 int family;
1829                 char **route;
1830
1831                 route = g_strsplit(elems[i], "/", 0);
1832                 if (route == NULL)
1833                         goto next;
1834
1835                 network = route[0];
1836                 if (network == NULL || network[0] == '\0')
1837                         goto next;
1838
1839                 family = connman_inet_check_ipaddress(network);
1840                 if (family < 0) {
1841                         DBG("Cannot get address family of %s (%d/%s)", network,
1842                                 family, gai_strerror(family));
1843
1844                         goto next;
1845                 }
1846
1847                 switch (family) {
1848                 case AF_INET:
1849                         break;
1850                 case AF_INET6:
1851                         break;
1852                 default:
1853                         DBG("Unsupported address family %d", family);
1854                         goto next;
1855                 }
1856
1857                 netmask = route[1];
1858                 if (netmask == NULL || netmask[0] == '\0')
1859                         goto next;
1860
1861                 gateway = route[2];
1862
1863                 vpn_route = g_try_new0(struct vpn_route, 1);
1864                 if (vpn_route == NULL) {
1865                         g_strfreev(route);
1866                         break;
1867                 }
1868
1869                 vpn_route->family = family;
1870                 vpn_route->network = g_strdup(network);
1871                 vpn_route->netmask = g_strdup(netmask);
1872                 vpn_route->gateway = g_strdup(gateway);
1873
1874                 DBG("route %s/%s%s%s", network, netmask,
1875                         gateway ? " via " : "", gateway ? gateway : "");
1876
1877                 networks = g_slist_prepend(networks, vpn_route);
1878
1879         next:
1880                 g_strfreev(route);
1881                 i++;
1882         }
1883
1884         g_strfreev(elems);
1885
1886         return g_slist_reverse(networks);
1887 }
1888
1889 int __vpn_provider_create_from_config(GHashTable *settings,
1890                                 const char *config_ident,
1891                                 const char *config_entry)
1892 {
1893         struct vpn_provider *provider;
1894         const char *type, *name, *host, *domain, *networks_str;
1895         GSList *networks;
1896         char *ident = NULL;
1897         GHashTableIter hash;
1898         gpointer value, key;
1899         int err;
1900
1901         type = get_string(settings, "Type");
1902         name = get_string(settings, "Name");
1903         host = get_string(settings, "Host");
1904         domain = get_string(settings, "Domain");
1905         networks_str = get_string(settings, "Networks");
1906         networks = parse_user_networks(networks_str);
1907
1908         if (host == NULL || domain == NULL) {
1909                 err = -EINVAL;
1910                 goto fail;
1911         }
1912
1913         DBG("type %s name %s networks %s", type, name, networks_str);
1914
1915         if (type == NULL || name == NULL) {
1916                 err = -EOPNOTSUPP;
1917                 goto fail;
1918         }
1919
1920         ident = __vpn_provider_create_identifier(host, domain);
1921         DBG("ident %s", ident);
1922
1923         provider = __vpn_provider_lookup(ident);
1924         if (provider == NULL) {
1925                 provider = vpn_provider_get(ident);
1926                 if (provider == NULL) {
1927                         DBG("can not create provider");
1928                         err = -EOPNOTSUPP;
1929                         goto fail;
1930                 }
1931
1932                 provider->host = g_strdup(host);
1933                 provider->domain = g_strdup(domain);
1934                 provider->name = g_strdup(name);
1935                 provider->type = g_ascii_strdown(type, -1);
1936
1937                 provider->config_file = g_strdup(config_ident);
1938                 provider->config_entry = g_strdup(config_entry);
1939
1940                 if (provider_register(provider) == 0)
1941                         vpn_provider_load(provider);
1942
1943                 provider_resolv_host_addr(provider);
1944         }
1945
1946         if (networks != NULL) {
1947                 g_slist_free_full(provider->user_networks, free_route);
1948                 provider->user_networks = networks;
1949                 set_user_networks(provider, provider->user_networks);
1950         }
1951
1952         g_hash_table_iter_init(&hash, settings);
1953
1954         while (g_hash_table_iter_next(&hash, &key, &value) == TRUE)
1955                 vpn_provider_set_string(provider, key, value);
1956
1957         vpn_provider_save(provider);
1958
1959         err = provider_register(provider);
1960         if (err != 0 && err != -EALREADY)
1961                 goto fail;
1962
1963         connection_register(provider);
1964
1965         DBG("provider %p index %d path %s", provider, provider->index,
1966                                                         provider->path);
1967
1968         connection_added_signal(provider);
1969
1970         g_free(ident);
1971
1972         return 0;
1973
1974 fail:
1975         g_free(ident);
1976         g_slist_free_full(networks, free_route);
1977
1978         return err;
1979 }
1980
1981 static void append_connection_structs(DBusMessageIter *iter, void *user_data)
1982 {
1983         DBusMessageIter entry;
1984         GHashTableIter hash;
1985         gpointer value, key;
1986
1987         g_hash_table_iter_init(&hash, provider_hash);
1988
1989         while (g_hash_table_iter_next(&hash, &key, &value) == TRUE) {
1990                 struct vpn_provider *provider = value;
1991
1992                 DBG("path %s", provider->path);
1993
1994                 if (provider->identifier == NULL)
1995                         continue;
1996
1997                 dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT,
1998                                 NULL, &entry);
1999                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
2000                                 &provider->path);
2001                 append_properties(&entry, provider);
2002                 dbus_message_iter_close_container(iter, &entry);
2003         }
2004 }
2005
2006 DBusMessage *__vpn_provider_get_connections(DBusMessage *msg)
2007 {
2008         DBusMessage *reply;
2009
2010         DBG("");
2011
2012         reply = dbus_message_new_method_return(msg);
2013         if (reply == NULL)
2014                 return NULL;
2015
2016         __connman_dbus_append_objpath_dict_array(reply,
2017                         append_connection_structs, NULL);
2018
2019         return reply;
2020 }
2021
2022 const char * __vpn_provider_get_ident(struct vpn_provider *provider)
2023 {
2024         if (provider == NULL)
2025                 return NULL;
2026
2027         return provider->identifier;
2028 }
2029
2030 static int set_string(struct vpn_provider *provider,
2031                 const char *key, const char *value, gboolean hide_value)
2032 {
2033         DBG("provider %p key %s value %s", provider, key,
2034                 hide_value ? "<not printed>" : value);
2035
2036         if (g_str_equal(key, "Type") == TRUE) {
2037                 g_free(provider->type);
2038                 provider->type = g_ascii_strdown(value, -1);
2039                 send_value(provider->path, "Type", provider->type);
2040         } else if (g_str_equal(key, "Name") == TRUE) {
2041                 g_free(provider->name);
2042                 provider->name = g_strdup(value);
2043                 send_value(provider->path, "Name", provider->name);
2044         } else if (g_str_equal(key, "Host") == TRUE) {
2045                 g_free(provider->host);
2046                 provider->host = g_strdup(value);
2047                 send_value(provider->path, "Host", provider->host);
2048         } else if (g_str_equal(key, "VPN.Domain") == TRUE) {
2049                 g_free(provider->domain);
2050                 provider->domain = g_strdup(value);
2051                 send_value(provider->path, "Domain", provider->domain);
2052         } else {
2053                 struct vpn_setting *setting;
2054
2055                 setting = g_try_new(struct vpn_setting, 1);
2056                 if (setting == NULL)
2057                         return -ENOMEM;
2058
2059                 setting->value = g_strdup(value);
2060                 setting->hide_value = hide_value;
2061
2062                 if (hide_value == FALSE)
2063                         send_value(provider->path, key, setting->value);
2064
2065                 g_hash_table_replace(provider->setting_strings,
2066                                 g_strdup(key), setting);
2067         }
2068
2069         return 0;
2070 }
2071
2072 int vpn_provider_set_string(struct vpn_provider *provider,
2073                                         const char *key, const char *value)
2074 {
2075         return set_string(provider, key, value, FALSE);
2076 }
2077
2078 int vpn_provider_set_string_hide_value(struct vpn_provider *provider,
2079                                         const char *key, const char *value)
2080 {
2081         return set_string(provider, key, value, TRUE);
2082 }
2083
2084 const char *vpn_provider_get_string(struct vpn_provider *provider,
2085                                                         const char *key)
2086 {
2087         struct vpn_setting *setting;
2088
2089         DBG("provider %p key %s", provider, key);
2090
2091         if (g_str_equal(key, "Type") == TRUE)
2092                 return provider->type;
2093         else if (g_str_equal(key, "Name") == TRUE)
2094                 return provider->name;
2095         else if (g_str_equal(key, "Host") == TRUE)
2096                 return provider->host;
2097         else if (g_str_equal(key, "HostIP") == TRUE) {
2098                 if (provider->host_ip == NULL ||
2099                                 provider->host_ip[0] == NULL)
2100                         return provider->host;
2101                 else
2102                         return provider->host_ip[0];
2103         } else if (g_str_equal(key, "VPN.Domain") == TRUE)
2104                 return provider->domain;
2105
2106         setting = g_hash_table_lookup(provider->setting_strings, key);
2107         if (setting == NULL)
2108                 return NULL;
2109
2110         return setting->value;
2111 }
2112
2113 connman_bool_t __vpn_provider_check_routes(struct vpn_provider *provider)
2114 {
2115         if (provider == NULL)
2116                 return FALSE;
2117
2118         if (provider->user_routes != NULL &&
2119                         g_hash_table_size(provider->user_routes) > 0)
2120                 return TRUE;
2121
2122         if (provider->routes != NULL &&
2123                         g_hash_table_size(provider->routes) > 0)
2124                 return TRUE;
2125
2126         return FALSE;
2127 }
2128
2129 void *vpn_provider_get_data(struct vpn_provider *provider)
2130 {
2131         return provider->driver_data;
2132 }
2133
2134 void vpn_provider_set_data(struct vpn_provider *provider, void *data)
2135 {
2136         provider->driver_data = data;
2137 }
2138
2139 void vpn_provider_set_index(struct vpn_provider *provider, int index)
2140 {
2141         DBG("index %d provider %p", index, provider);
2142
2143         if (provider->ipconfig_ipv4 == NULL) {
2144                 provider->ipconfig_ipv4 = __vpn_ipconfig_create(index,
2145                                                                 AF_INET);
2146                 if (provider->ipconfig_ipv4 == NULL) {
2147                         DBG("Couldnt create ipconfig for IPv4");
2148                         goto done;
2149                 }
2150         }
2151
2152         __vpn_ipconfig_set_index(provider->ipconfig_ipv4, index);
2153
2154         if (provider->ipconfig_ipv6 == NULL) {
2155                 provider->ipconfig_ipv6 = __vpn_ipconfig_create(index,
2156                                                                 AF_INET6);
2157                 if (provider->ipconfig_ipv6 == NULL) {
2158                         DBG("Couldnt create ipconfig for IPv6");
2159                         goto done;
2160                 }
2161         }
2162
2163         __vpn_ipconfig_set_index(provider->ipconfig_ipv6, index);
2164
2165 done:
2166         provider->index = index;
2167 }
2168
2169 int vpn_provider_get_index(struct vpn_provider *provider)
2170 {
2171         return provider->index;
2172 }
2173
2174 int vpn_provider_set_ipaddress(struct vpn_provider *provider,
2175                                         struct connman_ipaddress *ipaddress)
2176 {
2177         struct vpn_ipconfig *ipconfig = NULL;
2178
2179         switch (ipaddress->family) {
2180         case AF_INET:
2181                 ipconfig = provider->ipconfig_ipv4;
2182                 break;
2183         case AF_INET6:
2184                 ipconfig = provider->ipconfig_ipv6;
2185                 break;
2186         default:
2187                 break;
2188         }
2189
2190         DBG("provider %p ipconfig %p family %d", provider, ipconfig,
2191                                                         ipaddress->family);
2192
2193         if (ipconfig == NULL)
2194                 return -EINVAL;
2195
2196         provider->family = ipaddress->family;
2197
2198         __vpn_ipconfig_set_local(ipconfig, ipaddress->local);
2199         __vpn_ipconfig_set_peer(ipconfig, ipaddress->peer);
2200         __vpn_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
2201         __vpn_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
2202         __vpn_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
2203
2204         return 0;
2205 }
2206
2207 int vpn_provider_set_pac(struct vpn_provider *provider,
2208                                 const char *pac)
2209 {
2210         DBG("provider %p pac %s", provider, pac);
2211
2212         return 0;
2213 }
2214
2215
2216 int vpn_provider_set_domain(struct vpn_provider *provider,
2217                                         const char *domain)
2218 {
2219         DBG("provider %p domain %s", provider, domain);
2220
2221         g_free(provider->domain);
2222         provider->domain = g_strdup(domain);
2223
2224         return 0;
2225 }
2226
2227 int vpn_provider_set_nameservers(struct vpn_provider *provider,
2228                                         const char *nameservers)
2229 {
2230         DBG("provider %p nameservers %s", provider, nameservers);
2231
2232         g_strfreev(provider->nameservers);
2233         provider->nameservers = NULL;
2234
2235         if (nameservers == NULL)
2236                 return 0;
2237
2238         provider->nameservers = g_strsplit(nameservers, " ", 0);
2239
2240         return 0;
2241 }
2242
2243 enum provider_route_type {
2244         PROVIDER_ROUTE_TYPE_NONE = 0,
2245         PROVIDER_ROUTE_TYPE_MASK = 1,
2246         PROVIDER_ROUTE_TYPE_ADDR = 2,
2247         PROVIDER_ROUTE_TYPE_GW   = 3,
2248 };
2249
2250 static int route_env_parse(struct vpn_provider *provider, const char *key,
2251                                 int *family, unsigned long *idx,
2252                                 enum provider_route_type *type)
2253 {
2254         char *end;
2255         const char *start;
2256
2257         DBG("name %s", provider->name);
2258
2259         if (!strcmp(provider->type, "openvpn")) {
2260                 if (g_str_has_prefix(key, "route_network_") == TRUE) {
2261                         start = key + strlen("route_network_");
2262                         *type = PROVIDER_ROUTE_TYPE_ADDR;
2263                 } else if (g_str_has_prefix(key, "route_netmask_") == TRUE) {
2264                         start = key + strlen("route_netmask_");
2265                         *type = PROVIDER_ROUTE_TYPE_MASK;
2266                 } else if (g_str_has_prefix(key, "route_gateway_") == TRUE) {
2267                         start = key + strlen("route_gateway_");
2268                         *type = PROVIDER_ROUTE_TYPE_GW;
2269                 } else
2270                         return -EINVAL;
2271
2272                 *family = AF_INET;
2273                 *idx = g_ascii_strtoull(start, &end, 10);
2274
2275         } else if (!strcmp(provider->type, "openconnect")) {
2276                 if (g_str_has_prefix(key, "CISCO_SPLIT_INC_") == TRUE) {
2277                         *family = AF_INET;
2278                         start = key + strlen("CISCO_SPLIT_INC_");
2279                 } else if (g_str_has_prefix(key,
2280                                         "CISCO_IPV6_SPLIT_INC_") == TRUE) {
2281                         *family = AF_INET6;
2282                         start = key + strlen("CISCO_IPV6_SPLIT_INC_");
2283                 } else
2284                         return -EINVAL;
2285
2286                 *idx = g_ascii_strtoull(start, &end, 10);
2287
2288                 if (strncmp(end, "_ADDR", 5) == 0)
2289                         *type = PROVIDER_ROUTE_TYPE_ADDR;
2290                 else if (strncmp(end, "_MASK", 5) == 0)
2291                         *type = PROVIDER_ROUTE_TYPE_MASK;
2292                 else if (strncmp(end, "_MASKLEN", 8) == 0 &&
2293                                 *family == AF_INET6) {
2294                         *type = PROVIDER_ROUTE_TYPE_MASK;
2295                 } else
2296                         return -EINVAL;
2297         }
2298
2299         return 0;
2300 }
2301
2302 int vpn_provider_append_route(struct vpn_provider *provider,
2303                                         const char *key, const char *value)
2304 {
2305         struct vpn_route *route;
2306         int ret, family = 0;
2307         unsigned long idx = 0;
2308         enum provider_route_type type = PROVIDER_ROUTE_TYPE_NONE;
2309
2310         DBG("key %s value %s", key, value);
2311
2312         ret = route_env_parse(provider, key, &family, &idx, &type);
2313         if (ret < 0)
2314                 return ret;
2315
2316         DBG("idx %lu family %d type %d", idx, family, type);
2317
2318         route = g_hash_table_lookup(provider->routes, GINT_TO_POINTER(idx));
2319         if (route == NULL) {
2320                 route = g_try_new0(struct vpn_route, 1);
2321                 if (route == NULL) {
2322                         connman_error("out of memory");
2323                         return -ENOMEM;
2324                 }
2325
2326                 route->family = family;
2327
2328                 g_hash_table_replace(provider->routes, GINT_TO_POINTER(idx),
2329                                                 route);
2330         }
2331
2332         switch (type) {
2333         case PROVIDER_ROUTE_TYPE_NONE:
2334                 break;
2335         case PROVIDER_ROUTE_TYPE_MASK:
2336                 route->netmask = g_strdup(value);
2337                 break;
2338         case PROVIDER_ROUTE_TYPE_ADDR:
2339                 route->network = g_strdup(value);
2340                 break;
2341         case PROVIDER_ROUTE_TYPE_GW:
2342                 route->gateway = g_strdup(value);
2343                 break;
2344         }
2345
2346         if (handle_routes == FALSE) {
2347                 if (route->netmask != NULL && route->gateway != NULL &&
2348                                                         route->network != NULL)
2349                         provider_schedule_changed(provider);
2350         }
2351
2352         return 0;
2353 }
2354
2355 const char *vpn_provider_get_driver_name(struct vpn_provider *provider)
2356 {
2357         if (provider->driver == NULL)
2358                 return NULL;
2359
2360         return provider->driver->name;
2361 }
2362
2363 const char *vpn_provider_get_save_group(struct vpn_provider *provider)
2364 {
2365         return provider->identifier;
2366 }
2367
2368 static gint compare_priority(gconstpointer a, gconstpointer b)
2369 {
2370         return 0;
2371 }
2372
2373 static void clean_provider(gpointer key, gpointer value, gpointer user_data)
2374 {
2375         struct vpn_provider *provider = value;
2376
2377         if (provider->driver != NULL && provider->driver->remove)
2378                 provider->driver->remove(provider);
2379
2380         connection_unregister(provider);
2381 }
2382
2383 int vpn_provider_driver_register(struct vpn_provider_driver *driver)
2384 {
2385         DBG("driver %p name %s", driver, driver->name);
2386
2387         driver_list = g_slist_insert_sorted(driver_list, driver,
2388                                                         compare_priority);
2389         provider_create_all_from_type(driver->name);
2390         return 0;
2391 }
2392
2393 void vpn_provider_driver_unregister(struct vpn_provider_driver *driver)
2394 {
2395         GHashTableIter iter;
2396         gpointer value, key;
2397
2398         DBG("driver %p name %s", driver, driver->name);
2399
2400         driver_list = g_slist_remove(driver_list, driver);
2401
2402         g_hash_table_iter_init(&iter, provider_hash);
2403         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
2404                 struct vpn_provider *provider = value;
2405
2406                 if (provider != NULL && provider->driver != NULL &&
2407                                 provider->driver->type == driver->type &&
2408                                 g_strcmp0(provider->driver->name,
2409                                                         driver->name) == 0) {
2410                         provider->driver = NULL;
2411                 }
2412         }
2413 }
2414
2415 static gboolean check_vpn_count(gpointer data)
2416 {
2417         if (configuration_count == 0) {
2418                 connman_info("No VPN configurations found, quitting.");
2419                 raise(SIGTERM);
2420         }
2421
2422         return FALSE;
2423 }
2424
2425 void __vpn_provider_check_connections(void)
2426 {
2427         /*
2428          * If we were started when there is no providers configured,
2429          * then just quit. This happens when connman starts and its
2430          * vpn plugin asks connman-vpnd if it has any connections
2431          * configured. If there are none, then we can stop the vpn
2432          * daemon.
2433          */
2434         g_timeout_add(1000, check_vpn_count, NULL);
2435 }
2436
2437 const char *vpn_provider_get_name(struct vpn_provider *provider)
2438 {
2439         return provider->name;
2440 }
2441
2442 const char *vpn_provider_get_host(struct vpn_provider *provider)
2443 {
2444         return provider->host;
2445 }
2446
2447 const char *vpn_provider_get_path(struct vpn_provider *provider)
2448 {
2449         return provider->path;
2450 }
2451
2452 static int agent_probe(struct connman_agent *agent)
2453 {
2454         DBG("agent %p", agent);
2455         return 0;
2456 }
2457
2458 static void agent_remove(struct connman_agent *agent)
2459 {
2460         DBG("agent %p", agent);
2461 }
2462
2463 static struct connman_agent_driver agent_driver = {
2464         .name           = "vpn",
2465         .interface      = VPN_AGENT_INTERFACE,
2466         .probe          = agent_probe,
2467         .remove         = agent_remove,
2468 };
2469
2470 static void remove_unprovisioned_providers()
2471 {
2472         gchar **providers;
2473         GKeyFile *keyfile, *configkeyfile;
2474         char *file, *section;
2475         int i = 0;
2476
2477         providers = __connman_storage_get_providers();
2478         if (providers == NULL)
2479                 return;
2480
2481         for (; providers[i] != NULL; i++) {
2482                 char *group = providers[i] + sizeof("provider_") - 1;
2483                 file = section = NULL;
2484                 keyfile = configkeyfile = NULL;
2485
2486                 keyfile = __connman_storage_load_provider(group);
2487                 if (keyfile == NULL)
2488                         continue;
2489
2490                 file = g_key_file_get_string(keyfile, group,
2491                                         "Config.file", NULL);
2492                 if (file == NULL)
2493                         goto next;
2494
2495                 section = g_key_file_get_string(keyfile, group,
2496                                         "Config.ident", NULL);
2497                 if (section == NULL)
2498                         goto next;
2499
2500                 configkeyfile = __connman_storage_load_provider_config(file);
2501                 if (configkeyfile == NULL) {
2502                         /*
2503                          * Config file is missing, remove the provisioned
2504                          * service.
2505                          */
2506                         __connman_storage_remove_provider(group);
2507                         goto next;
2508                 }
2509
2510                 if (g_key_file_has_group(configkeyfile, section) == FALSE)
2511                         /*
2512                          * Config section is missing, remove the provisioned
2513                          * service.
2514                          */
2515                         __connman_storage_remove_provider(group);
2516
2517         next:
2518                 if (keyfile != NULL)
2519                         g_key_file_free(keyfile);
2520
2521                 if (configkeyfile != NULL)
2522                         g_key_file_free(configkeyfile);
2523
2524                 g_free(section);
2525                 g_free(file);
2526         }
2527
2528         g_strfreev(providers);
2529 }
2530
2531 int __vpn_provider_init(gboolean do_routes)
2532 {
2533         int err;
2534
2535         DBG("");
2536
2537         handle_routes = do_routes;
2538
2539         err = connman_agent_driver_register(&agent_driver);
2540         if (err < 0) {
2541                 connman_error("Cannot register agent driver for %s",
2542                                                 agent_driver.name);
2543                 return err;
2544         }
2545
2546         connection = connman_dbus_get_connection();
2547
2548         remove_unprovisioned_providers();
2549
2550         provider_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
2551                                                 NULL, unregister_provider);
2552         return 0;
2553 }
2554
2555 void __vpn_provider_cleanup(void)
2556 {
2557         DBG("");
2558
2559         g_hash_table_foreach(provider_hash, clean_provider, NULL);
2560
2561         g_hash_table_destroy(provider_hash);
2562         provider_hash = NULL;
2563
2564         connman_agent_driver_unregister(&agent_driver);
2565
2566         dbus_connection_unref(connection);
2567 }