5 * Copyright (C) 2007-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
31 #include <gweb/gresolv.h>
35 static DBusConnection *connection = NULL;
37 static GHashTable *provider_hash = NULL;
39 static GSList *driver_list = NULL;
41 struct connman_provider {
44 struct connman_service *vpn_service;
48 struct connman_provider_driver *driver;
52 void __connman_provider_append_properties(struct connman_provider *provider,
53 DBusMessageIter *iter)
55 const char *host, *domain, *type;
56 dbus_bool_t split_routing;
58 if (!provider->driver || !provider->driver->get_property)
61 host = provider->driver->get_property(provider, "Host");
62 domain = provider->driver->get_property(provider, "Domain");
63 type = provider->driver->get_property(provider, "Type");
66 connman_dbus_dict_append_basic(iter, "Host",
67 DBUS_TYPE_STRING, &host);
70 connman_dbus_dict_append_basic(iter, "Domain",
71 DBUS_TYPE_STRING, &domain);
74 connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING,
77 if (provider->vpn_service) {
78 split_routing = connman_provider_is_split_routing(provider);
79 connman_dbus_dict_append_basic(iter, "SplitRouting",
80 DBUS_TYPE_BOOLEAN, &split_routing);
84 struct connman_provider *
85 connman_provider_ref_debug(struct connman_provider *provider,
86 const char *file, int line, const char *caller)
88 DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount + 1,
91 __sync_fetch_and_add(&provider->refcount, 1);
96 static void provider_remove(struct connman_provider *provider)
98 if (provider->driver) {
99 provider->driver->remove(provider);
100 provider->driver = NULL;
104 static void provider_destruct(struct connman_provider *provider)
106 DBG("provider %p", provider);
108 g_free(provider->identifier);
112 void connman_provider_unref_debug(struct connman_provider *provider,
113 const char *file, int line, const char *caller)
115 DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount - 1,
118 if (__sync_fetch_and_sub(&provider->refcount, 1) != 1)
121 provider_destruct(provider);
124 static int provider_indicate_state(struct connman_provider *provider,
125 enum connman_service_state state)
127 DBG("state %d", state);
129 __connman_service_ipconfig_indicate_state(provider->vpn_service, state,
130 CONNMAN_IPCONFIG_TYPE_IPV4);
132 return __connman_service_ipconfig_indicate_state(provider->vpn_service,
133 state, CONNMAN_IPCONFIG_TYPE_IPV6);
136 int connman_provider_disconnect(struct connman_provider *provider)
140 DBG("provider %p", provider);
142 if (provider->driver && provider->driver->disconnect)
143 err = provider->driver->disconnect(provider);
147 if (provider->vpn_service)
148 provider_indicate_state(provider,
149 CONNMAN_SERVICE_STATE_DISCONNECT);
154 if (provider->vpn_service)
155 provider_indicate_state(provider,
156 CONNMAN_SERVICE_STATE_IDLE);
161 int connman_provider_remove(struct connman_provider *provider)
163 DBG("Removing VPN %s", provider->identifier);
165 provider_remove(provider);
167 connman_provider_set_state(provider, CONNMAN_PROVIDER_STATE_IDLE);
169 g_hash_table_remove(provider_hash, provider->identifier);
174 int __connman_provider_connect(struct connman_provider *provider,
175 const char *dbus_sender)
179 DBG("provider %p", provider);
181 if (provider->driver && provider->driver->connect)
182 err = provider->driver->connect(provider, dbus_sender);
191 provider_indicate_state(provider,
192 CONNMAN_SERVICE_STATE_ASSOCIATION);
195 * Return EINPROGRESS also for when there is an existing pending call.
196 * The state should not be indicated again but the real state is
197 * still in progress for the provider.
206 int __connman_provider_remove_by_path(const char *path)
208 struct connman_provider *provider;
212 DBG("path %s", path);
214 g_hash_table_iter_init(&iter, provider_hash);
215 while (g_hash_table_iter_next(&iter, &key, &value)) {
216 const char *srv_path;
219 if (!provider->vpn_service)
222 srv_path = __connman_service_get_path(provider->vpn_service);
224 if (g_strcmp0(srv_path, path) == 0) {
225 DBG("Removing VPN %s", provider->identifier);
227 provider_remove(provider);
229 connman_provider_set_state(provider,
230 CONNMAN_PROVIDER_STATE_IDLE);
232 g_hash_table_remove(provider_hash,
233 provider->identifier);
241 static int set_connected(struct connman_provider *provider,
244 struct connman_service *service = provider->vpn_service;
245 struct connman_ipconfig *ipconfig;
250 ipconfig = __connman_service_get_ipconfig(service, provider->family);
254 provider_indicate_state(provider,
255 CONNMAN_SERVICE_STATE_FAILURE);
259 __connman_ipconfig_address_add(ipconfig);
260 #if defined TIZEN_EXT
261 __connman_ipconfig_gateway_add(ipconfig, service);
263 __connman_ipconfig_gateway_add(ipconfig);
266 provider_indicate_state(provider,
267 CONNMAN_SERVICE_STATE_READY);
269 if (provider->driver && provider->driver->set_routes)
270 provider->driver->set_routes(provider,
271 CONNMAN_PROVIDER_ROUTE_ALL);
275 provider_indicate_state(provider,
276 CONNMAN_SERVICE_STATE_DISCONNECT);
277 __connman_ipconfig_gateway_remove(ipconfig);
280 provider_indicate_state(provider,
281 CONNMAN_SERVICE_STATE_IDLE);
287 int connman_provider_set_state(struct connman_provider *provider,
288 enum connman_provider_state state)
290 if (!provider || !provider->vpn_service)
294 case CONNMAN_PROVIDER_STATE_UNKNOWN:
296 case CONNMAN_PROVIDER_STATE_IDLE:
297 return set_connected(provider, false);
298 case CONNMAN_PROVIDER_STATE_CONNECT:
299 return provider_indicate_state(provider,
300 CONNMAN_SERVICE_STATE_ASSOCIATION);
301 case CONNMAN_PROVIDER_STATE_READY:
302 return set_connected(provider, true);
303 case CONNMAN_PROVIDER_STATE_DISCONNECT:
304 return provider_indicate_state(provider,
305 CONNMAN_SERVICE_STATE_DISCONNECT);
306 case CONNMAN_PROVIDER_STATE_FAILURE:
307 return provider_indicate_state(provider,
308 CONNMAN_SERVICE_STATE_FAILURE);
314 int connman_provider_indicate_error(struct connman_provider *provider,
315 enum connman_provider_error error)
317 enum connman_service_error service_error;
320 case CONNMAN_PROVIDER_ERROR_LOGIN_FAILED:
321 service_error = CONNMAN_SERVICE_ERROR_LOGIN_FAILED;
323 case CONNMAN_PROVIDER_ERROR_AUTH_FAILED:
324 service_error = CONNMAN_SERVICE_ERROR_AUTH_FAILED;
326 case CONNMAN_PROVIDER_ERROR_CONNECT_FAILED:
327 service_error = CONNMAN_SERVICE_ERROR_CONNECT_FAILED;
330 service_error = CONNMAN_SERVICE_ERROR_UNKNOWN;
334 return __connman_service_indicate_error(provider->vpn_service,
338 int connman_provider_create_service(struct connman_provider *provider)
340 if (provider->vpn_service) {
343 connected = __connman_service_is_connected_state(
344 provider->vpn_service, CONNMAN_IPCONFIG_TYPE_IPV4);
348 connected = __connman_service_is_connected_state(
349 provider->vpn_service, CONNMAN_IPCONFIG_TYPE_IPV6);
356 provider->vpn_service =
357 __connman_service_create_from_provider(provider);
359 if (!provider->vpn_service) {
360 connman_warn("service creation failed for provider %s",
361 provider->identifier);
363 g_hash_table_remove(provider_hash, provider->identifier);
370 bool __connman_provider_is_immutable(struct connman_provider *provider)
374 return provider->immutable;
379 int connman_provider_set_immutable(struct connman_provider *provider,
385 provider->immutable = immutable;
390 static struct connman_provider *provider_lookup(const char *identifier)
392 return g_hash_table_lookup(provider_hash, identifier);
395 static void connection_ready(DBusMessage *msg, int error_code, void *user_data)
398 const char *identifier = user_data;
400 DBG("msg %p error %d", msg, error_code);
402 if (error_code != 0) {
403 reply = __connman_error_failed(msg, -error_code);
404 if (!g_dbus_send_message(connection, reply))
405 DBG("reply %p send failed", reply);
408 struct connman_provider *provider;
410 provider = provider_lookup(identifier);
412 reply = __connman_error_failed(msg, EINVAL);
413 g_dbus_send_message(connection, reply);
417 path = __connman_service_get_path(provider->vpn_service);
419 g_dbus_send_reply(connection, msg,
420 DBUS_TYPE_OBJECT_PATH, &path,
425 int __connman_provider_create_and_connect(DBusMessage *msg)
427 struct connman_provider_driver *driver;
432 driver = driver_list->data;
433 if (!driver || !driver->create)
438 return driver->create(msg, connection_ready);
441 const char *__connman_provider_get_ident(struct connman_provider *provider)
446 return provider->identifier;
449 const char * __connman_provider_get_transport_ident(
450 struct connman_provider *provider)
452 if (provider && provider && provider->driver && provider->driver->get_property)
453 return provider->driver->get_property(provider, "Transport");
458 int connman_provider_set_string(struct connman_provider *provider,
459 const char *key, const char *value)
461 if (provider->driver && provider->driver->set_property)
462 return provider->driver->set_property(provider, key, value);
467 const char *connman_provider_get_string(struct connman_provider *provider,
470 if (provider->driver && provider->driver->get_property)
471 return provider->driver->get_property(provider, key);
477 __connman_provider_check_routes(struct connman_provider *provider)
482 if (provider->driver && provider->driver->check_routes)
483 return provider->driver->check_routes(provider);
488 void *connman_provider_get_data(struct connman_provider *provider)
490 return provider->driver_data;
493 void connman_provider_set_data(struct connman_provider *provider, void *data)
495 provider->driver_data = data;
498 void connman_provider_set_index(struct connman_provider *provider, int index)
500 struct connman_service *service = provider->vpn_service;
501 struct connman_ipconfig *ipconfig;
508 ipconfig = __connman_service_get_ip4config(service);
511 connman_service_create_ip4config(service, index);
513 ipconfig = __connman_service_get_ip4config(service);
515 DBG("Couldn't create ipconfig");
520 __connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_OFF);
521 __connman_ipconfig_set_index(ipconfig, index);
523 ipconfig = __connman_service_get_ip6config(service);
526 connman_service_create_ip6config(service, index);
528 ipconfig = __connman_service_get_ip6config(service);
530 DBG("Couldn't create ipconfig for IPv6");
535 __connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_OFF);
536 __connman_ipconfig_set_index(ipconfig, index);
539 provider->index = index;
542 int connman_provider_get_index(struct connman_provider *provider)
544 return provider->index;
547 int connman_provider_set_ipaddress(struct connman_provider *provider,
548 struct connman_ipaddress *ipaddress)
550 struct connman_ipconfig *ipconfig = NULL;
552 ipconfig = __connman_service_get_ipconfig(provider->vpn_service,
557 provider->family = ipaddress->family;
559 __connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_FIXED);
561 __connman_ipconfig_set_local(ipconfig, ipaddress->local);
562 __connman_ipconfig_set_peer(ipconfig, ipaddress->peer);
563 __connman_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
564 __connman_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
565 __connman_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
570 int connman_provider_set_pac(struct connman_provider *provider, const char *pac)
572 DBG("provider %p pac %s", provider, pac);
574 __connman_service_set_pac(provider->vpn_service, pac);
580 int connman_provider_set_domain(struct connman_provider *provider,
583 DBG("provider %p domain %s", provider, domain);
585 __connman_service_set_domainname(provider->vpn_service, domain);
590 int connman_provider_set_nameservers(struct connman_provider *provider,
591 char * const *nameservers)
595 DBG("provider %p nameservers %p", provider, nameservers);
597 __connman_service_nameserver_clear(provider->vpn_service);
602 for (i = 0; nameservers[i]; i++)
603 #if defined TIZEN_EXT
604 __connman_service_nameserver_append(provider->vpn_service,
605 nameservers[i], false,
606 CONNMAN_IPCONFIG_TYPE_ALL);
608 __connman_service_nameserver_append(provider->vpn_service,
609 nameservers[i], false);
615 void connman_provider_set_autoconnect(struct connman_provider *provider,
618 if (!provider || !provider->vpn_service)
621 /* Save VPN service if autoconnect value changes */
622 if (connman_service_set_autoconnect(provider->vpn_service, flag))
623 __connman_service_save(provider->vpn_service);
626 bool connman_provider_is_split_routing(struct connman_provider *provider)
628 if (!provider || !provider->vpn_service)
631 return __connman_service_is_split_routing(provider->vpn_service);
634 int connman_provider_set_split_routing(struct connman_provider *provider,
637 struct connman_service *service;
638 enum connman_ipconfig_type type;
641 bool service_split_routing;
646 if (!provider || !provider->vpn_service)
649 service_split_routing = __connman_service_is_split_routing(
650 provider->vpn_service);
652 if (service_split_routing == split_routing) {
653 DBG("split_routing already set %s",
654 split_routing ? "true" : "false");
658 switch (provider->family) {
660 type = CONNMAN_IPCONFIG_TYPE_IPV4;
663 type = CONNMAN_IPCONFIG_TYPE_IPV6;
666 type = CONNMAN_IPCONFIG_TYPE_ALL;
669 type = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
672 if (!__connman_service_is_connected_state(provider->vpn_service,
674 DBG("%p VPN not connected", provider->vpn_service);
678 vpn_index = __connman_service_get_index(provider->vpn_service);
679 service_index = __connman_connection_get_vpn_phy_index(vpn_index);
680 service = __connman_service_lookup_from_index(service_index);
685 err = __connman_service_move(service, provider->vpn_service,
688 err = __connman_service_move(provider->vpn_service, service,
692 connman_warn("cannot move service %p and VPN %p error %d",
693 service, provider->vpn_service, err);
696 * In case of error notify vpnd about the current split routing
699 __connman_service_split_routing_changed(provider->vpn_service);
704 __connman_service_set_split_routing(provider->vpn_service,
706 __connman_service_save(provider->vpn_service);
712 int connman_provider_get_family(struct connman_provider *provider)
717 return provider->family;
720 static void unregister_provider(gpointer data)
722 struct connman_provider *provider = data;
724 DBG("provider %p service %p", provider, provider->vpn_service);
726 if (provider->vpn_service) {
727 connman_service_unref(provider->vpn_service);
728 provider->vpn_service = NULL;
731 connman_provider_unref(provider);
734 static gint compare_priority(gconstpointer a, gconstpointer b)
739 int connman_provider_driver_register(struct connman_provider_driver *driver)
741 DBG("driver %p name %s", driver, driver->name);
743 driver_list = g_slist_insert_sorted(driver_list, driver,
748 void connman_provider_driver_unregister(struct connman_provider_driver *driver)
750 DBG("driver %p name %s", driver, driver->name);
752 driver_list = g_slist_remove(driver_list, driver);
755 void connman_provider_set_driver(struct connman_provider *provider,
756 struct connman_provider_driver *driver)
758 provider->driver = driver;
761 static void provider_disconnect_all(gpointer key, gpointer value,
764 struct connman_provider *provider = value;
766 connman_provider_disconnect(provider);
769 static void provider_offline_mode(bool enabled)
771 DBG("enabled %d", enabled);
774 g_hash_table_foreach(provider_hash, provider_disconnect_all,
779 static void provider_initialize(struct connman_provider *provider)
781 DBG("provider %p", provider);
784 provider->identifier = NULL;
787 static struct connman_provider *provider_new(void)
789 struct connman_provider *provider;
791 provider = g_try_new0(struct connman_provider, 1);
795 provider->refcount = 1;
797 DBG("provider %p", provider);
798 provider_initialize(provider);
803 struct connman_provider *connman_provider_get(const char *identifier)
805 struct connman_provider *provider;
807 provider = g_hash_table_lookup(provider_hash, identifier);
811 provider = provider_new();
815 DBG("provider %p", provider);
817 provider->identifier = g_strdup(identifier);
819 g_hash_table_insert(provider_hash, provider->identifier, provider);
824 void connman_provider_put(struct connman_provider *provider)
826 g_hash_table_remove(provider_hash, provider->identifier);
829 static struct connman_provider *provider_get(int index)
834 g_hash_table_iter_init(&iter, provider_hash);
836 while (g_hash_table_iter_next(&iter, &key, &value)) {
837 struct connman_provider *provider = value;
839 if (provider->index == index)
846 static void provider_service_changed(struct connman_service *service,
847 enum connman_service_state state)
849 struct connman_provider *provider;
850 int vpn_index, service_index;
856 case CONNMAN_SERVICE_STATE_UNKNOWN:
857 case CONNMAN_SERVICE_STATE_IDLE:
858 case CONNMAN_SERVICE_STATE_ASSOCIATION:
859 case CONNMAN_SERVICE_STATE_CONFIGURATION:
860 case CONNMAN_SERVICE_STATE_READY:
861 case CONNMAN_SERVICE_STATE_ONLINE:
863 case CONNMAN_SERVICE_STATE_DISCONNECT:
864 case CONNMAN_SERVICE_STATE_FAILURE:
868 service_index = __connman_service_get_index(service);
870 vpn_index = __connman_connection_get_vpn_index(service_index);
872 DBG("service %p %s state %d index %d/%d", service,
873 connman_service_get_identifier(service),
874 state, service_index, vpn_index);
879 provider = provider_get(vpn_index);
883 DBG("disconnect %p index %d", provider, vpn_index);
885 connman_provider_disconnect(provider);
888 static const struct connman_notifier provider_notifier = {
890 .offline_mode = provider_offline_mode,
891 .service_state_changed = provider_service_changed,
894 int __connman_provider_init(void)
900 connection = connman_dbus_get_connection();
902 provider_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
903 NULL, unregister_provider);
905 err = connman_notifier_register(&provider_notifier);
907 g_hash_table_destroy(provider_hash);
908 dbus_connection_unref(connection);
914 void __connman_provider_cleanup(void)
918 connman_notifier_unregister(&provider_notifier);
920 g_hash_table_destroy(provider_hash);
921 provider_hash = NULL;
923 dbus_connection_unref(connection);