5 * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
6 * Copyright (C) 2019 Jolla Ltd. All rights reserved.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
32 #include <connman/log.h>
33 #include <gweb/gresolv.h>
36 #include "../src/connman.h"
37 #include "connman/agent.h"
38 #include "connman/vpn-dbus.h"
39 #include "vpn-provider.h"
41 #include "plugins/vpn.h"
43 static DBusConnection *connection;
44 static GHashTable *provider_hash;
45 static GSList *driver_list;
46 static int configuration_count;
65 enum vpn_provider_state state;
73 bool do_split_routing;
75 struct vpn_provider_driver *driver;
77 GHashTable *setting_strings;
78 GHashTable *user_routes;
79 GSList *user_networks;
82 struct vpn_ipconfig *ipconfig_ipv4;
83 struct vpn_ipconfig *ipconfig_ipv6;
89 struct connman_ipaddress *prev_ipv4_addr;
90 struct connman_ipaddress *prev_ipv6_addr;
92 unsigned int auth_error_counter;
93 unsigned int conn_error_counter;
94 unsigned int signal_watch;
97 static void append_properties(DBusMessageIter *iter,
98 struct vpn_provider *provider);
99 static int vpn_provider_save(struct vpn_provider *provider);
101 static void free_route(gpointer data)
103 struct vpn_route *route = data;
105 g_free(route->network);
106 g_free(route->netmask);
107 g_free(route->gateway);
112 static void free_setting(gpointer data)
114 struct vpn_setting *setting = data;
116 g_free(setting->value);
120 static void append_route(DBusMessageIter *iter, void *user_data)
122 struct vpn_route *route = user_data;
123 DBusMessageIter item;
126 connman_dbus_dict_open(iter, &item);
131 if (route->family == AF_INET)
133 else if (route->family == AF_INET6)
137 connman_dbus_dict_append_basic(&item, "ProtocolFamily",
138 DBUS_TYPE_INT32, &family);
141 connman_dbus_dict_append_basic(&item, "Network",
142 DBUS_TYPE_STRING, &route->network);
145 connman_dbus_dict_append_basic(&item, "Netmask",
146 DBUS_TYPE_STRING, &route->netmask);
149 connman_dbus_dict_append_basic(&item, "Gateway",
150 DBUS_TYPE_STRING, &route->gateway);
153 connman_dbus_dict_close(iter, &item);
156 static void append_routes(DBusMessageIter *iter, void *user_data)
158 GHashTable *routes = user_data;
163 append_route(iter, NULL);
167 g_hash_table_iter_init(&hash, routes);
169 while (g_hash_table_iter_next(&hash, &key, &value)) {
170 DBusMessageIter dict;
172 dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL,
174 append_route(&dict, value);
175 dbus_message_iter_close_container(iter, &dict);
179 static void send_routes(struct vpn_provider *provider, GHashTable *routes,
182 connman_dbus_property_changed_array(provider->path,
183 VPN_CONNECTION_INTERFACE,
185 DBUS_TYPE_DICT_ENTRY,
190 static int provider_routes_changed(struct vpn_provider *provider)
192 DBG("provider %p", provider);
194 send_routes(provider, provider->routes, "ServerRoutes");
200 * Sort vpn_route struct based on (similarly to the route key in hash table):
201 * 1) IP protocol number
202 * 2) Network addresses
203 * 3) Netmask addresses
204 * 4) Gateway addresses
206 static gint compare_route(gconstpointer a, gconstpointer b)
208 const struct vpn_route *route_a = a;
209 const struct vpn_route *route_b = b;
212 /* If IP families differ, prefer IPv6 over IPv4 */
213 if (route_a->family != route_b->family) {
214 if (route_a->family < route_b->family)
217 if (route_a->family > route_b->family)
221 /* If networks differ, return */
222 if ((difference = g_strcmp0(route_a->network, route_b->network)))
225 /* If netmasks differ, return. */
226 if ((difference = g_strcmp0(route_a->netmask, route_b->netmask)))
229 return g_strcmp0(route_a->gateway, route_b->gateway);
232 static GSList *read_route_dict(GSList *routes, DBusMessageIter *dicts)
234 DBusMessageIter dict, value, entry;
235 const char *network, *netmask, *gateway;
236 struct vpn_route *route;
240 dbus_message_iter_recurse(dicts, &entry);
242 network = netmask = gateway = NULL;
245 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_DICT_ENTRY) {
247 dbus_message_iter_recurse(&entry, &dict);
248 dbus_message_iter_get_basic(&dict, &key);
250 dbus_message_iter_next(&dict);
251 dbus_message_iter_recurse(&dict, &value);
253 type = dbus_message_iter_get_arg_type(&value);
256 case DBUS_TYPE_INT32:
257 if (g_str_equal(key, "ProtocolFamily"))
258 dbus_message_iter_get_basic(&value, &family);
261 case DBUS_TYPE_STRING:
262 if (g_str_equal(key, "Network"))
263 dbus_message_iter_get_basic(&value, &network);
264 else if (g_str_equal(key, "Netmask"))
265 dbus_message_iter_get_basic(&value, &netmask);
266 else if (g_str_equal(key, "Gateway"))
267 dbus_message_iter_get_basic(&value, &gateway);
271 dbus_message_iter_next(&entry);
274 DBG("family %d network %s netmask %s gateway %s", family,
275 network, netmask, gateway);
277 if (!network || !netmask) {
278 DBG("Ignoring route as network/netmask is missing");
282 route = g_try_new(struct vpn_route, 1);
284 g_slist_free_full(routes, free_route);
288 if (family == PF_UNSPEC) {
289 family = connman_inet_check_ipaddress(network);
291 DBG("Cannot get address family of %s (%d/%s)", network,
292 family, gai_strerror(family));
313 route->family = family;
314 route->network = g_strdup(network);
315 route->netmask = g_strdup(netmask);
316 route->gateway = g_strdup(gateway);
318 routes = g_slist_insert_sorted(routes, route, compare_route);
322 static GSList *get_user_networks(DBusMessageIter *array)
324 DBusMessageIter entry;
327 while (dbus_message_iter_get_arg_type(array) == DBUS_TYPE_ARRAY) {
329 dbus_message_iter_recurse(array, &entry);
331 while (dbus_message_iter_get_arg_type(&entry) ==
333 DBusMessageIter dicts;
335 dbus_message_iter_recurse(&entry, &dicts);
337 while (dbus_message_iter_get_arg_type(&dicts) ==
340 list = read_route_dict(list, &dicts);
341 dbus_message_iter_next(&dicts);
344 dbus_message_iter_next(&entry);
347 dbus_message_iter_next(array);
353 static void set_user_networks(struct vpn_provider *provider, GSList *networks)
357 for (list = networks; list; list = g_slist_next(list)) {
358 struct vpn_route *route = list->data;
360 if (__vpn_provider_append_user_route(provider,
361 route->family, route->network,
362 route->netmask, route->gateway) != 0)
367 static void del_routes(struct vpn_provider *provider)
371 g_hash_table_iter_init(&hash, provider->user_routes);
372 g_hash_table_remove_all(provider->user_routes);
373 g_slist_free_full(provider->user_networks, free_route);
374 provider->user_networks = NULL;
377 static void send_value(const char *path, const char *key, const char *value)
379 const char *empty = "";
387 connman_dbus_property_changed_basic(path,
388 VPN_CONNECTION_INTERFACE,
394 static void send_value_boolean(const char *path, const char *key,
397 connman_dbus_property_changed_basic(path,
398 VPN_CONNECTION_INTERFACE,
404 static gboolean provider_send_changed(gpointer data)
406 struct vpn_provider *provider = data;
408 provider_routes_changed(provider);
410 provider->notify_id = 0;
415 static void provider_schedule_changed(struct vpn_provider *provider)
417 if (provider->notify_id != 0)
418 g_source_remove(provider->notify_id);
420 provider->notify_id = g_timeout_add(100, provider_send_changed,
424 static DBusMessage *get_properties(DBusConnection *conn,
425 DBusMessage *msg, void *data)
427 struct vpn_provider *provider = data;
429 DBusMessageIter array;
431 DBG("provider %p", provider);
433 reply = dbus_message_new_method_return(msg);
437 dbus_message_iter_init_append(reply, &array);
439 append_properties(&array, provider);
444 /* True when lists are equal, false otherwise */
445 static bool compare_network_lists(GSList *a, GSList *b)
447 struct vpn_route *route_a, *route_b;
448 GSList *iter_a, *iter_b;
454 * If either of lists is NULL or the lists are of different size, the
455 * lists are not equal.
457 if ((!a || !b) || (g_slist_length(a) != g_slist_length(b)))
460 /* Routes are in sorted list so items can be compared in order. */
461 for (iter_a = a, iter_b = b; iter_a && iter_b;
462 iter_a = iter_a->next, iter_b = iter_b->next) {
464 route_a = iter_a->data;
465 route_b = iter_b->data;
467 if (compare_route(route_a, route_b))
474 static const char *bool2str(bool value)
476 return value ? "true" : "false";
479 static int set_provider_property(struct vpn_provider *provider,
480 const char *name, DBusMessageIter *value, int type)
484 DBG("provider %p", provider);
486 if (!provider || !name || !value)
489 if (g_str_equal(name, "UserRoutes")) {
492 if (type != DBUS_TYPE_ARRAY)
495 networks = get_user_networks(value);
497 if (compare_network_lists(provider->user_networks, networks)) {
498 g_slist_free_full(networks, free_route);
502 del_routes(provider);
503 provider->user_networks = networks;
504 set_user_networks(provider, provider->user_networks);
505 send_routes(provider, provider->user_routes, "UserRoutes");
506 } else if (g_str_equal(name, "SplitRouting")) {
507 dbus_bool_t split_routing;
509 if (type != DBUS_TYPE_BOOLEAN)
512 dbus_message_iter_get_basic(value, &split_routing);
514 DBG("property %s value %s ", name, bool2str(split_routing));
515 vpn_provider_set_boolean(provider, name, split_routing, false);
519 if (type != DBUS_TYPE_STRING)
522 dbus_message_iter_get_basic(value, &str);
524 DBG("property %s value %s", name, str);
526 /* Empty string clears the value, similar to ClearProperty. */
527 err = vpn_provider_set_string(provider, name,
534 static GString *append_to_gstring(GString *str, const char *value)
537 return g_string_new(value);
539 g_string_append_printf(str, ",%s", value);
544 static DBusMessage *set_properties(DBusMessageIter *iter, DBusMessage *msg,
547 struct vpn_provider *provider = data;
548 DBusMessageIter dict;
551 GString *invalid = NULL;
552 GString *denied = NULL;
556 for (dbus_message_iter_recurse(iter, &dict);
557 dbus_message_iter_get_arg_type(&dict) ==
558 DBUS_TYPE_DICT_ENTRY;
559 dbus_message_iter_next(&dict)) {
560 DBusMessageIter entry, value;
562 dbus_message_iter_recurse(&dict, &entry);
564 * Ignore invalid types in order to process all values in the
565 * dict. If there is an invalid type in between the dict there
566 * may already be changes on some values and breaking out here
567 * would have the provider in an inconsistent state, leaving
568 * the rest, potentially correct property values untouched.
570 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
573 dbus_message_iter_get_basic(&entry, &key);
577 dbus_message_iter_next(&entry);
578 /* Ignore and report back all non variant types. */
579 if (dbus_message_iter_get_arg_type(&entry)
580 != DBUS_TYPE_VARIANT) {
581 invalid = append_to_gstring(invalid, key);
585 dbus_message_iter_recurse(&entry, &value);
587 type = dbus_message_iter_get_arg_type(&value);
589 case DBUS_TYPE_STRING:
590 case DBUS_TYPE_ARRAY:
591 case DBUS_TYPE_BOOLEAN:
594 /* Ignore and report back all invalid property types */
595 invalid = append_to_gstring(invalid, key);
599 err = set_provider_property(provider, key, &value, type);
605 invalid = append_to_gstring(invalid, key);
608 denied = append_to_gstring(denied, key);
614 vpn_provider_save(provider);
616 if (invalid || denied) {
618 char *invalid_str = g_string_free(invalid, FALSE);
619 char *denied_str = g_string_free(denied, FALSE);
622 * If there are both invalid and denied properties report
623 * back invalid arguments. Add also the failed properties to
626 error = g_dbus_create_error(msg, (invalid ?
627 CONNMAN_ERROR_INTERFACE ".InvalidProperty" :
628 CONNMAN_ERROR_INTERFACE ".PermissionDenied"),
629 "%s %s%s%s", (invalid ? "Invalid properties" :
630 "Permission denied"),
631 (invalid ? invalid_str : ""),
632 (invalid && denied ? "," : ""),
633 (denied ? denied_str : ""));
641 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
644 static DBusMessage *set_property(DBusConnection *conn, DBusMessage *msg,
647 struct vpn_provider *provider = data;
648 DBusMessageIter iter, value;
653 DBG("conn %p", conn);
655 if (provider->immutable)
656 return __connman_error_not_supported(msg);
658 if (!dbus_message_iter_init(msg, &iter))
659 return __connman_error_invalid_arguments(msg);
661 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
662 return __connman_error_invalid_arguments(msg);
664 dbus_message_iter_get_basic(&iter, &name);
665 dbus_message_iter_next(&iter);
667 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
668 return __connman_error_invalid_arguments(msg);
670 dbus_message_iter_recurse(&iter, &value);
672 type = dbus_message_iter_get_arg_type(&value);
673 if (type == DBUS_TYPE_ARRAY && g_str_equal(name, "Properties"))
674 return set_properties(&value, msg, data);
676 err = set_provider_property(provider, name, &value, type);
679 vpn_provider_save(provider);
684 return __connman_error_invalid_property(msg);
686 return __connman_error_failed(msg, -err);
689 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
692 static DBusMessage *clear_property(DBusConnection *conn, DBusMessage *msg,
695 struct vpn_provider *provider = data;
700 DBG("conn %p", conn);
702 if (provider->immutable)
703 return __connman_error_not_supported(msg);
705 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
708 if (g_str_equal(name, "UserRoutes")) {
710 * If either user_routes or user_networks has any entries
711 * there is a change that is to be written to settings file.
713 if (g_hash_table_size(provider->user_routes) ||
714 provider->user_networks)
717 del_routes(provider);
719 send_routes(provider, provider->user_routes, name);
720 } else if (vpn_provider_get_string(provider, name)) {
721 err = vpn_provider_set_string(provider, name, NULL);
729 return __connman_error_invalid_property(msg);
731 return __connman_error_failed(msg, -err);
734 return __connman_error_invalid_property(msg);
738 vpn_provider_save(provider);
740 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
743 static DBusMessage *do_connect(DBusConnection *conn, DBusMessage *msg,
746 struct vpn_provider *provider = data;
749 DBG("conn %p provider %p", conn, provider);
751 err = __vpn_provider_connect(provider, msg);
752 if (err < 0 && err != -EINPROGRESS)
753 return __connman_error_failed(msg, -err);
758 static DBusMessage *do_connect2(DBusConnection *conn, DBusMessage *msg,
761 return do_connect(conn, msg, data);
764 static DBusMessage *do_disconnect(DBusConnection *conn, DBusMessage *msg,
767 struct vpn_provider *provider = data;
770 DBG("conn %p provider %p", conn, provider);
772 err = __vpn_provider_disconnect(provider);
773 if (err < 0 && err != -EINPROGRESS)
774 return __connman_error_failed(msg, -err);
776 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
779 static const GDBusMethodTable connection_methods[] = {
780 { GDBUS_METHOD("GetProperties",
781 NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
783 { GDBUS_METHOD("SetProperty",
784 GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
785 NULL, set_property) },
786 { GDBUS_METHOD("ClearProperty",
787 GDBUS_ARGS({ "name", "s" }), NULL,
789 { GDBUS_ASYNC_METHOD("Connect", NULL, NULL, do_connect) },
790 { GDBUS_ASYNC_METHOD("Connect2",
791 GDBUS_ARGS({ "dbus_sender", "s" }),
792 NULL, do_connect2) },
793 { GDBUS_METHOD("Disconnect", NULL, NULL, do_disconnect) },
797 static const GDBusSignalTable connection_signals[] = {
798 { GDBUS_SIGNAL("PropertyChanged",
799 GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
803 static void resolv_result(GResolvResultStatus status,
804 char **results, gpointer user_data)
806 struct vpn_provider *provider = user_data;
808 DBG("status %d", status);
810 if (status == G_RESOLV_RESULT_STATUS_SUCCESS && results &&
811 g_strv_length(results) > 0)
812 provider->host_ip = g_strdupv(results);
814 vpn_provider_unref(provider);
816 /* Remove the resolver here so that it will not be left
817 * hanging around and cause double free in unregister_provider()
819 g_resolv_unref(provider->resolv);
820 provider->resolv = NULL;
823 static void provider_resolv_host_addr(struct vpn_provider *provider)
828 if (connman_inet_check_ipaddress(provider->host) > 0)
831 if (provider->host_ip)
835 * If the hostname is not numeric, try to resolv it. We do not wait
836 * the result as it might take some time. We will get the result
837 * before VPN will feed routes to us because VPN client will need
838 * the IP address also before VPN connection can be established.
840 provider->resolv = g_resolv_new(0);
841 if (!provider->resolv) {
842 DBG("Cannot resolv %s", provider->host);
846 DBG("Trying to resolv %s", provider->host);
848 vpn_provider_ref(provider);
850 g_resolv_lookup_hostname(provider->resolv, provider->host,
851 resolv_result, provider);
854 void __vpn_provider_append_properties(struct vpn_provider *provider,
855 DBusMessageIter *iter)
857 dbus_bool_t split_routing;
860 connman_dbus_dict_append_basic(iter, "Host",
861 DBUS_TYPE_STRING, &provider->host);
863 if (provider->domain)
864 connman_dbus_dict_append_basic(iter, "Domain",
865 DBUS_TYPE_STRING, &provider->domain);
868 connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING,
871 split_routing = provider->do_split_routing;
872 connman_dbus_dict_append_basic(iter, "SplitRouting", DBUS_TYPE_BOOLEAN,
876 int __vpn_provider_append_user_route(struct vpn_provider *provider,
877 int family, const char *network,
878 const char *netmask, const char *gateway)
880 struct vpn_route *route;
881 char *key = g_strdup_printf("%d/%s/%s/%s", family, network,
882 netmask, gateway ? gateway : "");
884 DBG("family %d network %s netmask %s gw %s", family, network,
887 route = g_hash_table_lookup(provider->user_routes, key);
889 route = g_try_new0(struct vpn_route, 1);
891 connman_error("out of memory");
895 route->family = family;
896 route->network = g_strdup(network);
897 route->netmask = g_strdup(netmask);
898 route->gateway = g_strdup(gateway);
900 g_hash_table_replace(provider->user_routes, key, route);
907 static struct vpn_route *get_route(char *route_str)
909 char **elems = g_strsplit(route_str, "/", 0);
910 char *network, *netmask, *gateway, *family_str;
911 int family = PF_UNSPEC;
912 struct vpn_route *route = NULL;
917 family_str = elems[0];
920 if (!network || network[0] == '\0')
924 if (!netmask || netmask[0] == '\0')
929 route = g_try_new0(struct vpn_route, 1);
933 if (family_str[0] == '\0' || atoi(family_str) == 0) {
936 switch (family_str[0]) {
946 if (g_strrstr(network, ":")) {
947 if (family != PF_UNSPEC && family != AF_INET6)
948 DBG("You have IPv6 address but you have non IPv6 route");
949 } else if (g_strrstr(network, ".")) {
950 if (family != PF_UNSPEC && family != AF_INET)
951 DBG("You have IPv4 address but you have non IPv4 route");
953 if (!g_strrstr(netmask, ".")) {
954 /* We have netmask length */
956 struct in_addr netmask_in;
957 unsigned char prefix_len = 32;
959 long int value = strtol(netmask, &ptr, 10);
961 if (ptr != netmask && *ptr == '\0' && value <= 32)
964 addr = 0xffffffff << (32 - prefix_len);
965 netmask_in.s_addr = htonl(addr);
966 netmask = inet_ntoa(netmask_in);
968 DBG("network %s netmask %s", network, netmask);
972 if (family == PF_UNSPEC) {
973 family = connman_inet_check_ipaddress(network);
974 if (family < 0 || family == PF_UNSPEC)
978 route->family = family;
979 route->network = g_strdup(network);
980 route->netmask = g_strdup(netmask);
981 route->gateway = g_strdup(gateway);
988 static GSList *get_routes(gchar **networks)
990 struct vpn_route *route;
991 GSList *routes = NULL;
994 for (i = 0; networks[i]; i++) {
995 route = get_route(networks[i]);
997 routes = g_slist_prepend(routes, route);
1003 static int provider_load_from_keyfile(struct vpn_provider *provider,
1009 gsize length, num_user_networks;
1010 gchar **networks = NULL;
1012 settings = g_key_file_get_keys(keyfile, provider->identifier, &length,
1015 g_key_file_free(keyfile);
1019 for (idx = 0; idx < length; idx++) {
1020 key = settings[idx];
1024 if (g_str_equal(key, "Networks")) {
1025 networks = __vpn_config_get_string_list(keyfile,
1026 provider->identifier,key,
1027 &num_user_networks, NULL);
1028 provider->user_networks = get_routes(networks);
1030 value = __vpn_config_get_string(keyfile,
1031 provider->identifier, key,
1034 vpn_provider_set_string(provider, key, value);
1039 g_strfreev(settings);
1040 g_strfreev(networks);
1042 if (provider->user_networks)
1043 set_user_networks(provider, provider->user_networks);
1049 static int vpn_provider_load(struct vpn_provider *provider)
1053 DBG("provider %p", provider);
1055 keyfile = __connman_storage_load_provider(provider->identifier);
1059 provider_load_from_keyfile(provider, keyfile);
1061 g_key_file_free(keyfile);
1065 static gchar **create_network_list(GSList *networks, gsize *count)
1068 gchar **result = NULL;
1069 gchar **prev_result;
1070 unsigned int num_elems = 0;
1072 for (list = networks; list; list = g_slist_next(list)) {
1073 struct vpn_route *route = list->data;
1076 prev_result = result;
1077 result = g_try_realloc(result,
1078 (num_elems + 1) * sizeof(gchar *));
1080 g_free(prev_result);
1084 switch (route->family) {
1096 result[num_elems] = g_strdup_printf("%d/%s/%s/%s",
1097 family, route->network, route->netmask,
1098 !route->gateway ? "" : route->gateway);
1103 prev_result = result;
1104 result = g_try_realloc(result, (num_elems + 1) * sizeof(gchar *));
1106 g_free(prev_result);
1110 result[num_elems] = NULL;
1115 static void reset_error_counters(struct vpn_provider *provider)
1120 provider->auth_error_counter = provider->conn_error_counter = 0;
1123 static int vpn_provider_save(struct vpn_provider *provider)
1127 DBG("provider %p immutable %s", provider,
1128 provider->immutable ? "yes" : "no");
1130 reset_error_counters(provider);
1132 if (provider->state == VPN_PROVIDER_STATE_FAILURE)
1133 vpn_provider_set_state(provider, VPN_PROVIDER_STATE_IDLE);
1135 if (provider->immutable) {
1137 * Do not save providers that are provisioned via .config
1143 keyfile = g_key_file_new();
1147 g_key_file_set_string(keyfile, provider->identifier,
1148 "Name", provider->name);
1149 g_key_file_set_string(keyfile, provider->identifier,
1150 "Type", provider->type);
1151 g_key_file_set_string(keyfile, provider->identifier,
1152 "Host", provider->host);
1153 g_key_file_set_string(keyfile, provider->identifier,
1154 "VPN.Domain", provider->domain);
1156 if (provider->user_networks) {
1158 gsize network_count;
1160 networks = create_network_list(provider->user_networks,
1163 g_key_file_set_string_list(keyfile,
1164 provider->identifier,
1166 (const gchar ** const)networks,
1168 g_strfreev(networks);
1172 if (provider->config_file && strlen(provider->config_file) > 0)
1173 g_key_file_set_string(keyfile, provider->identifier,
1174 "Config.file", provider->config_file);
1176 if (provider->config_entry &&
1177 strlen(provider->config_entry) > 0)
1178 g_key_file_set_string(keyfile, provider->identifier,
1179 "Config.ident", provider->config_entry);
1181 if (provider->driver && provider->driver->save)
1182 provider->driver->save(provider, keyfile);
1184 __connman_storage_save_provider(keyfile, provider->identifier);
1185 g_key_file_free(keyfile);
1190 struct vpn_provider *__vpn_provider_lookup(const char *identifier)
1192 struct vpn_provider *provider = NULL;
1194 provider = g_hash_table_lookup(provider_hash, identifier);
1199 static bool match_driver(struct vpn_provider *provider,
1200 struct vpn_provider_driver *driver)
1202 if (g_strcmp0(driver->name, provider->type) == 0)
1208 static int provider_probe(struct vpn_provider *provider)
1212 DBG("provider %p driver %p name %s", provider, provider->driver,
1215 if (provider->driver)
1218 for (list = driver_list; list; list = list->next) {
1219 struct vpn_provider_driver *driver = list->data;
1221 if (!match_driver(provider, driver))
1224 DBG("driver %p name %s", driver, driver->name);
1226 if (driver->probe && driver->probe(provider) == 0) {
1227 provider->driver = driver;
1232 if (!provider->driver)
1238 static void provider_remove(struct vpn_provider *provider)
1240 if (provider->driver) {
1241 provider->driver->remove(provider);
1242 provider->driver = NULL;
1246 static int provider_register(struct vpn_provider *provider)
1248 return provider_probe(provider);
1251 static void provider_unregister(struct vpn_provider *provider)
1253 provider_remove(provider);
1256 struct vpn_provider *
1257 vpn_provider_ref_debug(struct vpn_provider *provider,
1258 const char *file, int line, const char *caller)
1260 DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount + 1,
1261 file, line, caller);
1263 __sync_fetch_and_add(&provider->refcount, 1);
1268 static void provider_destruct(struct vpn_provider *provider)
1270 DBG("provider %p", provider);
1272 if (provider->notify_id != 0)
1273 g_source_remove(provider->notify_id);
1275 g_free(provider->name);
1276 g_free(provider->type);
1277 g_free(provider->host);
1278 g_free(provider->domain);
1279 g_free(provider->identifier);
1280 g_free(provider->path);
1281 g_slist_free_full(provider->user_networks, free_route);
1282 g_strfreev(provider->nameservers);
1283 g_hash_table_destroy(provider->routes);
1284 g_hash_table_destroy(provider->user_routes);
1285 g_hash_table_destroy(provider->setting_strings);
1286 if (provider->resolv) {
1287 g_resolv_unref(provider->resolv);
1288 provider->resolv = NULL;
1290 __vpn_ipconfig_unref(provider->ipconfig_ipv4);
1291 __vpn_ipconfig_unref(provider->ipconfig_ipv6);
1293 g_strfreev(provider->host_ip);
1294 g_free(provider->config_file);
1295 g_free(provider->config_entry);
1296 connman_ipaddress_free(provider->prev_ipv4_addr);
1297 connman_ipaddress_free(provider->prev_ipv6_addr);
1301 void vpn_provider_unref_debug(struct vpn_provider *provider,
1302 const char *file, int line, const char *caller)
1304 DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount - 1,
1305 file, line, caller);
1307 if (__sync_fetch_and_sub(&provider->refcount, 1) != 1)
1310 provider_remove(provider);
1312 provider_destruct(provider);
1315 static void configuration_count_add(void)
1317 DBG("count %d", configuration_count + 1);
1319 __sync_fetch_and_add(&configuration_count, 1);
1322 static void configuration_count_del(void)
1324 DBG("count %d", configuration_count - 1);
1326 if (__sync_fetch_and_sub(&configuration_count, 1) != 1)
1330 int __vpn_provider_disconnect(struct vpn_provider *provider)
1334 DBG("provider %p", provider);
1336 if (provider->driver && provider->driver->disconnect)
1337 err = provider->driver->disconnect(provider);
1341 if (err == -EINPROGRESS)
1342 vpn_provider_set_state(provider, VPN_PROVIDER_STATE_CONNECT);
1347 static void connect_cb(struct vpn_provider *provider, void *user_data,
1350 DBusMessage *pending = user_data;
1352 DBG("provider %p user %p error %d", provider, user_data, error);
1355 DBusMessage *reply = __connman_error_failed(pending, error);
1357 g_dbus_send_message(connection, reply);
1361 vpn_provider_indicate_error(provider,
1362 VPN_PROVIDER_ERROR_AUTH_FAILED);
1366 * No reply, disconnect called by connmand because of
1367 * connection timeout.
1373 /* No reply or timed out -> cancel the agent request */
1374 connman_agent_cancel(provider);
1375 vpn_provider_indicate_error(provider,
1376 VPN_PROVIDER_ERROR_UNKNOWN);
1382 * This can be called in other situations than when
1383 * VPN agent error checker is called. In such case
1384 * react to both ECONNABORTED and ECANCELED as if the
1385 * connection was called to terminate and do full
1386 * disconnect -> idle cycle when being connected or
1387 * ready. Setting the state also using the driver
1388 * callback (vpn_set_state()) ensures that the driver is
1389 * being disconnected as well and eventually the vpn
1390 * process gets killed and vpn_died() is called to make
1391 * the provider back to idle state.
1393 if (provider->state == VPN_PROVIDER_STATE_CONNECT ||
1395 VPN_PROVIDER_STATE_READY) {
1396 if (provider->driver->set_state)
1397 provider->driver->set_state(provider,
1398 VPN_PROVIDER_STATE_DISCONNECT);
1400 vpn_provider_set_state(provider,
1401 VPN_PROVIDER_STATE_DISCONNECT);
1405 vpn_provider_indicate_error(provider,
1406 VPN_PROVIDER_ERROR_CONNECT_FAILED);
1407 vpn_provider_set_state(provider,
1408 VPN_PROVIDER_STATE_FAILURE);
1411 reset_error_counters(provider);
1412 g_dbus_send_reply(connection, pending, DBUS_TYPE_INVALID);
1415 dbus_message_unref(pending);
1418 int __vpn_provider_connect(struct vpn_provider *provider, DBusMessage *msg)
1423 DBG("provider %p state %d", provider, provider->state);
1425 switch (provider->state) {
1427 * When previous connection has failed change state to idle and let
1428 * the connmand to process this information as well. Return -EINPROGRESS
1429 * to indicate that transition is in progress and next connection
1430 * attempt will continue as normal.
1432 case VPN_PROVIDER_STATE_FAILURE:
1433 if (provider->driver && provider->driver->set_state)
1434 provider->driver->set_state(provider,
1435 VPN_PROVIDER_STATE_IDLE);
1437 vpn_provider_set_state(provider, VPN_PROVIDER_STATE_IDLE);
1440 * If re-using a provider and it is being disconnected let it finish
1441 * the disconnect process in order to let vpn.c:vpn_died() to get
1442 * processed and everything cleaned up. Otherwise the reference
1443 * counters are not decreased properly causing the previous interface
1444 * being left up and its routes will remain in routing table. Return
1445 * -EINPROGRESS to indicate that transition is in progress.
1447 case VPN_PROVIDER_STATE_DISCONNECT:
1449 * Failure transition or disconnecting does not yield a
1450 * message to be sent. Send in progress message to avoid
1451 * D-Bus LimitsExceeded error message.
1453 reply = __connman_error_in_progress(msg);
1455 g_dbus_send_message(connection, reply);
1457 return -EINPROGRESS;
1458 case VPN_PROVIDER_STATE_UNKNOWN:
1459 case VPN_PROVIDER_STATE_IDLE:
1460 case VPN_PROVIDER_STATE_CONNECT:
1461 case VPN_PROVIDER_STATE_READY:
1465 if (provider->driver && provider->driver->connect) {
1466 const char *dbus_sender = dbus_message_get_sender(msg);
1468 dbus_message_ref(msg);
1470 if (dbus_message_has_signature(msg,
1471 DBUS_TYPE_STRING_AS_STRING)) {
1472 const char *sender = NULL;
1474 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING,
1475 &sender, DBUS_TYPE_INVALID);
1476 if (sender && sender[0])
1477 dbus_sender = sender;
1480 err = provider->driver->connect(provider, connect_cb,
1485 if (err == -EINPROGRESS)
1486 vpn_provider_set_state(provider, VPN_PROVIDER_STATE_CONNECT);
1491 static void connection_removed_signal(struct vpn_provider *provider)
1493 DBusMessage *signal;
1494 DBusMessageIter iter;
1496 signal = dbus_message_new_signal(VPN_MANAGER_PATH,
1497 VPN_MANAGER_INTERFACE, "ConnectionRemoved");
1501 dbus_message_iter_init_append(signal, &iter);
1502 dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
1504 dbus_connection_send(connection, signal, NULL);
1505 dbus_message_unref(signal);
1508 static char *get_ident(const char *path)
1515 pos = strrchr(path, '/');
1522 int __vpn_provider_remove(const char *path)
1524 struct vpn_provider *provider;
1527 DBG("path %s", path);
1529 ident = get_ident(path);
1531 provider = __vpn_provider_lookup(ident);
1533 return __vpn_provider_delete(provider);
1538 int __vpn_provider_delete(struct vpn_provider *provider)
1540 DBG("Deleting VPN %s", provider->identifier);
1542 connection_removed_signal(provider);
1544 provider_unregister(provider);
1546 __connman_storage_remove_provider(provider->identifier);
1548 g_hash_table_remove(provider_hash, provider->identifier);
1553 static void append_ipv4(DBusMessageIter *iter, void *user_data)
1555 struct vpn_provider *provider = user_data;
1556 const char *address, *gateway, *peer;
1558 address = __vpn_ipconfig_get_local(provider->ipconfig_ipv4);
1561 struct in_addr netmask;
1565 prefixlen = __vpn_ipconfig_get_prefixlen(
1566 provider->ipconfig_ipv4);
1568 addr = 0xffffffff << (32 - prefixlen);
1569 netmask.s_addr = htonl(addr);
1570 mask = inet_ntoa(netmask);
1572 connman_dbus_dict_append_basic(iter, "Address",
1573 DBUS_TYPE_STRING, &address);
1575 connman_dbus_dict_append_basic(iter, "Netmask",
1576 DBUS_TYPE_STRING, &mask);
1579 gateway = __vpn_ipconfig_get_gateway(provider->ipconfig_ipv4);
1581 connman_dbus_dict_append_basic(iter, "Gateway",
1582 DBUS_TYPE_STRING, &gateway);
1584 peer = __vpn_ipconfig_get_peer(provider->ipconfig_ipv4);
1586 connman_dbus_dict_append_basic(iter, "Peer",
1587 DBUS_TYPE_STRING, &peer);
1590 static void append_ipv6(DBusMessageIter *iter, void *user_data)
1592 struct vpn_provider *provider = user_data;
1593 const char *address, *gateway, *peer;
1595 address = __vpn_ipconfig_get_local(provider->ipconfig_ipv6);
1597 unsigned char prefixlen;
1599 connman_dbus_dict_append_basic(iter, "Address",
1600 DBUS_TYPE_STRING, &address);
1602 prefixlen = __vpn_ipconfig_get_prefixlen(
1603 provider->ipconfig_ipv6);
1605 connman_dbus_dict_append_basic(iter, "PrefixLength",
1606 DBUS_TYPE_BYTE, &prefixlen);
1609 gateway = __vpn_ipconfig_get_gateway(provider->ipconfig_ipv6);
1611 connman_dbus_dict_append_basic(iter, "Gateway",
1612 DBUS_TYPE_STRING, &gateway);
1614 peer = __vpn_ipconfig_get_peer(provider->ipconfig_ipv6);
1616 connman_dbus_dict_append_basic(iter, "Peer",
1617 DBUS_TYPE_STRING, &peer);
1620 static const char *state2string(enum vpn_provider_state state)
1623 case VPN_PROVIDER_STATE_UNKNOWN:
1625 case VPN_PROVIDER_STATE_IDLE:
1627 case VPN_PROVIDER_STATE_CONNECT:
1628 return "configuration";
1629 case VPN_PROVIDER_STATE_READY:
1631 case VPN_PROVIDER_STATE_DISCONNECT:
1632 return "disconnect";
1633 case VPN_PROVIDER_STATE_FAILURE:
1640 static void append_nameservers(DBusMessageIter *iter, char **servers)
1646 for (i = 0; servers[i]; i++) {
1647 DBG("servers[%d] %s", i, servers[i]);
1648 dbus_message_iter_append_basic(iter,
1649 DBUS_TYPE_STRING, &servers[i]);
1653 static void append_dns(DBusMessageIter *iter, void *user_data)
1655 struct vpn_provider *provider = user_data;
1657 if (provider->nameservers)
1658 append_nameservers(iter, provider->nameservers);
1661 static int provider_indicate_state(struct vpn_provider *provider,
1662 enum vpn_provider_state state)
1665 enum vpn_provider_state old_state;
1667 str = state2string(state);
1668 DBG("provider %p state %s/%d", provider, str, state);
1672 old_state = provider->state;
1673 provider->state = state;
1675 if (state == VPN_PROVIDER_STATE_READY) {
1676 connman_dbus_property_changed_basic(provider->path,
1677 VPN_CONNECTION_INTERFACE, "Index",
1678 DBUS_TYPE_INT32, &provider->index);
1680 if (provider->family == AF_INET)
1681 connman_dbus_property_changed_dict(provider->path,
1682 VPN_CONNECTION_INTERFACE, "IPv4",
1683 append_ipv4, provider);
1684 else if (provider->family == AF_INET6)
1685 connman_dbus_property_changed_dict(provider->path,
1686 VPN_CONNECTION_INTERFACE, "IPv6",
1687 append_ipv6, provider);
1689 connman_dbus_property_changed_array(provider->path,
1690 VPN_CONNECTION_INTERFACE,
1693 append_dns, provider);
1695 if (provider->domain)
1696 connman_dbus_property_changed_basic(provider->path,
1697 VPN_CONNECTION_INTERFACE,
1703 if (old_state != state)
1704 connman_dbus_property_changed_basic(provider->path,
1705 VPN_CONNECTION_INTERFACE, "State",
1706 DBUS_TYPE_STRING, &str);
1711 static void append_state(DBusMessageIter *iter,
1712 struct vpn_provider *provider)
1716 switch (provider->state) {
1717 case VPN_PROVIDER_STATE_UNKNOWN:
1718 case VPN_PROVIDER_STATE_IDLE:
1721 case VPN_PROVIDER_STATE_CONNECT:
1722 str = "configuration";
1724 case VPN_PROVIDER_STATE_READY:
1727 case VPN_PROVIDER_STATE_DISCONNECT:
1730 case VPN_PROVIDER_STATE_FAILURE:
1735 connman_dbus_dict_append_basic(iter, "State",
1736 DBUS_TYPE_STRING, &str);
1739 static void append_properties(DBusMessageIter *iter,
1740 struct vpn_provider *provider)
1742 DBusMessageIter dict;
1743 GHashTableIter hash;
1744 gpointer value, key;
1745 dbus_bool_t immutable;
1746 dbus_bool_t split_routing;
1748 connman_dbus_dict_open(iter, &dict);
1750 append_state(&dict, provider);
1753 connman_dbus_dict_append_basic(&dict, "Type",
1754 DBUS_TYPE_STRING, &provider->type);
1757 connman_dbus_dict_append_basic(&dict, "Name",
1758 DBUS_TYPE_STRING, &provider->name);
1761 connman_dbus_dict_append_basic(&dict, "Host",
1762 DBUS_TYPE_STRING, &provider->host);
1763 if (provider->index >= 0)
1764 connman_dbus_dict_append_basic(&dict, "Index",
1765 DBUS_TYPE_INT32, &provider->index);
1766 if (provider->domain)
1767 connman_dbus_dict_append_basic(&dict, "Domain",
1768 DBUS_TYPE_STRING, &provider->domain);
1770 immutable = provider->immutable;
1771 connman_dbus_dict_append_basic(&dict, "Immutable", DBUS_TYPE_BOOLEAN,
1774 split_routing = provider->do_split_routing;
1775 connman_dbus_dict_append_basic(&dict, "SplitRouting",
1776 DBUS_TYPE_BOOLEAN, &split_routing);
1778 if (provider->family == AF_INET)
1779 connman_dbus_dict_append_dict(&dict, "IPv4", append_ipv4,
1781 else if (provider->family == AF_INET6)
1782 connman_dbus_dict_append_dict(&dict, "IPv6", append_ipv6,
1785 connman_dbus_dict_append_array(&dict, "Nameservers",
1786 DBUS_TYPE_STRING, append_dns, provider);
1788 connman_dbus_dict_append_array(&dict, "UserRoutes",
1789 DBUS_TYPE_DICT_ENTRY, append_routes,
1790 provider->user_routes);
1792 connman_dbus_dict_append_array(&dict, "ServerRoutes",
1793 DBUS_TYPE_DICT_ENTRY, append_routes,
1796 if (provider->setting_strings) {
1797 g_hash_table_iter_init(&hash, provider->setting_strings);
1799 while (g_hash_table_iter_next(&hash, &key, &value)) {
1800 struct vpn_setting *setting = value;
1802 if (!setting->hide_value && setting->value)
1803 connman_dbus_dict_append_basic(&dict, key,
1809 connman_dbus_dict_close(iter, &dict);
1812 static void connection_added_signal(struct vpn_provider *provider)
1814 DBusMessage *signal;
1815 DBusMessageIter iter;
1817 signal = dbus_message_new_signal(VPN_MANAGER_PATH,
1818 VPN_MANAGER_INTERFACE, "ConnectionAdded");
1822 dbus_message_iter_init_append(signal, &iter);
1823 dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
1825 append_properties(&iter, provider);
1827 dbus_connection_send(connection, signal, NULL);
1828 dbus_message_unref(signal);
1831 static int set_connected(struct vpn_provider *provider,
1834 struct vpn_ipconfig *ipconfig;
1836 DBG("provider %p id %s connected %d", provider,
1837 provider->identifier, connected);
1840 if (provider->family == AF_INET6)
1841 ipconfig = provider->ipconfig_ipv6;
1843 ipconfig = provider->ipconfig_ipv4;
1845 __vpn_ipconfig_address_add(ipconfig, provider->family);
1847 provider_indicate_state(provider,
1848 VPN_PROVIDER_STATE_READY);
1850 provider_indicate_state(provider,
1851 VPN_PROVIDER_STATE_DISCONNECT);
1853 provider_indicate_state(provider,
1854 VPN_PROVIDER_STATE_IDLE);
1860 int vpn_provider_set_state(struct vpn_provider *provider,
1861 enum vpn_provider_state state)
1867 case VPN_PROVIDER_STATE_UNKNOWN:
1869 case VPN_PROVIDER_STATE_IDLE:
1870 return set_connected(provider, false);
1871 case VPN_PROVIDER_STATE_CONNECT:
1872 return provider_indicate_state(provider, state);
1873 case VPN_PROVIDER_STATE_READY:
1874 return set_connected(provider, true);
1875 case VPN_PROVIDER_STATE_DISCONNECT:
1876 return provider_indicate_state(provider, state);
1877 case VPN_PROVIDER_STATE_FAILURE:
1878 return provider_indicate_state(provider, state);
1883 void vpn_provider_add_error(struct vpn_provider *provider,
1884 enum vpn_provider_error error)
1887 case VPN_PROVIDER_ERROR_UNKNOWN:
1889 case VPN_PROVIDER_ERROR_CONNECT_FAILED:
1890 ++provider->conn_error_counter;
1892 case VPN_PROVIDER_ERROR_LOGIN_FAILED:
1893 case VPN_PROVIDER_ERROR_AUTH_FAILED:
1894 ++provider->auth_error_counter;
1899 int vpn_provider_indicate_error(struct vpn_provider *provider,
1900 enum vpn_provider_error error)
1902 DBG("provider %p id %s error %d", provider, provider->identifier,
1905 vpn_provider_set_state(provider, VPN_PROVIDER_STATE_FAILURE);
1907 vpn_provider_add_error(provider, error);
1909 if (provider->driver && provider->driver->set_state)
1910 provider->driver->set_state(provider, provider->state);
1915 static gboolean provider_property_changed(DBusConnection *conn,
1916 DBusMessage *message, void *user_data)
1918 DBusMessageIter iter;
1919 DBusMessageIter value;
1920 struct vpn_provider *provider = user_data;
1923 if (!dbus_message_iter_init(message, &iter))
1926 dbus_message_iter_get_basic(&iter, &key);
1928 dbus_message_iter_next(&iter);
1929 dbus_message_iter_recurse(&iter, &value);
1931 DBG("provider %p key %s", provider, key);
1933 if (g_str_equal(key, "SplitRouting")) {
1934 dbus_bool_t split_routing;
1936 if (dbus_message_iter_get_arg_type(&value) !=
1940 dbus_message_iter_get_basic(&value, &split_routing);
1942 DBG("property %s value %s", key, bool2str(split_routing));
1945 * Even though this is coming from connmand, signal the value
1946 * for other components listening to the changes via VPN API
1947 * only. provider.c will skip setting the same value in order
1948 * to avoid signaling loop. This is needed for ensuring that
1949 * all components using VPN API will be informed about the
1950 * correct status of SplitRouting. Especially when loading the
1951 * services after a crash, for instance.
1953 vpn_provider_set_boolean(provider, "SplitRouting",
1954 split_routing, true);
1961 static int connection_unregister(struct vpn_provider *provider)
1963 DBG("provider %p path %s", provider, provider->path);
1965 if (provider->signal_watch) {
1966 g_dbus_remove_watch(connection, provider->signal_watch);
1967 provider->signal_watch = 0;
1970 if (!provider->path)
1973 g_dbus_unregister_interface(connection, provider->path,
1974 VPN_CONNECTION_INTERFACE);
1976 g_free(provider->path);
1977 provider->path = NULL;
1982 static int connection_register(struct vpn_provider *provider)
1984 char *connmand_vpn_path;
1986 DBG("provider %p path %s", provider, provider->path);
1991 provider->path = g_strdup_printf("%s/connection/%s", VPN_PATH,
1992 provider->identifier);
1994 g_dbus_register_interface(connection, provider->path,
1995 VPN_CONNECTION_INTERFACE,
1996 connection_methods, connection_signals,
1997 NULL, provider, NULL);
1999 connmand_vpn_path = g_strdup_printf("%s/service/vpn_%s", CONNMAN_PATH,
2000 provider->identifier);
2002 provider->signal_watch = g_dbus_add_signal_watch(connection,
2003 CONNMAN_SERVICE, connmand_vpn_path,
2004 CONNMAN_SERVICE_INTERFACE,
2006 provider_property_changed,
2009 g_free(connmand_vpn_path);
2014 static void unregister_provider(gpointer data)
2016 struct vpn_provider *provider = data;
2018 configuration_count_del();
2020 connection_unregister(provider);
2022 /* If the provider has any DNS resolver queries pending,
2023 * they need to be cleared here because the unref will not
2024 * be able to do that (because the provider_resolv_host_addr()
2025 * has increased the ref count by 1). This is quite rare as
2026 * normally the resolving either returns a value or has a
2027 * timeout which clears the memory. Typically resolv_result() will
2028 * unref the provider but in this case that call has not yet
2031 if (provider->resolv)
2032 vpn_provider_unref(provider);
2034 vpn_provider_unref(provider);
2037 static void provider_initialize(struct vpn_provider *provider)
2039 DBG("provider %p", provider);
2041 provider->index = 0;
2043 provider->name = NULL;
2044 provider->type = NULL;
2045 provider->domain = NULL;
2046 provider->identifier = NULL;
2047 provider->immutable = false;
2048 provider->do_split_routing = false;
2049 provider->user_networks = NULL;
2050 provider->routes = g_hash_table_new_full(g_direct_hash, g_direct_equal,
2052 provider->user_routes = g_hash_table_new_full(g_str_hash, g_str_equal,
2053 g_free, free_route);
2054 provider->setting_strings = g_hash_table_new_full(g_str_hash,
2055 g_str_equal, g_free, free_setting);
2058 static struct vpn_provider *vpn_provider_new(void)
2060 struct vpn_provider *provider;
2062 provider = g_try_new0(struct vpn_provider, 1);
2066 provider->refcount = 1;
2068 DBG("provider %p", provider);
2069 provider_initialize(provider);
2074 static struct vpn_provider *vpn_provider_get(const char *identifier)
2076 struct vpn_provider *provider;
2078 provider = g_hash_table_lookup(provider_hash, identifier);
2082 provider = vpn_provider_new();
2086 DBG("provider %p", provider);
2088 provider->identifier = g_strdup(identifier);
2090 g_hash_table_insert(provider_hash, provider->identifier, provider);
2092 configuration_count_add();
2097 static void vpn_provider_put(const char *identifier)
2099 configuration_count_del();
2101 g_hash_table_remove(provider_hash, identifier);
2104 static void provider_dbus_ident(char *ident)
2106 int i, len = strlen(ident);
2108 for (i = 0; i < len; i++) {
2109 if (ident[i] >= '0' && ident[i] <= '9')
2111 if (ident[i] >= 'a' && ident[i] <= 'z')
2113 if (ident[i] >= 'A' && ident[i] <= 'Z')
2119 static struct vpn_provider *provider_create_from_keyfile(GKeyFile *keyfile,
2122 struct vpn_provider *provider;
2124 if (!keyfile || !ident)
2127 provider = __vpn_provider_lookup(ident);
2129 provider = vpn_provider_get(ident);
2131 DBG("can not create provider");
2135 provider_load_from_keyfile(provider, keyfile);
2137 if (!provider->name || !provider->host ||
2138 !provider->domain) {
2139 DBG("cannot get name, host or domain");
2140 vpn_provider_unref(provider);
2144 if (!provider_register(provider)) {
2145 connection_register(provider);
2146 connection_added_signal(provider);
2153 static void provider_create_all_from_type(const char *provider_type)
2160 DBG("provider type %s", provider_type);
2162 providers = __connman_storage_get_providers();
2167 for (i = 0; providers[i]; i += 1) {
2169 if (strncmp(providers[i], "provider_", 9) != 0)
2172 id = providers[i] + 9;
2173 keyfile = __connman_storage_load_provider(id);
2178 type = __vpn_config_get_string(keyfile, id, "Type", NULL);
2180 DBG("keyfile %p id %s type %s", keyfile, id, type);
2182 if (strcmp(provider_type, type) != 0) {
2184 g_key_file_free(keyfile);
2188 if (!provider_create_from_keyfile(keyfile, id))
2189 DBG("could not create provider");
2192 g_key_file_free(keyfile);
2194 g_strfreev(providers);
2197 char *__vpn_provider_create_identifier(const char *host, const char *domain)
2202 ident = g_strdup_printf("%s_%s", host, domain);
2204 ident = g_strdup_printf("%s", host);
2206 provider_dbus_ident(ident);
2211 int __vpn_provider_create(DBusMessage *msg)
2213 struct vpn_provider *provider;
2214 DBusMessageIter iter, array;
2215 const char *type = NULL, *name = NULL;
2216 const char *host = NULL, *domain = NULL;
2217 GSList *networks = NULL;
2220 dbus_bool_t split_routing = false;
2222 dbus_message_iter_init(msg, &iter);
2223 dbus_message_iter_recurse(&iter, &array);
2225 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
2226 DBusMessageIter entry, value;
2229 dbus_message_iter_recurse(&array, &entry);
2230 dbus_message_iter_get_basic(&entry, &key);
2232 dbus_message_iter_next(&entry);
2233 dbus_message_iter_recurse(&entry, &value);
2235 switch (dbus_message_iter_get_arg_type(&value)) {
2236 case DBUS_TYPE_STRING:
2237 if (g_str_equal(key, "Type"))
2238 dbus_message_iter_get_basic(&value, &type);
2239 else if (g_str_equal(key, "Name"))
2240 dbus_message_iter_get_basic(&value, &name);
2241 else if (g_str_equal(key, "Host"))
2242 dbus_message_iter_get_basic(&value, &host);
2243 else if (g_str_equal(key, "VPN.Domain") ||
2244 g_str_equal(key, "Domain"))
2245 dbus_message_iter_get_basic(&value, &domain);
2247 case DBUS_TYPE_BOOLEAN:
2248 if (g_str_equal(key, "SplitRouting"))
2249 dbus_message_iter_get_basic(&value,
2252 case DBUS_TYPE_ARRAY:
2253 if (g_str_equal(key, "UserRoutes"))
2254 networks = get_user_networks(&value);
2258 dbus_message_iter_next(&array);
2264 DBG("Type %s name %s networks %p", type, name, networks);
2269 ident = __vpn_provider_create_identifier(host, domain);
2270 DBG("ident %s", ident);
2272 provider = __vpn_provider_lookup(ident);
2274 provider = vpn_provider_get(ident);
2276 DBG("can not create provider");
2281 provider->host = g_strdup(host);
2282 provider->domain = g_strdup(domain);
2283 provider->name = g_strdup(name);
2284 provider->type = g_strdup(type);
2285 provider->do_split_routing = split_routing;
2287 if (provider_register(provider) == 0)
2288 vpn_provider_load(provider);
2290 provider_resolv_host_addr(provider);
2294 g_slist_free_full(provider->user_networks, free_route);
2295 provider->user_networks = networks;
2296 set_user_networks(provider, provider->user_networks);
2299 dbus_message_iter_init(msg, &iter);
2300 dbus_message_iter_recurse(&iter, &array);
2302 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
2303 DBusMessageIter entry, value;
2304 const char *key, *str;
2306 dbus_message_iter_recurse(&array, &entry);
2307 dbus_message_iter_get_basic(&entry, &key);
2309 dbus_message_iter_next(&entry);
2310 dbus_message_iter_recurse(&entry, &value);
2312 switch (dbus_message_iter_get_arg_type(&value)) {
2313 case DBUS_TYPE_STRING:
2314 dbus_message_iter_get_basic(&value, &str);
2315 vpn_provider_set_string(provider, key, str);
2319 dbus_message_iter_next(&array);
2324 vpn_provider_save(provider);
2326 err = provider_register(provider);
2327 if (err != 0 && err != -EALREADY)
2330 connection_register(provider);
2332 DBG("provider %p index %d path %s", provider, provider->index,
2335 g_dbus_send_reply(connection, msg,
2336 DBUS_TYPE_OBJECT_PATH, &provider->path,
2339 connection_added_signal(provider);
2344 static const char *get_string(GHashTable *settings, const char *key)
2346 DBG("settings %p key %s", settings, key);
2348 return g_hash_table_lookup(settings, key);
2351 static GSList *parse_user_networks(const char *network_str)
2353 GSList *networks = NULL;
2360 elems = g_strsplit(network_str, ",", 0);
2365 struct vpn_route *vpn_route;
2366 char *network, *netmask, *gateway;
2370 route = g_strsplit(elems[i], "/", 0);
2375 if (!network || network[0] == '\0')
2378 family = connman_inet_check_ipaddress(network);
2380 DBG("Cannot get address family of %s (%d/%s)", network,
2381 family, gai_strerror(family));
2392 DBG("Unsupported address family %d", family);
2397 if (!netmask || netmask[0] == '\0')
2402 vpn_route = g_try_new0(struct vpn_route, 1);
2408 vpn_route->family = family;
2409 vpn_route->network = g_strdup(network);
2410 vpn_route->netmask = g_strdup(netmask);
2411 vpn_route->gateway = g_strdup(gateway);
2413 DBG("route %s/%s%s%s", network, netmask,
2414 gateway ? " via " : "", gateway ? gateway : "");
2416 networks = g_slist_prepend(networks, vpn_route);
2425 return g_slist_reverse(networks);
2428 int __vpn_provider_create_from_config(GHashTable *settings,
2429 const char *config_ident,
2430 const char *config_entry)
2432 struct vpn_provider *provider;
2433 const char *type, *name, *host, *domain, *networks_str;
2436 GHashTableIter hash;
2437 gpointer value, key;
2440 type = get_string(settings, "Type");
2441 name = get_string(settings, "Name");
2442 host = get_string(settings, "Host");
2443 domain = get_string(settings, "Domain");
2444 networks_str = get_string(settings, "Networks");
2445 networks = parse_user_networks(networks_str);
2452 DBG("type %s name %s networks %s", type, name, networks_str);
2454 if (!type || !name) {
2459 ident = __vpn_provider_create_identifier(host, domain);
2460 DBG("ident %s", ident);
2462 provider = __vpn_provider_lookup(ident);
2464 provider = vpn_provider_get(ident);
2466 DBG("can not create provider");
2471 provider->host = g_strdup(host);
2472 provider->domain = g_strdup(domain);
2473 provider->name = g_strdup(name);
2474 provider->type = g_ascii_strdown(type, -1);
2476 provider->config_file = g_strdup(config_ident);
2477 provider->config_entry = g_strdup(config_entry);
2479 provider_resolv_host_addr(provider);
2483 g_slist_free_full(provider->user_networks, free_route);
2484 provider->user_networks = networks;
2485 set_user_networks(provider, provider->user_networks);
2488 g_hash_table_iter_init(&hash, settings);
2490 while (g_hash_table_iter_next(&hash, &key, &value))
2491 __vpn_provider_set_string_immutable(provider, key, value);
2493 provider->immutable = true;
2495 vpn_provider_save(provider);
2497 err = provider_register(provider);
2498 if (err != 0 && err != -EALREADY)
2501 connection_register(provider);
2503 DBG("provider %p index %d path %s", provider, provider->index,
2506 connection_added_signal(provider);
2513 vpn_provider_put(ident);
2515 g_slist_free_full(networks, free_route);
2520 static void append_connection_structs(DBusMessageIter *iter, void *user_data)
2522 DBusMessageIter entry;
2523 GHashTableIter hash;
2524 gpointer value, key;
2526 g_hash_table_iter_init(&hash, provider_hash);
2528 while (g_hash_table_iter_next(&hash, &key, &value)) {
2529 struct vpn_provider *provider = value;
2531 DBG("path %s", provider->path);
2533 if (!provider->identifier)
2536 dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT,
2538 dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
2540 append_properties(&entry, provider);
2541 dbus_message_iter_close_container(iter, &entry);
2545 DBusMessage *__vpn_provider_get_connections(DBusMessage *msg)
2551 reply = dbus_message_new_method_return(msg);
2555 __connman_dbus_append_objpath_dict_array(reply,
2556 append_connection_structs, NULL);
2561 const char *vpn_provider_get_ident(struct vpn_provider *provider)
2566 return provider->identifier;
2569 static int set_string(struct vpn_provider *provider,
2570 const char *key, const char *value,
2571 bool hide_value, bool immutable)
2573 DBG("provider %p key %s immutable %s value %s", provider, key,
2574 immutable ? "yes" : "no",
2575 hide_value ? "<not printed>" : value);
2577 if (g_str_equal(key, "Type")) {
2578 if (!g_strcmp0(provider->type, value))
2581 g_free(provider->type);
2582 provider->type = g_ascii_strdown(value, -1);
2583 send_value(provider->path, "Type", provider->type);
2584 } else if (g_str_equal(key, "Name")) {
2585 if (!g_strcmp0(provider->name, value))
2588 g_free(provider->name);
2589 provider->name = g_strdup(value);
2590 send_value(provider->path, "Name", provider->name);
2591 } else if (g_str_equal(key, "Host")) {
2592 if (!g_strcmp0(provider->host, value))
2595 g_free(provider->host);
2596 provider->host = g_strdup(value);
2597 send_value(provider->path, "Host", provider->host);
2598 } else if (g_str_equal(key, "VPN.Domain") ||
2599 g_str_equal(key, "Domain")) {
2600 if (!g_strcmp0(provider->domain, value))
2603 g_free(provider->domain);
2604 provider->domain = g_strdup(value);
2605 send_value(provider->path, "Domain", provider->domain);
2606 } else if (g_str_equal(key, "SplitRouting")) {
2607 connman_warn("VPN SplitRouting value attempted to set as "
2608 "string, is boolean");
2611 struct vpn_setting *setting;
2612 bool replace = true;
2614 setting = g_hash_table_lookup(provider->setting_strings, key);
2616 if (!immutable && setting->immutable) {
2617 DBG("Trying to set immutable variable %s", key);
2619 } else if (!g_strcmp0(setting->value, value)) {
2623 g_free(setting->value);
2626 setting = g_try_new0(struct vpn_setting, 1);
2631 setting->value = g_strdup(value);
2632 setting->hide_value = hide_value;
2635 setting->immutable = true;
2638 send_value(provider->path, key, setting->value);
2641 g_hash_table_replace(provider->setting_strings,
2642 g_strdup(key), setting);
2648 int vpn_provider_set_string(struct vpn_provider *provider,
2649 const char *key, const char *value)
2651 return set_string(provider, key, value, false, false);
2654 int vpn_provider_set_string_hide_value(struct vpn_provider *provider,
2655 const char *key, const char *value)
2657 return set_string(provider, key, value, true, false);
2660 int __vpn_provider_set_string_immutable(struct vpn_provider *provider,
2661 const char *key, const char *value)
2663 return set_string(provider, key, value, false, true);
2666 const char *vpn_provider_get_string(struct vpn_provider *provider,
2669 struct vpn_setting *setting;
2671 DBG("provider %p key %s", provider, key);
2673 if (g_str_equal(key, "Type"))
2674 return provider->type;
2675 else if (g_str_equal(key, "Name"))
2676 return provider->name;
2677 else if (g_str_equal(key, "Host"))
2678 return provider->host;
2679 else if (g_str_equal(key, "HostIP")) {
2680 if (!provider->host_ip ||
2681 !provider->host_ip[0])
2682 return provider->host;
2684 return provider->host_ip[0];
2685 } else if (g_str_equal(key, "VPN.Domain") ||
2686 g_str_equal(key, "Domain"))
2687 return provider->domain;
2689 setting = g_hash_table_lookup(provider->setting_strings, key);
2693 return setting->value;
2696 int vpn_provider_set_boolean(struct vpn_provider *provider, const char *key,
2697 bool value, bool force_change)
2699 DBG("provider %p key %s", provider, key);
2701 if (g_str_equal(key, "SplitRouting")) {
2702 if (provider->do_split_routing == value && !force_change)
2705 DBG("SplitRouting set to %s", bool2str(value));
2707 provider->do_split_routing = value;
2708 send_value_boolean(provider->path, key,
2709 provider->do_split_routing);
2715 bool vpn_provider_get_boolean(struct vpn_provider *provider, const char *key,
2718 struct vpn_setting *setting;
2720 connman_info("provider %p key %s", provider, key);
2722 setting = g_hash_table_lookup(provider->setting_strings, key);
2723 if (!setting || !setting->value)
2724 return default_value;
2726 if (!g_strcmp0(setting->value, "true"))
2729 if (!g_strcmp0(setting->value, "false"))
2732 return default_value;
2735 bool vpn_provider_get_string_immutable(struct vpn_provider *provider,
2738 struct vpn_setting *setting;
2740 /* These values can be changed if the provider is not immutable */
2741 if (g_str_equal(key, "Type")) {
2742 return provider->immutable;
2743 } else if (g_str_equal(key, "Name")) {
2744 return provider->immutable;
2745 } else if (g_str_equal(key, "Host")) {
2746 return provider->immutable;
2747 } else if (g_str_equal(key, "HostIP")) {
2748 return provider->immutable;
2749 } else if (g_str_equal(key, "VPN.Domain") ||
2750 g_str_equal(key, "Domain")) {
2751 return provider->immutable;
2754 setting = g_hash_table_lookup(provider->setting_strings, key);
2756 return true; /* Not found, regard as immutable - no changes */
2758 return setting->immutable;
2761 bool __vpn_provider_check_routes(struct vpn_provider *provider)
2766 if (provider->user_routes &&
2767 g_hash_table_size(provider->user_routes) > 0)
2770 if (provider->routes &&
2771 g_hash_table_size(provider->routes) > 0)
2777 void *vpn_provider_get_data(struct vpn_provider *provider)
2779 return provider->driver_data;
2782 void vpn_provider_set_data(struct vpn_provider *provider, void *data)
2784 provider->driver_data = data;
2787 void *vpn_provider_get_plugin_data(struct vpn_provider *provider)
2789 return provider->plugin_data;
2792 void vpn_provider_set_plugin_data(struct vpn_provider *provider, void *data)
2794 provider->plugin_data = data;
2797 void vpn_provider_set_index(struct vpn_provider *provider, int index)
2799 DBG("index %d provider %p", index, provider);
2801 if (!provider->ipconfig_ipv4) {
2802 provider->ipconfig_ipv4 = __vpn_ipconfig_create(index,
2804 if (!provider->ipconfig_ipv4) {
2805 DBG("Couldn't create ipconfig for IPv4");
2810 __vpn_ipconfig_set_index(provider->ipconfig_ipv4, index);
2812 if (!provider->ipconfig_ipv6) {
2813 provider->ipconfig_ipv6 = __vpn_ipconfig_create(index,
2815 if (!provider->ipconfig_ipv6) {
2816 DBG("Couldn't create ipconfig for IPv6");
2821 __vpn_ipconfig_set_index(provider->ipconfig_ipv6, index);
2824 provider->index = index;
2827 int vpn_provider_get_index(struct vpn_provider *provider)
2829 return provider->index;
2832 int vpn_provider_set_ipaddress(struct vpn_provider *provider,
2833 struct connman_ipaddress *ipaddress)
2835 struct vpn_ipconfig *ipconfig = NULL;
2837 switch (ipaddress->family) {
2839 ipconfig = provider->ipconfig_ipv4;
2842 ipconfig = provider->ipconfig_ipv6;
2848 DBG("provider %p state %d ipconfig %p family %d", provider,
2849 provider->state, ipconfig, ipaddress->family);
2854 provider->family = ipaddress->family;
2856 if (provider->state == VPN_PROVIDER_STATE_CONNECT ||
2857 provider->state == VPN_PROVIDER_STATE_READY) {
2858 struct connman_ipaddress *addr =
2859 __vpn_ipconfig_get_address(ipconfig);
2862 * Remember the old address so that we can remove it in notify
2863 * function in plugins/vpn.c if we ever restart
2865 if (ipaddress->family == AF_INET6) {
2866 connman_ipaddress_free(provider->prev_ipv6_addr);
2867 provider->prev_ipv6_addr =
2868 connman_ipaddress_copy(addr);
2870 connman_ipaddress_free(provider->prev_ipv4_addr);
2871 provider->prev_ipv4_addr =
2872 connman_ipaddress_copy(addr);
2876 if (ipaddress->local) {
2877 __vpn_ipconfig_set_local(ipconfig, ipaddress->local);
2878 __vpn_ipconfig_set_peer(ipconfig, ipaddress->peer);
2879 __vpn_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
2880 __vpn_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
2881 __vpn_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
2887 int vpn_provider_set_pac(struct vpn_provider *provider,
2890 DBG("provider %p pac %s", provider, pac);
2896 int vpn_provider_set_domain(struct vpn_provider *provider,
2899 DBG("provider %p domain %s", provider, domain);
2901 g_free(provider->domain);
2902 provider->domain = g_strdup(domain);
2907 int vpn_provider_set_nameservers(struct vpn_provider *provider,
2908 const char *nameservers)
2910 DBG("provider %p nameservers %s", provider, nameservers);
2912 g_strfreev(provider->nameservers);
2913 provider->nameservers = NULL;
2918 provider->nameservers = g_strsplit_set(nameservers, ", ", 0);
2923 static int route_env_parse(struct vpn_provider *provider, const char *key,
2924 int *family, unsigned long *idx,
2925 enum vpn_provider_route_type *type)
2930 DBG("name %s", provider->name);
2932 if (provider->driver && provider->driver->route_env_parse)
2933 return provider->driver->route_env_parse(provider, key, family, idx,
2939 int vpn_provider_append_route(struct vpn_provider *provider,
2940 const char *key, const char *value)
2942 struct vpn_route *route;
2943 int ret, family = 0;
2944 unsigned long idx = 0;
2945 enum vpn_provider_route_type type = VPN_PROVIDER_ROUTE_TYPE_NONE;
2947 DBG("key %s value %s", key, value);
2949 ret = route_env_parse(provider, key, &family, &idx, &type);
2953 DBG("idx %lu family %d type %d", idx, family, type);
2955 route = g_hash_table_lookup(provider->routes, GINT_TO_POINTER(idx));
2957 route = g_try_new0(struct vpn_route, 1);
2959 connman_error("out of memory");
2963 route->family = family;
2965 g_hash_table_replace(provider->routes, GINT_TO_POINTER(idx),
2970 case VPN_PROVIDER_ROUTE_TYPE_NONE:
2972 case VPN_PROVIDER_ROUTE_TYPE_MASK:
2973 route->netmask = g_strdup(value);
2975 case VPN_PROVIDER_ROUTE_TYPE_ADDR:
2976 route->network = g_strdup(value);
2978 case VPN_PROVIDER_ROUTE_TYPE_GW:
2979 route->gateway = g_strdup(value);
2983 if (route->netmask && route->gateway && route->network)
2984 provider_schedule_changed(provider);
2989 const char *vpn_provider_get_driver_name(struct vpn_provider *provider)
2991 if (!provider->driver)
2994 return provider->driver->name;
2997 const char *vpn_provider_get_save_group(struct vpn_provider *provider)
2999 return provider->identifier;
3002 static gint compare_priority(gconstpointer a, gconstpointer b)
3007 static void clean_provider(gpointer key, gpointer value, gpointer user_data)
3009 struct vpn_provider *provider = value;
3011 if (provider->driver && provider->driver->remove)
3012 provider->driver->remove(provider);
3014 connection_unregister(provider);
3017 int vpn_provider_driver_register(struct vpn_provider_driver *driver)
3019 DBG("driver %p name %s", driver, driver->name);
3021 driver_list = g_slist_insert_sorted(driver_list, driver,
3023 provider_create_all_from_type(driver->name);
3027 void vpn_provider_driver_unregister(struct vpn_provider_driver *driver)
3029 GHashTableIter iter;
3030 gpointer value, key;
3032 DBG("driver %p name %s", driver, driver->name);
3034 driver_list = g_slist_remove(driver_list, driver);
3036 g_hash_table_iter_init(&iter, provider_hash);
3037 while (g_hash_table_iter_next(&iter, &key, &value)) {
3038 struct vpn_provider *provider = value;
3040 if (provider && provider->driver &&
3041 g_strcmp0(provider->driver->name,
3042 driver->name) == 0) {
3044 * Cancel VPN agent request to avoid segfault at
3045 * shutdown as the callback, if set can point to a
3046 * function in the plugin that is to be removed.
3048 connman_agent_cancel(provider);
3049 provider->driver = NULL;
3054 const char *vpn_provider_get_name(struct vpn_provider *provider)
3056 return provider->name;
3059 const char *vpn_provider_get_host(struct vpn_provider *provider)
3061 return provider->host;
3064 const char *vpn_provider_get_path(struct vpn_provider *provider)
3066 return provider->path;
3069 unsigned int vpn_provider_get_authentication_errors(
3070 struct vpn_provider *provider)
3072 return provider->auth_error_counter;
3075 unsigned int vpn_provider_get_connection_errors(
3076 struct vpn_provider *provider)
3078 return provider->conn_error_counter;
3081 void vpn_provider_change_address(struct vpn_provider *provider)
3083 switch (provider->family) {
3085 connman_inet_set_address(provider->index,
3086 __vpn_ipconfig_get_address(provider->ipconfig_ipv4));
3089 connman_inet_set_ipv6_address(provider->index,
3090 __vpn_ipconfig_get_address(provider->ipconfig_ipv6));
3097 void vpn_provider_clear_address(struct vpn_provider *provider, int family)
3099 const char *address;
3102 DBG("provider %p family %d ipv4 %p ipv6 %p", provider, family,
3103 provider->prev_ipv4_addr, provider->prev_ipv6_addr);
3107 if (provider->prev_ipv4_addr) {
3108 connman_ipaddress_get_ip(provider->prev_ipv4_addr,
3111 DBG("ipv4 %s/%d", address, len);
3113 connman_inet_clear_address(provider->index,
3114 provider->prev_ipv4_addr);
3115 connman_ipaddress_free(provider->prev_ipv4_addr);
3116 provider->prev_ipv4_addr = NULL;
3120 if (provider->prev_ipv6_addr) {
3121 connman_ipaddress_get_ip(provider->prev_ipv6_addr,
3124 DBG("ipv6 %s/%d", address, len);
3126 connman_inet_clear_ipv6_address(provider->index,
3127 provider->prev_ipv6_addr);
3129 connman_ipaddress_free(provider->prev_ipv6_addr);
3130 provider->prev_ipv6_addr = NULL;
3138 static int agent_probe(struct connman_agent *agent)
3140 DBG("agent %p", agent);
3144 static void agent_remove(struct connman_agent *agent)
3146 DBG("agent %p", agent);
3149 static struct connman_agent_driver agent_driver = {
3151 .interface = VPN_AGENT_INTERFACE,
3152 .probe = agent_probe,
3153 .remove = agent_remove,
3156 static void remove_unprovisioned_providers(void)
3159 GKeyFile *keyfile, *configkeyfile;
3160 char *file, *section;
3163 providers = __connman_storage_get_providers();
3167 for (; providers[i]; i++) {
3168 char *group = providers[i] + sizeof("provider_") - 1;
3169 file = section = NULL;
3170 keyfile = configkeyfile = NULL;
3172 keyfile = __connman_storage_load_provider(group);
3176 file = __vpn_config_get_string(keyfile, group,
3177 "Config.file", NULL);
3181 section = __vpn_config_get_string(keyfile, group,
3182 "Config.ident", NULL);
3186 configkeyfile = __connman_storage_load_provider_config(file);
3187 if (!configkeyfile) {
3189 * Config file is missing, remove the provisioned
3192 __connman_storage_remove_provider(group);
3196 if (!g_key_file_has_group(configkeyfile, section))
3198 * Config section is missing, remove the provisioned
3201 __connman_storage_remove_provider(group);
3205 g_key_file_free(keyfile);
3208 g_key_file_free(configkeyfile);
3214 g_strfreev(providers);
3217 int __vpn_provider_init(void)
3223 err = connman_agent_driver_register(&agent_driver);
3225 connman_error("Cannot register agent driver for %s",
3230 connection = connman_dbus_get_connection();
3232 remove_unprovisioned_providers();
3234 provider_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
3235 NULL, unregister_provider);
3239 void __vpn_provider_cleanup(void)
3243 connman_agent_driver_unregister(&agent_driver);
3245 g_hash_table_foreach(provider_hash, clean_provider, NULL);
3247 g_hash_table_destroy(provider_hash);
3248 provider_hash = NULL;
3250 dbus_connection_unref(connection);