5 * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
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.
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.
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
28 #include <sys/socket.h>
34 #define CONNMAN_API_SUBJECT_TO_CHANGE
35 #include <connman/technology.h>
36 #include <connman/plugin.h>
37 #include <connman/log.h>
38 #include <connman/dbus.h>
39 #include <connman/provider.h>
40 #include <connman/ipaddress.h>
41 #include <connman/notifier.h>
42 #include <connman/vpn-dbus.h>
43 #include <connman/inet.h>
44 #include <gweb/gresolv.h>
46 #define DBUS_TIMEOUT 10000
48 static DBusConnection *connection;
50 static GHashTable *vpn_connections = NULL;
52 static guint added_watch;
53 static guint removed_watch;
54 static guint property_watch;
63 struct config_create_data {
64 connection_ready_cb callback;
69 struct connection_data {
72 struct connman_provider *provider;
74 DBusPendingCall *call;
75 DBusPendingCall *disconnect_call;
77 struct config_create_data *cb_data;
89 GHashTable *server_routes;
90 GHashTable *user_routes;
91 GHashTable *setting_strings;
93 struct connman_ipaddress *ip;
99 static int set_string(struct connman_provider *provider,
100 const char *key, const char *value)
102 struct connection_data *data;
104 data = connman_provider_get_data(provider);
108 DBG("data %p provider %p key %s value %s", data, provider, key, value);
110 if (g_str_equal(key, "Type")) {
112 data->type = g_strdup(value);
113 } else if (g_str_equal(key, "Name")) {
115 data->name = g_strdup(value);
116 } else if (g_str_equal(key, "Host")) {
118 data->host = g_strdup(value);
119 } else if (g_str_equal(key, "VPN.Domain") ||
120 g_str_equal(key, "Domain")) {
121 g_free(data->domain);
122 data->domain = g_strdup(value);
124 g_hash_table_replace(data->setting_strings,
125 g_strdup(key), g_strdup(value));
129 static const char *get_string(struct connman_provider *provider,
132 struct connection_data *data;
134 data = connman_provider_get_data(provider);
138 DBG("data %p provider %p key %s", data, provider, key);
140 if (g_str_equal(key, "Type"))
142 else if (g_str_equal(key, "Name"))
144 else if (g_str_equal(key, "Host"))
146 else if (g_str_equal(key, "HostIP")) {
147 if (!data->host_ip ||
151 return data->host_ip[0];
152 } else if (g_str_equal(key, "VPN.Domain"))
155 return g_hash_table_lookup(data->setting_strings, key);
158 static char *get_ident(const char *path)
165 pos = strrchr(path, '/');
172 static void cancel_host_resolv(struct connection_data *data)
174 if (data->resolv_id != 0)
175 g_resolv_cancel_lookup(data->resolv, data->resolv_id);
179 g_resolv_unref(data->resolv);
183 static gboolean remove_resolv(gpointer user_data)
185 struct connection_data *data = user_data;
187 cancel_host_resolv(data);
192 static void resolv_result(GResolvResultStatus status,
193 char **results, gpointer user_data)
195 struct connection_data *data = user_data;
197 DBG("status %d", status);
199 if (status == G_RESOLV_RESULT_STATUS_SUCCESS && results &&
200 g_strv_length(results) > 0) {
201 g_strfreev(data->host_ip);
202 data->host_ip = g_strdupv(results);
206 * We cannot unref the resolver here as resolv struct is manipulated
207 * by gresolv.c after we return from this callback.
209 g_idle_add(remove_resolv, data);
214 static void resolv_host_addr(struct connection_data *data)
219 if (connman_inet_check_ipaddress(data->host) > 0)
225 data->resolv = g_resolv_new(0);
227 DBG("Cannot resolv %s", data->host);
231 DBG("Trying to resolv %s", data->host);
233 data->resolv_id = g_resolv_lookup_hostname(data->resolv, data->host,
234 resolv_result, data);
237 static void free_config_cb_data(struct config_create_data *cb_data)
242 g_free(cb_data->path);
243 cb_data->path = NULL;
245 if (cb_data->message) {
246 dbus_message_unref(cb_data->message);
247 cb_data->message = NULL;
250 cb_data->callback = NULL;
255 static bool provider_is_connected(struct connection_data *data)
257 return data && (g_str_equal(data->state, "ready") ||
258 g_str_equal(data->state, "configuration"));
261 static void set_provider_state(struct connection_data *data)
263 enum connman_provider_state state = CONNMAN_PROVIDER_STATE_UNKNOWN;
266 DBG("provider %p new state %s", data->provider, data->state);
268 if (!provider_is_connected(data)) {
269 g_free(data->service_ident);
270 data->service_ident = NULL;
273 if (g_str_equal(data->state, "ready")) {
274 state = CONNMAN_PROVIDER_STATE_READY;
276 } else if (g_str_equal(data->state, "configuration")) {
277 state = CONNMAN_PROVIDER_STATE_CONNECT;
278 } else if (g_str_equal(data->state, "idle")) {
279 state = CONNMAN_PROVIDER_STATE_IDLE;
280 } else if (g_str_equal(data->state, "disconnect")) {
282 state = CONNMAN_PROVIDER_STATE_DISCONNECT;
284 } else if (g_str_equal(data->state, "failure")) {
286 state = CONNMAN_PROVIDER_STATE_FAILURE;
290 connman_provider_set_state(data->provider, state);
295 data->cb_data->callback(data->cb_data->message,
298 connman_provider_set_state(data->provider, state);
300 free_config_cb_data(data->cb_data);
301 data->cb_data = NULL;
304 static int create_provider(struct connection_data *data, void *user_data)
306 struct connman_provider_driver *driver = user_data;
309 DBG("%s", data->path);
311 data->provider = connman_provider_get(data->ident);
315 DBG("provider %p name %s", data->provider, data->name);
317 connman_provider_set_data(data->provider, data);
318 connman_provider_set_driver(data->provider, driver);
320 err = connman_provider_create_service(data->provider);
322 connman_provider_set_immutable(data->provider, data->immutable);
323 if (g_str_equal(data->state, "ready")) {
324 connman_provider_set_index(data->provider,
327 connman_provider_set_ipaddress(data->provider,
331 set_provider_state(data);
337 static void destroy_route(gpointer user_data)
339 struct vpn_route *route = user_data;
341 g_free(route->network);
342 g_free(route->netmask);
343 g_free(route->gateway);
347 static struct connection_data *create_connection_data(const char *path)
349 struct connection_data *data;
351 data = g_try_new0(struct connection_data, 1);
355 DBG("path %s", path);
357 data->path = g_strdup(path);
358 data->ident = g_strdup(get_ident(path));
361 data->setting_strings = g_hash_table_new_full(g_str_hash,
362 g_str_equal, g_free, g_free);
364 data->server_routes = g_hash_table_new_full(g_direct_hash,
365 g_str_equal, g_free, destroy_route);
366 data->user_routes = g_hash_table_new_full(g_str_hash,
367 g_str_equal, g_free, destroy_route);
372 static int extract_ip(DBusMessageIter *array, int family,
373 struct connection_data *data)
375 DBusMessageIter dict;
376 char *address = NULL, *gateway = NULL, *netmask = NULL, *peer = NULL;
377 unsigned char prefix_len;
379 if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
382 dbus_message_iter_recurse(array, &dict);
384 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
385 DBusMessageIter entry, value;
388 dbus_message_iter_recurse(&dict, &entry);
389 dbus_message_iter_get_basic(&entry, &key);
391 dbus_message_iter_next(&entry);
392 dbus_message_iter_recurse(&entry, &value);
394 if (g_str_equal(key, "Address")) {
395 dbus_message_iter_get_basic(&value, &address);
396 DBG("address %s", address);
397 } else if (g_str_equal(key, "Netmask")) {
398 dbus_message_iter_get_basic(&value, &netmask);
399 DBG("netmask %s", netmask);
400 } else if (g_str_equal(key, "PrefixLength")) {
401 dbus_message_iter_get_basic(&value, &netmask);
402 DBG("prefix length %s", netmask);
403 } else if (g_str_equal(key, "Peer")) {
404 dbus_message_iter_get_basic(&value, &peer);
405 DBG("peer %s", peer);
406 } else if (g_str_equal(key, "Gateway")) {
407 dbus_message_iter_get_basic(&value, &gateway);
408 DBG("gateway %s", gateway);
411 dbus_message_iter_next(&dict);
414 connman_ipaddress_free(data->ip);
415 data->ip = connman_ipaddress_alloc(family);
421 connman_ipaddress_set_ipv4(data->ip, address, netmask,
425 prefix_len = atoi(netmask);
426 connman_ipaddress_set_ipv6(data->ip, address, prefix_len,
433 connman_ipaddress_set_peer(data->ip, peer);
438 static int extract_nameservers(DBusMessageIter *array,
439 struct connection_data *data)
441 DBusMessageIter entry;
442 char **nameservers = NULL;
445 dbus_message_iter_recurse(array, &entry);
447 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
448 const char *nameserver;
450 dbus_message_iter_get_basic(&entry, &nameserver);
452 nameservers = g_try_renew(char *, nameservers, i + 2);
456 DBG("[%d] %s", i, nameserver);
458 nameservers[i] = g_strdup(nameserver);
462 nameservers[++i] = NULL;
464 dbus_message_iter_next(&entry);
467 g_strfreev(data->nameservers);
468 data->nameservers = nameservers;
473 static int errorstr2val(const char *error) {
474 if (g_strcmp0(error, CONNMAN_ERROR_INTERFACE ".InProgress") == 0)
477 if (g_strcmp0(error, CONNMAN_ERROR_INTERFACE ".AlreadyConnected") == 0)
480 return -ECONNREFUSED;
483 static void connect_reply(DBusPendingCall *call, void *user_data)
487 struct connection_data *data = user_data;
488 struct config_create_data *cb_data = data->cb_data;
490 if (!dbus_pending_call_get_completed(call))
493 DBG("user_data %p path %s", user_data, cb_data ? cb_data->path : NULL);
495 reply = dbus_pending_call_steal_reply(call);
497 dbus_error_init(&error);
499 if (dbus_set_error_from_message(&error, reply)) {
500 int err = errorstr2val(error.name);
502 if (err != -EINPROGRESS) {
503 connman_error("Connect reply: %s (%s)", error.message,
505 DBG("data %p cb_data %p", data, cb_data);
508 cb_data->callback(cb_data->message, err, NULL);
509 free_config_cb_data(cb_data);
510 data->cb_data = NULL;
514 dbus_error_free(&error);
518 * The vpn connection is up when we get a "ready" state
519 * property so at this point we do nothing for the provider
523 dbus_message_unref(reply);
525 dbus_pending_call_unref(call);
528 static int connect_provider(struct connection_data *data, void *user_data,
529 const char *dbus_sender)
531 DBusPendingCall *call;
532 DBusMessage *message;
533 struct config_create_data *cb_data = user_data;
534 struct connman_service *transport = connman_service_get_default();
536 DBG("data %p user %p path %s sender %s", data, cb_data, data->path,
540 DBG("no default service, refusing to connect");
544 data->connect_pending = false;
546 /* We need to pass original dbus sender to connman-vpnd,
547 * use a Connect2 method for that if the original dbus sender is set.
548 * Connect method requires no parameter, Connect2 requires dbus sender
551 message = dbus_message_new_method_call(VPN_SERVICE, data->path,
552 VPN_CONNECTION_INTERFACE,
553 dbus_sender && *dbus_sender ?
554 VPN_CONNECT2 : VPN_CONNECT);
558 if (dbus_sender && *dbus_sender)
559 dbus_message_append_args(message, DBUS_TYPE_STRING,
564 if (!dbus_connection_send_with_reply(connection, message,
565 &call, DBUS_TIMEOUT)) {
566 connman_error("Unable to call %s.%s()",
567 VPN_CONNECTION_INTERFACE, dbus_sender && *dbus_sender ?
568 VPN_CONNECT2 : VPN_CONNECT);
569 dbus_message_unref(message);
574 dbus_message_unref(message);
579 g_free(cb_data->path);
580 cb_data->path = g_strdup(data->path);
584 * This is the service which (most likely) will be used
585 * as a transport for VPN connection.
587 g_free(data->service_ident);
588 data->service_ident =
589 g_strdup(connman_service_get_identifier(transport));
590 DBG("transport %s", data->service_ident);
592 dbus_pending_call_set_notify(call, connect_reply, data, NULL);
594 dbus_message_unref(message);
599 static void add_connection(const char *path, DBusMessageIter *properties,
602 struct connection_data *data;
604 char *ident = get_ident(path);
607 data = g_hash_table_lookup(vpn_connections, ident);
610 * We might have a dummy connection struct here that
611 * was created by configuration_create_reply() so in
612 * that case just continue.
614 if (!data->connect_pending)
619 data = create_connection_data(path);
624 DBG("data %p path %s", data, path);
626 while (dbus_message_iter_get_arg_type(properties) ==
627 DBUS_TYPE_DICT_ENTRY) {
628 DBusMessageIter entry, value;
632 dbus_message_iter_recurse(properties, &entry);
633 dbus_message_iter_get_basic(&entry, &key);
635 dbus_message_iter_next(&entry);
636 dbus_message_iter_recurse(&entry, &value);
638 if (g_str_equal(key, "State")) {
639 dbus_message_iter_get_basic(&value, &str);
640 DBG("state %s -> %s", data->state, str);
641 data->state = g_strdup(str);
642 } else if (g_str_equal(key, "IPv4")) {
643 extract_ip(&value, AF_INET, data);
644 } else if (g_str_equal(key, "IPv6")) {
645 extract_ip(&value, AF_INET6, data);
646 } else if (g_str_equal(key, "Name")) {
647 dbus_message_iter_get_basic(&value, &str);
648 data->name = g_strdup(str);
649 } else if (g_str_equal(key, "Type")) {
650 dbus_message_iter_get_basic(&value, &str);
651 data->type = g_strdup(str);
652 } else if (g_str_equal(key, "Immutable")) {
653 dbus_bool_t immutable;
655 dbus_message_iter_get_basic(&value, &immutable);
656 data->immutable = immutable;
657 } else if (g_str_equal(key, "Host")) {
658 dbus_message_iter_get_basic(&value, &str);
659 data->host = g_strdup(str);
660 } else if (g_str_equal(key, "Domain")) {
661 dbus_message_iter_get_basic(&value, &str);
662 g_free(data->domain);
663 data->domain = g_strdup(str);
664 } else if (g_str_equal(key, "Nameservers")) {
665 extract_nameservers(&value, data);
666 } else if (g_str_equal(key, "Index")) {
667 dbus_message_iter_get_basic(&value, &data->index);
668 } else if (g_str_equal(key, "ServerRoutes")) {
670 } else if (g_str_equal(key, "UserRoutes")) {
673 if (dbus_message_iter_get_arg_type(&value) ==
675 dbus_message_iter_get_basic(&value, &str);
676 g_hash_table_replace(data->setting_strings,
677 g_strdup(key), g_strdup(str));
679 DBG("unknown key %s", key);
683 dbus_message_iter_next(properties);
687 g_hash_table_insert(vpn_connections, g_strdup(data->ident),
690 err = create_provider(data, user_data);
694 resolv_host_addr(data);
696 if (data->nameservers)
697 connman_provider_set_nameservers(data->provider,
701 connman_provider_set_domain(data->provider,
704 if (data->connect_pending) {
705 const char *dbus_sender = NULL;
707 if (data->cb_data && data->cb_data->message) {
709 dbus_message_get_sender(data->cb_data->message);
711 connect_provider(data, data->cb_data, dbus_sender);
717 DBG("removing %s", data->ident);
718 g_hash_table_remove(vpn_connections, data->ident);
721 static void get_connections_reply(DBusPendingCall *call, void *user_data)
725 DBusMessageIter array, dict;
726 const char *signature = DBUS_TYPE_ARRAY_AS_STRING
727 DBUS_STRUCT_BEGIN_CHAR_AS_STRING
728 DBUS_TYPE_OBJECT_PATH_AS_STRING
729 DBUS_TYPE_ARRAY_AS_STRING
730 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
731 DBUS_TYPE_STRING_AS_STRING
732 DBUS_TYPE_VARIANT_AS_STRING
733 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
734 DBUS_STRUCT_END_CHAR_AS_STRING;
736 if (!dbus_pending_call_get_completed(call))
741 reply = dbus_pending_call_steal_reply(call);
743 dbus_error_init(&error);
745 if (dbus_set_error_from_message(&error, reply)) {
746 connman_error("%s", error.message);
747 dbus_error_free(&error);
751 if (!dbus_message_has_signature(reply, signature)) {
752 connman_error("vpnd signature \"%s\" does not match "
754 dbus_message_get_signature(reply), signature);
758 if (!dbus_message_iter_init(reply, &array))
761 dbus_message_iter_recurse(&array, &dict);
763 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_STRUCT) {
764 DBusMessageIter value, properties;
767 dbus_message_iter_recurse(&dict, &value);
768 dbus_message_iter_get_basic(&value, &path);
770 dbus_message_iter_next(&value);
771 dbus_message_iter_recurse(&value, &properties);
773 add_connection(path, &properties, user_data);
775 dbus_message_iter_next(&dict);
779 dbus_message_unref(reply);
781 dbus_pending_call_unref(call);
784 static int get_connections(void *user_data)
786 DBusPendingCall *call;
787 DBusMessage *message;
791 message = dbus_message_new_method_call(VPN_SERVICE, "/",
792 VPN_MANAGER_INTERFACE,
797 if (!dbus_connection_send_with_reply(connection, message,
798 &call, DBUS_TIMEOUT)) {
799 connman_error("Unable to call %s.%s()", VPN_MANAGER_INTERFACE,
801 dbus_message_unref(message);
806 dbus_message_unref(message);
810 dbus_pending_call_set_notify(call, get_connections_reply,
813 dbus_message_unref(message);
818 static int provider_probe(struct connman_provider *provider)
823 static void remove_connection_reply(DBusPendingCall *call, void *user_data)
828 if (!dbus_pending_call_get_completed(call))
833 reply = dbus_pending_call_steal_reply(call);
835 dbus_error_init(&error);
837 if (dbus_set_error_from_message(&error, reply)) {
839 * If the returned error is NotFound, it means that we
840 * have actually removed the provider in vpnd already.
842 if (!dbus_error_has_name(&error,
843 CONNMAN_ERROR_INTERFACE".NotFound"))
844 connman_error("%s", error.message);
846 dbus_error_free(&error);
849 dbus_message_unref(reply);
851 dbus_pending_call_unref(call);
854 static int provider_remove(struct connman_provider *provider)
856 DBusPendingCall *call;
857 DBusMessage *message;
858 struct connection_data *data;
860 data = connman_provider_get_data(provider);
862 DBG("provider %p data %p", provider, data);
866 * This means the provider is already removed,
867 * just ignore the dbus in this case.
873 * When provider.c:provider_remove() calls this function,
874 * it will remove the provider itself after the call.
875 * This means that we cannot use the provider pointer later
876 * as it is no longer valid.
878 data->provider = NULL;
880 message = dbus_message_new_method_call(VPN_SERVICE, "/",
881 VPN_MANAGER_INTERFACE,
886 dbus_message_append_args(message, DBUS_TYPE_OBJECT_PATH, &data->path,
889 if (!dbus_connection_send_with_reply(connection, message,
890 &call, DBUS_TIMEOUT)) {
891 connman_error("Unable to call %s.%s()", VPN_MANAGER_INTERFACE,
893 dbus_message_unref(message);
898 dbus_message_unref(message);
902 dbus_pending_call_set_notify(call, remove_connection_reply,
905 dbus_message_unref(message);
910 static int provider_connect(struct connman_provider *provider,
911 const char *dbus_sender)
913 struct connection_data *data;
915 data = connman_provider_get_data(provider);
919 return connect_provider(data, NULL, dbus_sender);
922 static void disconnect_reply(DBusPendingCall *call, void *user_data)
924 struct connection_data *data = user_data;
928 DBG("user %p", user_data);
930 reply = dbus_pending_call_steal_reply(call);
932 dbus_error_init(&error);
934 if (dbus_set_error_from_message(&error, reply)) {
935 connman_error("%s", error.message);
936 dbus_error_free(&error);
941 dbus_message_unref(reply);
942 dbus_pending_call_unref(call);
943 data->disconnect_call = NULL;
946 static int disconnect_provider(struct connection_data *data)
949 DBusMessage *message;
951 DBG("data %p path %s", data, data->path);
953 if (data->disconnect_call) {
954 DBG("already disconnecting");
958 message = dbus_message_new_method_call(VPN_SERVICE, data->path,
959 VPN_CONNECTION_INTERFACE,
964 sent = dbus_connection_send_with_reply(connection, message,
965 &data->disconnect_call, DBUS_TIMEOUT);
966 dbus_message_unref(message);
968 if (!sent || !data->disconnect_call) {
969 connman_error("Unable to call %s.%s()",
970 VPN_CONNECTION_INTERFACE, VPN_DISCONNECT);
974 dbus_pending_call_set_notify(data->disconnect_call, disconnect_reply,
977 g_free(data->service_ident);
978 data->service_ident = NULL;
980 connman_provider_set_state(data->provider,
981 CONNMAN_PROVIDER_STATE_DISCONNECT);
985 static int provider_disconnect(struct connman_provider *provider)
987 struct connection_data *data;
989 DBG("provider %p", provider);
991 data = connman_provider_get_data(provider);
995 if (provider_is_connected(data))
996 return disconnect_provider(data);
1001 static void configuration_create_reply(DBusPendingCall *call, void *user_data)
1005 DBusMessageIter iter;
1006 const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
1009 struct connection_data *data;
1010 struct config_create_data *cb_data = user_data;
1012 if (!dbus_pending_call_get_completed(call))
1015 DBG("user %p", cb_data);
1017 reply = dbus_pending_call_steal_reply(call);
1019 dbus_error_init(&error);
1021 if (dbus_set_error_from_message(&error, reply)) {
1022 connman_error("dbus error: %s", error.message);
1023 dbus_error_free(&error);
1027 if (!dbus_message_has_signature(reply, signature)) {
1028 connman_error("vpn configuration signature \"%s\" does not "
1029 "match expected \"%s\"",
1030 dbus_message_get_signature(reply), signature);
1034 if (!dbus_message_iter_init(reply, &iter))
1037 dbus_message_iter_get_basic(&iter, &path);
1040 * Then try to connect the VPN as expected by ConnectProvider API
1042 ident = get_ident(path);
1044 data = g_hash_table_lookup(vpn_connections, ident);
1047 * Someone removed the data. We cannot really continue.
1049 DBG("Pending data not found for %s, cannot continue!", ident);
1052 data->connect_pending = true;
1055 data->cb_data = cb_data;
1057 DBG("Connection callback data already in use!");
1060 * Connection is created in add_connections() after
1061 * we have received the ConnectionAdded signal.
1064 DBG("cb %p msg %p", data->cb_data,
1065 data->cb_data ? data->cb_data->message : NULL);
1069 dbus_message_unref(reply);
1071 dbus_pending_call_unref(call);
1074 static void set_dbus_ident(char *ident)
1076 int i, len = strlen(ident);
1078 for (i = 0; i < len; i++) {
1079 if (ident[i] >= '0' && ident[i] <= '9')
1081 if (ident[i] >= 'a' && ident[i] <= 'z')
1083 if (ident[i] >= 'A' && ident[i] <= 'Z')
1089 static struct vpn_route *parse_user_route(const char *user_route)
1091 char *network, *netmask;
1092 struct vpn_route *route = NULL;
1093 int family = PF_UNSPEC;
1094 char **elems = g_strsplit(user_route, "/", 0);
1100 if (!network || *network == '\0') {
1101 DBG("no network/netmask set");
1106 if (netmask && *netmask == '\0') {
1107 DBG("no netmask set");
1111 if (g_strrstr(network, ":"))
1113 else if (g_strrstr(network, ".")) {
1116 if (!g_strrstr(netmask, ".")) {
1117 /* We have netmask length */
1119 struct in_addr netmask_in;
1120 unsigned char prefix_len = 32;
1124 long int value = strtol(netmask, &ptr, 10);
1125 if (ptr != netmask && *ptr == '\0' &&
1126 value && value <= 32)
1130 addr = 0xffffffff << (32 - prefix_len);
1131 netmask_in.s_addr = htonl(addr);
1132 netmask = inet_ntoa(netmask_in);
1134 DBG("network %s netmask %s", network, netmask);
1138 route = g_try_new(struct vpn_route, 1);
1142 route->network = g_strdup(network);
1143 route->netmask = g_strdup(netmask);
1144 route->gateway = NULL;
1145 route->family = family;
1152 static GSList *get_user_networks(DBusMessageIter *array)
1154 DBusMessageIter entry;
1155 GSList *list = NULL;
1157 dbus_message_iter_recurse(array, &entry);
1159 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
1161 struct vpn_route *route;
1163 dbus_message_iter_get_basic(&entry, &val);
1165 route = parse_user_route(val);
1167 list = g_slist_prepend(list, route);
1169 dbus_message_iter_next(&entry);
1175 static void append_route(DBusMessageIter *iter, void *user_data)
1177 struct vpn_route *route = user_data;
1178 DBusMessageIter item;
1181 connman_dbus_dict_open(iter, &item);
1186 if (route->family == AF_INET)
1188 else if (route->family == AF_INET6)
1192 connman_dbus_dict_append_basic(&item, "ProtocolFamily",
1193 DBUS_TYPE_INT32, &family);
1196 connman_dbus_dict_append_basic(&item, "Network",
1197 DBUS_TYPE_STRING, &route->network);
1200 connman_dbus_dict_append_basic(&item, "Netmask",
1201 DBUS_TYPE_STRING, &route->netmask);
1204 connman_dbus_dict_append_basic(&item, "Gateway",
1205 DBUS_TYPE_STRING, &route->gateway);
1208 connman_dbus_dict_close(iter, &item);
1211 static void append_routes(DBusMessageIter *iter, void *user_data)
1213 GSList *list, *routes = user_data;
1215 DBG("routes %p", routes);
1217 for (list = routes; list; list = g_slist_next(list)) {
1218 DBusMessageIter dict;
1219 struct vpn_route *route = list->data;
1221 dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL,
1223 append_route(&dict, route);
1224 dbus_message_iter_close_container(iter, &dict);
1228 static int create_configuration(DBusMessage *msg, connection_ready_cb callback)
1230 DBusMessage *new_msg = NULL;
1231 DBusPendingCall *call;
1232 DBusMessageIter iter, array, new_iter, new_dict;
1233 const char *type = NULL, *name = NULL;
1234 const char *host = NULL, *domain = NULL;
1235 char *ident, *me = NULL;
1238 struct connection_data *data;
1239 struct config_create_data *user_data = NULL;
1240 GSList *networks = NULL;
1243 * We copy the old message data into new message. We cannot
1244 * just use the old message as is because the user route
1245 * information is not in the same format in vpnd.
1247 new_msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
1248 dbus_message_iter_init_append(new_msg, &new_iter);
1249 connman_dbus_dict_open(&new_iter, &new_dict);
1251 dbus_message_iter_init(msg, &iter);
1252 dbus_message_iter_recurse(&iter, &array);
1254 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
1255 DBusMessageIter entry, value;
1260 dbus_message_iter_recurse(&array, &entry);
1261 dbus_message_iter_get_basic(&entry, &key);
1263 dbus_message_iter_next(&entry);
1264 dbus_message_iter_recurse(&entry, &value);
1266 value_type = dbus_message_iter_get_arg_type(&value);
1269 switch (value_type) {
1270 case DBUS_TYPE_STRING:
1271 dbus_message_iter_get_basic(&value, &item_value);
1273 if (g_str_equal(key, "Type"))
1274 type = (const char *)item_value;
1275 else if (g_str_equal(key, "Name"))
1276 name = (const char *)item_value;
1277 else if (g_str_equal(key, "Host"))
1278 host = (const char *)item_value;
1279 else if (g_str_equal(key, "VPN.Domain"))
1280 domain = (const char *)item_value;
1282 DBG("%s %s", key, (char *)item_value);
1285 connman_dbus_dict_append_basic(&new_dict, key,
1286 value_type, &item_value);
1288 case DBUS_TYPE_ARRAY:
1289 if (g_str_equal(key, "Networks")) {
1290 networks = get_user_networks(&value);
1291 connman_dbus_dict_append_array(&new_dict,
1293 DBUS_TYPE_DICT_ENTRY,
1300 dbus_message_iter_next(&array);
1303 connman_dbus_dict_close(&new_iter, &new_dict);
1305 DBG("VPN type %s name %s host %s domain %s networks %p",
1306 type, name, host, domain, networks);
1308 if (!host || !domain) {
1313 if (!type || !name) {
1318 ident = g_strdup_printf("%s_%s", host, domain);
1319 set_dbus_ident(ident);
1321 DBG("ident %s", ident);
1323 data = g_hash_table_lookup(vpn_connections, ident);
1325 if (data->call || data->cb_data) {
1326 DBG("create configuration call already pending");
1331 char *path = g_strdup_printf("%s/connection/%s", VPN_PATH,
1333 data = create_connection_data(path);
1341 g_hash_table_insert(vpn_connections, g_strdup(ident), data);
1345 * User called net.connman.Manager.ConnectProvider if we are here.
1346 * So use the data from original message in the new msg.
1348 me = g_strdup(dbus_message_get_destination(msg));
1350 dbus_message_set_interface(new_msg, VPN_MANAGER_INTERFACE);
1351 dbus_message_set_path(new_msg, "/");
1352 dbus_message_set_destination(new_msg, VPN_SERVICE);
1353 dbus_message_set_sender(new_msg, me);
1354 dbus_message_set_member(new_msg, "Create");
1356 user_data = g_try_new0(struct config_create_data, 1);
1362 user_data->callback = callback;
1363 user_data->message = dbus_message_ref(msg);
1364 user_data->path = NULL;
1366 DBG("cb %p msg %p", user_data, msg);
1368 result = dbus_connection_send_with_reply(connection, new_msg,
1369 &call, DBUS_TIMEOUT);
1370 if (!result || !call) {
1375 dbus_pending_call_set_notify(call, configuration_create_reply,
1381 dbus_message_unref(new_msg);
1384 g_slist_free_full(networks, destroy_route);
1390 static bool check_host(char **hosts, char *host)
1397 for (i = 0; hosts[i]; i++) {
1398 if (g_strcmp0(hosts[i], host) == 0)
1405 static void set_route(struct connection_data *data, struct vpn_route *route)
1408 * If the VPN administrator/user has given a route to
1409 * VPN server, then we must discard that because the
1410 * server cannot be contacted via VPN tunnel.
1412 if (check_host(data->host_ip, route->network)) {
1413 DBG("Discarding VPN route to %s via %s at index %d",
1414 route->network, route->gateway, data->index);
1418 if (route->family == AF_INET6) {
1419 unsigned char prefix_len = atoi(route->netmask);
1421 connman_inet_add_ipv6_network_route(data->index,
1426 connman_inet_add_network_route(data->index, route->network,
1432 static int set_routes(struct connman_provider *provider,
1433 enum connman_provider_route_type type)
1435 struct connection_data *data;
1436 GHashTableIter iter;
1437 gpointer value, key;
1439 DBG("provider %p", provider);
1441 data = connman_provider_get_data(provider);
1445 if (type == CONNMAN_PROVIDER_ROUTE_ALL ||
1446 type == CONNMAN_PROVIDER_ROUTE_USER) {
1447 g_hash_table_iter_init(&iter, data->user_routes);
1449 while (g_hash_table_iter_next(&iter, &key, &value))
1450 set_route(data, value);
1453 if (type == CONNMAN_PROVIDER_ROUTE_ALL ||
1454 type == CONNMAN_PROVIDER_ROUTE_SERVER) {
1455 g_hash_table_iter_init(&iter, data->server_routes);
1457 while (g_hash_table_iter_next(&iter, &key, &value))
1458 set_route(data, value);
1464 static bool check_routes(struct connman_provider *provider)
1466 struct connection_data *data;
1468 DBG("provider %p", provider);
1470 data = connman_provider_get_data(provider);
1474 if (data->user_routes &&
1475 g_hash_table_size(data->user_routes) > 0)
1478 if (data->server_routes &&
1479 g_hash_table_size(data->server_routes) > 0)
1485 static struct connman_provider_driver provider_driver = {
1487 .type = CONNMAN_PROVIDER_TYPE_VPN,
1488 .probe = provider_probe,
1489 .remove = provider_remove,
1490 .connect = provider_connect,
1491 .disconnect = provider_disconnect,
1492 .set_property = set_string,
1493 .get_property = get_string,
1494 .create = create_configuration,
1495 .set_routes = set_routes,
1496 .check_routes = check_routes,
1499 static void destroy_provider(struct connection_data *data)
1501 DBG("data %p", data);
1503 if (provider_is_connected(data))
1504 connman_provider_disconnect(data->provider);
1506 connman_provider_set_data(data->provider, NULL);
1507 connman_provider_remove(data->provider);
1508 data->provider = NULL;
1511 static void connection_destroy(gpointer hash_data)
1513 struct connection_data *data = hash_data;
1515 DBG("data %p", data);
1518 destroy_provider(data);
1521 dbus_pending_call_cancel(data->call);
1522 dbus_pending_call_unref(data->call);
1525 if (data->disconnect_call) {
1526 dbus_pending_call_cancel(data->disconnect_call);
1527 dbus_pending_call_unref(data->disconnect_call);
1530 g_free(data->service_ident);
1532 g_free(data->ident);
1533 g_free(data->state);
1537 g_strfreev(data->host_ip);
1538 g_free(data->domain);
1539 g_hash_table_destroy(data->server_routes);
1540 g_hash_table_destroy(data->user_routes);
1541 g_strfreev(data->nameservers);
1542 g_hash_table_destroy(data->setting_strings);
1543 connman_ipaddress_free(data->ip);
1545 cancel_host_resolv(data);
1550 static void vpnd_created(DBusConnection *conn, void *user_data)
1552 DBG("connection %p", conn);
1554 get_connections(user_data);
1557 static void vpnd_removed(DBusConnection *conn, void *user_data)
1559 DBG("connection %p", conn);
1561 g_hash_table_remove_all(vpn_connections);
1564 static void remove_connection(DBusConnection *conn, const char *path)
1566 DBG("path %s", path);
1568 g_hash_table_remove(vpn_connections, get_ident(path));
1571 static gboolean connection_removed(DBusConnection *conn, DBusMessage *message,
1575 const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
1576 struct connection_data *data;
1578 if (!dbus_message_has_signature(message, signature)) {
1579 connman_error("vpn removed signature \"%s\" does not match "
1581 dbus_message_get_signature(message), signature);
1585 dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1588 data = g_hash_table_lookup(vpn_connections, get_ident(path));
1590 remove_connection(conn, path);
1595 static gboolean connection_added(DBusConnection *conn, DBusMessage *message,
1598 DBusMessageIter iter, properties;
1600 const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING
1601 DBUS_TYPE_ARRAY_AS_STRING
1602 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1603 DBUS_TYPE_STRING_AS_STRING
1604 DBUS_TYPE_VARIANT_AS_STRING
1605 DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
1607 if (!dbus_message_has_signature(message, signature)) {
1608 connman_error("vpn ConnectionAdded signature \"%s\" does not "
1609 "match expected \"%s\"",
1610 dbus_message_get_signature(message), signature);
1616 if (!dbus_message_iter_init(message, &iter))
1619 dbus_message_iter_get_basic(&iter, &path);
1621 dbus_message_iter_next(&iter);
1622 dbus_message_iter_recurse(&iter, &properties);
1624 add_connection(path, &properties, user_data);
1629 static int save_route(GHashTable *routes, int family, const char *network,
1630 const char *netmask, const char *gateway)
1632 struct vpn_route *route;
1633 char *key = g_strdup_printf("%d/%s/%s", family, network, netmask);
1635 DBG("family %d network %s netmask %s", family, network, netmask);
1637 route = g_hash_table_lookup(routes, key);
1639 route = g_try_new0(struct vpn_route, 1);
1641 connman_error("out of memory");
1645 route->family = family;
1646 route->network = g_strdup(network);
1647 route->netmask = g_strdup(netmask);
1648 route->gateway = g_strdup(gateway);
1650 g_hash_table_replace(routes, key, route);
1657 static int read_route_dict(GHashTable *routes, DBusMessageIter *dicts)
1659 DBusMessageIter dict;
1660 const char *network, *netmask, *gateway;
1663 dbus_message_iter_recurse(dicts, &dict);
1665 network = netmask = gateway = NULL;
1668 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
1670 DBusMessageIter entry, value;
1673 dbus_message_iter_recurse(&dict, &entry);
1674 dbus_message_iter_get_basic(&entry, &key);
1676 dbus_message_iter_next(&entry);
1677 dbus_message_iter_recurse(&entry, &value);
1679 if (g_str_equal(key, "ProtocolFamily")) {
1681 dbus_message_iter_get_basic(&value, &pf);
1690 DBG("family %d", family);
1691 } else if (g_str_equal(key, "Netmask")) {
1692 dbus_message_iter_get_basic(&value, &netmask);
1693 DBG("netmask %s", netmask);
1694 } else if (g_str_equal(key, "Network")) {
1695 dbus_message_iter_get_basic(&value, &network);
1696 DBG("host %s", network);
1697 } else if (g_str_equal(key, "Gateway")) {
1698 dbus_message_iter_get_basic(&value, &gateway);
1699 DBG("gateway %s", gateway);
1702 dbus_message_iter_next(&dict);
1705 if (!netmask || !network || !gateway) {
1706 DBG("Value missing.");
1710 return save_route(routes, family, network, netmask, gateway);
1713 static int routes_changed(DBusMessageIter *array, GHashTable *routes)
1715 DBusMessageIter entry;
1718 if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY) {
1719 DBG("Expecting array, ignoring routes.");
1723 while (dbus_message_iter_get_arg_type(array) == DBUS_TYPE_ARRAY) {
1725 dbus_message_iter_recurse(array, &entry);
1727 while (dbus_message_iter_get_arg_type(&entry) ==
1729 DBusMessageIter dicts;
1731 dbus_message_iter_recurse(&entry, &dicts);
1733 while (dbus_message_iter_get_arg_type(&dicts) ==
1735 int err = read_route_dict(routes, &dicts);
1738 dbus_message_iter_next(&dicts);
1741 dbus_message_iter_next(&entry);
1744 dbus_message_iter_next(array);
1750 static gboolean property_changed(DBusConnection *conn,
1751 DBusMessage *message,
1754 const char *path = dbus_message_get_path(message);
1755 struct connection_data *data = NULL;
1756 DBusMessageIter iter, value;
1757 bool ip_set = false;
1761 const char *signature = DBUS_TYPE_STRING_AS_STRING
1762 DBUS_TYPE_VARIANT_AS_STRING;
1764 if (!dbus_message_has_signature(message, signature)) {
1765 connman_error("vpn property signature \"%s\" does not match "
1767 dbus_message_get_signature(message), signature);
1771 data = g_hash_table_lookup(vpn_connections, get_ident(path));
1775 if (!dbus_message_iter_init(message, &iter))
1778 dbus_message_iter_get_basic(&iter, &key);
1780 dbus_message_iter_next(&iter);
1781 dbus_message_iter_recurse(&iter, &value);
1785 if (g_str_equal(key, "State")) {
1786 dbus_message_iter_get_basic(&value, &str);
1788 DBG("%s %s -> %s", data->path, data->state, str);
1790 if (g_str_equal(data->state, str))
1793 g_free(data->state);
1794 data->state = g_strdup(str);
1796 set_provider_state(data);
1797 } else if (g_str_equal(key, "Index")) {
1798 dbus_message_iter_get_basic(&value, &data->index);
1799 connman_provider_set_index(data->provider, data->index);
1800 } else if (g_str_equal(key, "IPv4")) {
1801 err = extract_ip(&value, AF_INET, data);
1803 } else if (g_str_equal(key, "IPv6")) {
1804 err = extract_ip(&value, AF_INET6, data);
1806 } else if (g_str_equal(key, "ServerRoutes")) {
1807 err = routes_changed(&value, data->server_routes);
1809 * Note that the vpnd will delay the route sending a bit
1810 * (in order to collect the routes from VPN client),
1811 * so we might have got the State changed property before
1812 * we got ServerRoutes. This means that we must try to set
1813 * the routes here because they would be left unset otherwise.
1816 set_routes(data->provider,
1817 CONNMAN_PROVIDER_ROUTE_SERVER);
1818 } else if (g_str_equal(key, "UserRoutes")) {
1819 err = routes_changed(&value, data->user_routes);
1821 set_routes(data->provider,
1822 CONNMAN_PROVIDER_ROUTE_USER);
1823 } else if (g_str_equal(key, "Nameservers")) {
1824 if (extract_nameservers(&value, data) == 0 &&
1826 connman_provider_set_nameservers(data->provider,
1828 } else if (g_str_equal(key, "Domain")) {
1829 dbus_message_iter_get_basic(&value, &str);
1830 g_free(data->domain);
1831 data->domain = g_strdup(str);
1832 connman_provider_set_domain(data->provider, data->domain);
1835 if (ip_set && err == 0) {
1836 err = connman_provider_set_ipaddress(data->provider, data->ip);
1838 DBG("setting provider IP address failed (%s/%d)",
1839 strerror(-err), -err);
1845 static int vpn_find_online_transport_cb(struct connman_service *service,
1848 if (connman_service_get_type(service) != CONNMAN_SERVICE_TYPE_VPN) {
1849 switch (connman_service_get_state(service)) {
1850 case CONNMAN_SERVICE_STATE_ONLINE:
1851 *((struct connman_service**)user_data) = service;
1861 static struct connman_service *vpn_find_online_transport()
1863 struct connman_service *service = NULL;
1865 connman_service_iterate_services(vpn_find_online_transport_cb,
1870 static bool vpn_is_valid_transport(struct connman_service *transport)
1873 struct connman_service *online;
1875 switch (connman_service_get_state(transport)) {
1876 case CONNMAN_SERVICE_STATE_READY:
1877 online = vpn_find_online_transport();
1879 /* Stay connected if there are no online services */
1883 DBG("%s is ready, %s is online, disconnecting",
1884 connman_service_get_identifier(transport),
1885 connman_service_get_identifier(online));
1888 case CONNMAN_SERVICE_STATE_ONLINE:
1889 online = vpn_find_online_transport();
1891 /* Check if our transport is still the default */
1892 if (online == transport)
1895 DBG("%s is replaced by %s as default, disconnecting",
1896 connman_service_get_identifier(transport),
1897 connman_service_get_identifier(online));
1904 DBG("transport gone");
1910 static void vpn_disconnect_check_provider(struct connection_data *data)
1912 if (data->service_ident && provider_is_connected(data)) {
1913 struct connman_service *service =
1914 connman_service_lookup_from_identifier
1915 (data->service_ident);
1917 if (!vpn_is_valid_transport(service)) {
1918 disconnect_provider(data);
1923 static void vpn_disconnect_check()
1925 GHashTableIter iter;
1929 g_hash_table_iter_init(&iter, vpn_connections);
1930 while (g_hash_table_iter_next(&iter, NULL, &value))
1931 vpn_disconnect_check_provider(value);
1934 static void vpn_service_add(struct connman_service *service, const char *name)
1936 vpn_disconnect_check();
1939 static void vpn_service_list_changed(struct connman_service *service)
1941 vpn_disconnect_check();
1944 static void vpn_service_state_changed(struct connman_service *service,
1945 enum connman_service_state state)
1947 vpn_disconnect_check();
1950 static const struct connman_notifier vpn_notifier = {
1952 .priority = CONNMAN_NOTIFIER_PRIORITY_DEFAULT,
1953 .default_changed = vpn_service_list_changed,
1954 .service_add = vpn_service_add,
1955 .service_remove = vpn_service_list_changed,
1956 .service_state_changed = vpn_service_state_changed
1959 static int vpn_init(void)
1963 connection = connman_dbus_get_connection();
1967 watch = g_dbus_add_service_watch(connection, VPN_SERVICE,
1968 vpnd_created, vpnd_removed, &provider_driver, NULL);
1970 added_watch = g_dbus_add_signal_watch(connection, VPN_SERVICE, NULL,
1971 VPN_MANAGER_INTERFACE,
1972 CONNECTION_ADDED, connection_added,
1973 &provider_driver, NULL);
1975 removed_watch = g_dbus_add_signal_watch(connection, VPN_SERVICE, NULL,
1976 VPN_MANAGER_INTERFACE,
1977 CONNECTION_REMOVED, connection_removed,
1980 property_watch = g_dbus_add_signal_watch(connection, VPN_SERVICE, NULL,
1981 VPN_CONNECTION_INTERFACE,
1982 PROPERTY_CHANGED, property_changed,
1985 if (added_watch == 0 || removed_watch == 0 || property_watch == 0) {
1990 err = connman_provider_driver_register(&provider_driver);
1992 vpn_connections = g_hash_table_new_full(g_str_hash,
1994 g_free, connection_destroy);
1996 vpnd_created(connection, &provider_driver);
1999 connman_notifier_register(&vpn_notifier);
2003 g_dbus_remove_watch(connection, watch);
2004 g_dbus_remove_watch(connection, added_watch);
2005 g_dbus_remove_watch(connection, removed_watch);
2006 g_dbus_remove_watch(connection, property_watch);
2008 dbus_connection_unref(connection);
2013 static void vpn_exit(void)
2015 g_dbus_remove_watch(connection, watch);
2016 g_dbus_remove_watch(connection, added_watch);
2017 g_dbus_remove_watch(connection, removed_watch);
2018 g_dbus_remove_watch(connection, property_watch);
2020 connman_notifier_unregister(&vpn_notifier);
2021 connman_provider_driver_unregister(&provider_driver);
2023 if (vpn_connections)
2024 g_hash_table_destroy(vpn_connections);
2026 dbus_connection_unref(connection);
2029 CONNMAN_PLUGIN_DEFINE(vpn, "VPN plugin", VERSION,
2030 CONNMAN_PLUGIN_PRIORITY_DEFAULT, vpn_init, vpn_exit)