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;
57 if (!provider->driver || !provider->driver->get_property)
60 host = provider->driver->get_property(provider, "Host");
61 domain = provider->driver->get_property(provider, "Domain");
62 type = provider->driver->get_property(provider, "Type");
65 connman_dbus_dict_append_basic(iter, "Host",
66 DBUS_TYPE_STRING, &host);
69 connman_dbus_dict_append_basic(iter, "Domain",
70 DBUS_TYPE_STRING, &domain);
73 connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING,
77 struct connman_provider *
78 connman_provider_ref_debug(struct connman_provider *provider,
79 const char *file, int line, const char *caller)
81 DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount + 1,
84 __sync_fetch_and_add(&provider->refcount, 1);
89 static void provider_remove(struct connman_provider *provider)
91 if (provider->driver) {
92 provider->driver->remove(provider);
93 provider->driver = NULL;
97 static void provider_destruct(struct connman_provider *provider)
99 DBG("provider %p", provider);
101 g_free(provider->identifier);
105 void connman_provider_unref_debug(struct connman_provider *provider,
106 const char *file, int line, const char *caller)
108 DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount - 1,
111 if (__sync_fetch_and_sub(&provider->refcount, 1) != 1)
114 provider_destruct(provider);
117 static int provider_indicate_state(struct connman_provider *provider,
118 enum connman_service_state state)
120 DBG("state %d", state);
122 __connman_service_ipconfig_indicate_state(provider->vpn_service, state,
123 CONNMAN_IPCONFIG_TYPE_IPV4);
125 return __connman_service_ipconfig_indicate_state(provider->vpn_service,
126 state, CONNMAN_IPCONFIG_TYPE_IPV6);
129 int connman_provider_disconnect(struct connman_provider *provider)
133 DBG("provider %p", provider);
135 if (provider->driver && provider->driver->disconnect)
136 err = provider->driver->disconnect(provider);
140 if (provider->vpn_service)
141 provider_indicate_state(provider,
142 CONNMAN_SERVICE_STATE_DISCONNECT);
147 if (provider->vpn_service)
148 provider_indicate_state(provider,
149 CONNMAN_SERVICE_STATE_IDLE);
154 int connman_provider_remove(struct connman_provider *provider)
156 DBG("Removing VPN %s", provider->identifier);
158 provider_remove(provider);
160 connman_provider_set_state(provider, CONNMAN_PROVIDER_STATE_IDLE);
162 g_hash_table_remove(provider_hash, provider->identifier);
167 int __connman_provider_connect(struct connman_provider *provider,
168 const char *dbus_sender)
172 DBG("provider %p", provider);
174 if (provider->driver && provider->driver->connect)
175 err = provider->driver->connect(provider, dbus_sender);
184 provider_indicate_state(provider,
185 CONNMAN_SERVICE_STATE_ASSOCIATION);
188 * Return EINPROGRESS also for when there is an existing pending call.
189 * The state should not be indicated again but the real state is
190 * still in progress for the provider.
199 int __connman_provider_remove_by_path(const char *path)
201 struct connman_provider *provider;
205 DBG("path %s", path);
207 g_hash_table_iter_init(&iter, provider_hash);
208 while (g_hash_table_iter_next(&iter, &key, &value)) {
209 const char *srv_path;
212 if (!provider->vpn_service)
215 srv_path = __connman_service_get_path(provider->vpn_service);
217 if (g_strcmp0(srv_path, path) == 0) {
218 DBG("Removing VPN %s", provider->identifier);
220 provider_remove(provider);
222 connman_provider_set_state(provider,
223 CONNMAN_PROVIDER_STATE_IDLE);
225 g_hash_table_remove(provider_hash,
226 provider->identifier);
234 static int set_connected(struct connman_provider *provider,
237 struct connman_service *service = provider->vpn_service;
238 struct connman_ipconfig *ipconfig;
243 ipconfig = __connman_service_get_ipconfig(service, provider->family);
247 provider_indicate_state(provider,
248 CONNMAN_SERVICE_STATE_FAILURE);
252 __connman_ipconfig_address_add(ipconfig);
253 #if defined TIZEN_EXT
254 __connman_ipconfig_gateway_add(ipconfig, service);
256 __connman_ipconfig_gateway_add(ipconfig);
259 provider_indicate_state(provider,
260 CONNMAN_SERVICE_STATE_READY);
262 if (provider->driver && provider->driver->set_routes)
263 provider->driver->set_routes(provider,
264 CONNMAN_PROVIDER_ROUTE_ALL);
268 provider_indicate_state(provider,
269 CONNMAN_SERVICE_STATE_DISCONNECT);
270 __connman_ipconfig_gateway_remove(ipconfig);
273 provider_indicate_state(provider,
274 CONNMAN_SERVICE_STATE_IDLE);
280 int connman_provider_set_state(struct connman_provider *provider,
281 enum connman_provider_state state)
283 if (!provider || !provider->vpn_service)
287 case CONNMAN_PROVIDER_STATE_UNKNOWN:
289 case CONNMAN_PROVIDER_STATE_IDLE:
290 return set_connected(provider, false);
291 case CONNMAN_PROVIDER_STATE_CONNECT:
292 return provider_indicate_state(provider,
293 CONNMAN_SERVICE_STATE_ASSOCIATION);
294 case CONNMAN_PROVIDER_STATE_READY:
295 return set_connected(provider, true);
296 case CONNMAN_PROVIDER_STATE_DISCONNECT:
297 return provider_indicate_state(provider,
298 CONNMAN_SERVICE_STATE_DISCONNECT);
299 case CONNMAN_PROVIDER_STATE_FAILURE:
300 return provider_indicate_state(provider,
301 CONNMAN_SERVICE_STATE_FAILURE);
307 int connman_provider_indicate_error(struct connman_provider *provider,
308 enum connman_provider_error error)
310 enum connman_service_error service_error;
313 case CONNMAN_PROVIDER_ERROR_LOGIN_FAILED:
314 service_error = CONNMAN_SERVICE_ERROR_LOGIN_FAILED;
316 case CONNMAN_PROVIDER_ERROR_AUTH_FAILED:
317 service_error = CONNMAN_SERVICE_ERROR_AUTH_FAILED;
319 case CONNMAN_PROVIDER_ERROR_CONNECT_FAILED:
320 service_error = CONNMAN_SERVICE_ERROR_CONNECT_FAILED;
323 service_error = CONNMAN_SERVICE_ERROR_UNKNOWN;
327 return __connman_service_indicate_error(provider->vpn_service,
331 int connman_provider_create_service(struct connman_provider *provider)
333 if (provider->vpn_service) {
336 connected = __connman_service_is_connected_state(
337 provider->vpn_service, CONNMAN_IPCONFIG_TYPE_IPV4);
341 connected = __connman_service_is_connected_state(
342 provider->vpn_service, CONNMAN_IPCONFIG_TYPE_IPV6);
349 provider->vpn_service =
350 __connman_service_create_from_provider(provider);
352 if (!provider->vpn_service) {
353 connman_warn("service creation failed for provider %s",
354 provider->identifier);
356 g_hash_table_remove(provider_hash, provider->identifier);
363 bool __connman_provider_is_immutable(struct connman_provider *provider)
367 return provider->immutable;
372 int connman_provider_set_immutable(struct connman_provider *provider,
378 provider->immutable = immutable;
383 static struct connman_provider *provider_lookup(const char *identifier)
385 return g_hash_table_lookup(provider_hash, identifier);
388 static void connection_ready(DBusMessage *msg, int error_code, void *user_data)
391 const char *identifier = user_data;
393 DBG("msg %p error %d", msg, error_code);
395 if (error_code != 0) {
396 reply = __connman_error_failed(msg, -error_code);
397 if (!g_dbus_send_message(connection, reply))
398 DBG("reply %p send failed", reply);
401 struct connman_provider *provider;
403 provider = provider_lookup(identifier);
405 reply = __connman_error_failed(msg, EINVAL);
406 g_dbus_send_message(connection, reply);
410 path = __connman_service_get_path(provider->vpn_service);
412 g_dbus_send_reply(connection, msg,
413 DBUS_TYPE_OBJECT_PATH, &path,
418 int __connman_provider_create_and_connect(DBusMessage *msg)
420 struct connman_provider_driver *driver;
425 driver = driver_list->data;
426 if (!driver || !driver->create)
431 return driver->create(msg, connection_ready);
434 const char *__connman_provider_get_ident(struct connman_provider *provider)
439 return provider->identifier;
442 int connman_provider_set_string(struct connman_provider *provider,
443 const char *key, const char *value)
445 if (provider->driver && provider->driver->set_property)
446 return provider->driver->set_property(provider, key, value);
451 const char *connman_provider_get_string(struct connman_provider *provider,
454 if (provider->driver && provider->driver->get_property)
455 return provider->driver->get_property(provider, key);
461 __connman_provider_check_routes(struct connman_provider *provider)
466 if (provider->driver && provider->driver->check_routes)
467 return provider->driver->check_routes(provider);
472 void *connman_provider_get_data(struct connman_provider *provider)
474 return provider->driver_data;
477 void connman_provider_set_data(struct connman_provider *provider, void *data)
479 provider->driver_data = data;
482 void connman_provider_set_index(struct connman_provider *provider, int index)
484 struct connman_service *service = provider->vpn_service;
485 struct connman_ipconfig *ipconfig;
492 ipconfig = __connman_service_get_ip4config(service);
495 connman_service_create_ip4config(service, index);
497 ipconfig = __connman_service_get_ip4config(service);
499 DBG("Couldn't create ipconfig");
504 __connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_OFF);
505 __connman_ipconfig_set_index(ipconfig, index);
507 ipconfig = __connman_service_get_ip6config(service);
510 connman_service_create_ip6config(service, index);
512 ipconfig = __connman_service_get_ip6config(service);
514 DBG("Couldn't create ipconfig for IPv6");
519 __connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_OFF);
520 __connman_ipconfig_set_index(ipconfig, index);
523 provider->index = index;
526 int connman_provider_get_index(struct connman_provider *provider)
528 return provider->index;
531 int connman_provider_set_ipaddress(struct connman_provider *provider,
532 struct connman_ipaddress *ipaddress)
534 struct connman_ipconfig *ipconfig = NULL;
536 ipconfig = __connman_service_get_ipconfig(provider->vpn_service,
541 provider->family = ipaddress->family;
543 __connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_FIXED);
545 __connman_ipconfig_set_local(ipconfig, ipaddress->local);
546 __connman_ipconfig_set_peer(ipconfig, ipaddress->peer);
547 __connman_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
548 __connman_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
549 __connman_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
554 int connman_provider_set_pac(struct connman_provider *provider, const char *pac)
556 DBG("provider %p pac %s", provider, pac);
558 __connman_service_set_pac(provider->vpn_service, pac);
564 int connman_provider_set_domain(struct connman_provider *provider,
567 DBG("provider %p domain %s", provider, domain);
569 __connman_service_set_domainname(provider->vpn_service, domain);
574 int connman_provider_set_nameservers(struct connman_provider *provider,
575 char * const *nameservers)
579 DBG("provider %p nameservers %p", provider, nameservers);
581 __connman_service_nameserver_clear(provider->vpn_service);
586 for (i = 0; nameservers[i]; i++)
587 #if defined TIZEN_EXT
588 __connman_service_nameserver_append(provider->vpn_service,
589 nameservers[i], false,
590 CONNMAN_IPCONFIG_TYPE_ALL);
592 __connman_service_nameserver_append(provider->vpn_service,
593 nameservers[i], false);
599 void connman_provider_set_autoconnect(struct connman_provider *provider,
602 if (!provider || !provider->vpn_service)
605 /* Save VPN service if autoconnect value changes */
606 if (connman_service_set_autoconnect(provider->vpn_service, flag))
607 __connman_service_save(provider->vpn_service);
610 static void unregister_provider(gpointer data)
612 struct connman_provider *provider = data;
614 DBG("provider %p service %p", provider, provider->vpn_service);
616 if (provider->vpn_service) {
617 connman_service_unref(provider->vpn_service);
618 provider->vpn_service = NULL;
621 connman_provider_unref(provider);
624 static gint compare_priority(gconstpointer a, gconstpointer b)
629 int connman_provider_driver_register(struct connman_provider_driver *driver)
631 DBG("driver %p name %s", driver, driver->name);
633 driver_list = g_slist_insert_sorted(driver_list, driver,
638 void connman_provider_driver_unregister(struct connman_provider_driver *driver)
640 DBG("driver %p name %s", driver, driver->name);
642 driver_list = g_slist_remove(driver_list, driver);
645 void connman_provider_set_driver(struct connman_provider *provider,
646 struct connman_provider_driver *driver)
648 provider->driver = driver;
651 static void provider_disconnect_all(gpointer key, gpointer value,
654 struct connman_provider *provider = value;
656 connman_provider_disconnect(provider);
659 static void provider_offline_mode(bool enabled)
661 DBG("enabled %d", enabled);
664 g_hash_table_foreach(provider_hash, provider_disconnect_all,
669 static void provider_initialize(struct connman_provider *provider)
671 DBG("provider %p", provider);
674 provider->identifier = NULL;
677 static struct connman_provider *provider_new(void)
679 struct connman_provider *provider;
681 provider = g_try_new0(struct connman_provider, 1);
685 provider->refcount = 1;
687 DBG("provider %p", provider);
688 provider_initialize(provider);
693 struct connman_provider *connman_provider_get(const char *identifier)
695 struct connman_provider *provider;
697 provider = g_hash_table_lookup(provider_hash, identifier);
701 provider = provider_new();
705 DBG("provider %p", provider);
707 provider->identifier = g_strdup(identifier);
709 g_hash_table_insert(provider_hash, provider->identifier, provider);
714 void connman_provider_put(struct connman_provider *provider)
716 g_hash_table_remove(provider_hash, provider->identifier);
719 static struct connman_provider *provider_get(int index)
724 g_hash_table_iter_init(&iter, provider_hash);
726 while (g_hash_table_iter_next(&iter, &key, &value)) {
727 struct connman_provider *provider = value;
729 if (provider->index == index)
736 static void provider_service_changed(struct connman_service *service,
737 enum connman_service_state state)
739 struct connman_provider *provider;
740 int vpn_index, service_index;
746 case CONNMAN_SERVICE_STATE_UNKNOWN:
747 case CONNMAN_SERVICE_STATE_IDLE:
748 case CONNMAN_SERVICE_STATE_ASSOCIATION:
749 case CONNMAN_SERVICE_STATE_CONFIGURATION:
750 case CONNMAN_SERVICE_STATE_READY:
751 case CONNMAN_SERVICE_STATE_ONLINE:
753 case CONNMAN_SERVICE_STATE_DISCONNECT:
754 case CONNMAN_SERVICE_STATE_FAILURE:
758 service_index = __connman_service_get_index(service);
760 vpn_index = __connman_connection_get_vpn_index(service_index);
762 DBG("service %p %s state %d index %d/%d", service,
763 connman_service_get_identifier(service),
764 state, service_index, vpn_index);
769 provider = provider_get(vpn_index);
773 DBG("disconnect %p index %d", provider, vpn_index);
775 connman_provider_disconnect(provider);
778 static const struct connman_notifier provider_notifier = {
780 .offline_mode = provider_offline_mode,
781 .service_state_changed = provider_service_changed,
784 int __connman_provider_init(void)
790 connection = connman_dbus_get_connection();
792 provider_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
793 NULL, unregister_provider);
795 err = connman_notifier_register(&provider_notifier);
797 g_hash_table_destroy(provider_hash);
798 dbus_connection_unref(connection);
804 void __connman_provider_cleanup(void)
808 connman_notifier_unregister(&provider_notifier);
810 g_hash_table_destroy(provider_hash);
811 provider_hash = NULL;
813 dbus_connection_unref(connection);