X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmanager.c;h=514cd1eb9e0084eb6050d1fac174e51299224f91;hb=cd9553812a30cdbb7d30731d84cc90a8d4463156;hp=f943720e0fab2b14fd503f5a6c5a6665c0688c35;hpb=77b134b5f3f2856cd6a915904b9ff3b207654c71;p=platform%2Fupstream%2Fconnman.git diff --git a/src/manager.c b/src/manager.c index f943720..514cd1e 100644 --- a/src/manager.c +++ b/src/manager.c @@ -2,7 +2,7 @@ * * Connection Manager * - * Copyright (C) 2007-2009 Intel Corporation. All rights reserved. + * Copyright (C) 2007-2010 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as @@ -27,222 +27,512 @@ #include "connman.h" -enum connman_policy { - CONNMAN_POLICY_UNKNOWN = 0, - CONNMAN_POLICY_SINGLE = 1, - CONNMAN_POLICY_MULTIPLE = 2, - CONNMAN_POLICY_ASK = 3, -}; +static DBusMessage *get_properties(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + DBusMessage *reply; + DBusMessageIter array, dict; + connman_bool_t offlinemode, tethering; + const char *str; + + DBG("conn %p", conn); + + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0) + return __connman_error_permission_denied(msg); + + reply = dbus_message_new_method_return(msg); + if (reply == NULL) + return NULL; + + dbus_message_iter_init_append(reply, &array); + + connman_dbus_dict_open(&array, &dict); + + str = __connman_profile_active_path(); + if (str != NULL) + connman_dbus_dict_append_basic(&dict, "ActiveProfile", + DBUS_TYPE_OBJECT_PATH, &str); + + connman_dbus_dict_append_array(&dict, "Profiles", + DBUS_TYPE_OBJECT_PATH, __connman_profile_list, NULL); + connman_dbus_dict_append_array(&dict, "Services", + DBUS_TYPE_OBJECT_PATH, __connman_service_list, NULL); + connman_dbus_dict_append_array(&dict, "Providers", + DBUS_TYPE_OBJECT_PATH, __connman_provider_list, NULL); + connman_dbus_dict_append_array(&dict, "Technologies", + DBUS_TYPE_OBJECT_PATH, __connman_technology_list, NULL); + + str = __connman_notifier_get_state(); + connman_dbus_dict_append_basic(&dict, "State", + DBUS_TYPE_STRING, &str); + + offlinemode = __connman_profile_get_offlinemode(); + connman_dbus_dict_append_basic(&dict, "OfflineMode", + DBUS_TYPE_BOOLEAN, &offlinemode); + + tethering = __connman_tethering_get_status(); + connman_dbus_dict_append_basic(&dict, "Tethering", + DBUS_TYPE_BOOLEAN, &tethering); + + connman_dbus_dict_append_array(&dict, "AvailableTechnologies", + DBUS_TYPE_STRING, __connman_notifier_list_registered, NULL); + connman_dbus_dict_append_array(&dict, "EnabledTechnologies", + DBUS_TYPE_STRING, __connman_notifier_list_enabled, NULL); + connman_dbus_dict_append_array(&dict, "ConnectedTechnologies", + DBUS_TYPE_STRING, __connman_notifier_list_connected, NULL); + + str = __connman_service_default(); + if (str != NULL) + connman_dbus_dict_append_basic(&dict, "DefaultTechnology", + DBUS_TYPE_STRING, &str); + + connman_dbus_dict_append_array(&dict, "AvailableDebugs", + DBUS_TYPE_STRING, __connman_debug_list_available, NULL); + connman_dbus_dict_append_array(&dict, "EnabledDebugs", + DBUS_TYPE_STRING, __connman_debug_list_enabled, NULL); -static enum connman_policy global_policy = CONNMAN_POLICY_SINGLE; -static connman_bool_t global_flightmode = FALSE; + connman_dbus_dict_close(&array, &dict); -static const char *policy2string(enum connman_policy policy) + return reply; +} + +static DBusMessage *set_property(DBusConnection *conn, + DBusMessage *msg, void *data) { - switch (policy) { - case CONNMAN_POLICY_UNKNOWN: - break; - case CONNMAN_POLICY_SINGLE: - return "single"; - case CONNMAN_POLICY_MULTIPLE: - return "multiple"; - case CONNMAN_POLICY_ASK: - return "ask"; - } + DBusMessageIter iter, value; + const char *name; + int type; - return NULL; + DBG("conn %p", conn); + + if (dbus_message_iter_init(msg, &iter) == FALSE) + return __connman_error_invalid_arguments(msg); + + dbus_message_iter_get_basic(&iter, &name); + dbus_message_iter_next(&iter); + dbus_message_iter_recurse(&iter, &value); + + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0) + return __connman_error_permission_denied(msg); + + type = dbus_message_iter_get_arg_type(&value); + + if (g_str_equal(name, "OfflineMode") == TRUE) { + connman_bool_t offlinemode; + + if (type != DBUS_TYPE_BOOLEAN) + return __connman_error_invalid_arguments(msg); + + dbus_message_iter_get_basic(&value, &offlinemode); + + __connman_profile_set_offlinemode(offlinemode); + + __connman_profile_save_default(); + } else if (g_str_equal(name, "Tethering") == TRUE) { + connman_bool_t tethering; + + if (type != DBUS_TYPE_BOOLEAN) + return __connman_error_invalid_arguments(msg); + + dbus_message_iter_get_basic(&value, &tethering); + + if (__connman_tethering_set_status(tethering) < 0) + return __connman_error_invalid_arguments(msg); + + connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH, + CONNMAN_MANAGER_INTERFACE, "Tethering", + DBUS_TYPE_BOOLEAN, &tethering); + } else if (g_str_equal(name, "ActiveProfile") == TRUE) { + const char *str; + + dbus_message_iter_get_basic(&value, &str); + + return __connman_error_not_supported(msg); + } else + return __connman_error_invalid_property(msg); + + return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } -static enum connman_policy string2policy(const char *policy) +static DBusMessage *get_state(DBusConnection *conn, + DBusMessage *msg, void *data) { - if (g_str_equal(policy, "single") == TRUE) - return CONNMAN_POLICY_SINGLE; - else if (g_str_equal(policy, "multiple") == TRUE) - return CONNMAN_POLICY_MULTIPLE; - else if (g_str_equal(policy, "ask") == TRUE) - return CONNMAN_POLICY_ASK; - else - return CONNMAN_POLICY_UNKNOWN; + const char *str; + + DBG("conn %p", conn); + + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0) + return __connman_error_permission_denied(msg); + + str = __connman_notifier_get_state(); + + return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &str, + DBUS_TYPE_INVALID); } -static void append_profiles(DBusMessageIter *dict) +static DBusMessage *create_profile(DBusConnection *conn, + DBusMessage *msg, void *data) { - DBusMessageIter entry, value, iter; - const char *key = "Profiles"; + const char *name, *path; + int err; + + DBG("conn %p", conn); + + dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID); + + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0) + return __connman_error_permission_denied(msg); - dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, - NULL, &entry); + err = __connman_profile_create(name, &path); + if (err < 0) + return __connman_error_failed(msg, -err); - dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); + return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_INVALID); +} - dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, - DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING, - &value); +static DBusMessage *remove_profile(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *path; + int err; - dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY, - DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter); + DBG("conn %p", conn); - __connman_profile_list(&iter); + dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_INVALID); - dbus_message_iter_close_container(&value, &iter); + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0) + return __connman_error_permission_denied(msg); - dbus_message_iter_close_container(&entry, &value); + err = __connman_profile_remove(path); + if (err < 0) + return __connman_error_failed(msg, -err); - dbus_message_iter_close_container(dict, &entry); + return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } -static void append_devices(DBusMessageIter *dict) +static DBusMessage *remove_provider(DBusConnection *conn, + DBusMessage *msg, void *data) { - DBusMessageIter entry, value, iter; - const char *key = "Devices"; + const char *path; + int err; + + DBG("conn %p", conn); + + dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); + + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0) + return __connman_error_permission_denied(msg); + + err = __connman_provider_remove(path); + if (err < 0) + return __connman_error_failed(msg, -err); - dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, - NULL, &entry); + return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); +} - dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); +static DBusMessage *request_scan(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + enum connman_service_type type; + const char *str; + int err; - dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, - DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING, - &value); + DBG("conn %p", conn); - dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY, - DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter); + dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str, + DBUS_TYPE_INVALID); - __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, &iter); + if (g_strcmp0(str, "") == 0) + type = CONNMAN_SERVICE_TYPE_UNKNOWN; + else if (g_strcmp0(str, "wifi") == 0) + type = CONNMAN_SERVICE_TYPE_WIFI; + else if (g_strcmp0(str, "wimax") == 0) + type = CONNMAN_SERVICE_TYPE_WIMAX; + else + return __connman_error_invalid_arguments(msg); - dbus_message_iter_close_container(&value, &iter); + err = __connman_element_request_scan(type); + if (err < 0) { + if (err == -EINPROGRESS) { + connman_error("Invalid return code from scan"); + err = -EINVAL; + } - dbus_message_iter_close_container(&entry, &value); + return __connman_error_failed(msg, -err); + } - dbus_message_iter_close_container(dict, &entry); + return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } -static void append_connections(DBusMessageIter *dict) +static DBusConnection *connection = NULL; + +static enum connman_service_type technology_type; +static connman_bool_t technology_enabled; +static DBusMessage *technology_pending = NULL; +static guint technology_timeout = 0; + +static void technology_reply(int error) { - DBusMessageIter entry, value, iter; - const char *key = "Connections"; + DBG(""); + + if (technology_timeout > 0) { + g_source_remove(technology_timeout); + technology_timeout = 0; + } + + if (technology_pending != NULL) { + if (error > 0) { + DBusMessage *reply; + + reply = __connman_error_failed(technology_pending, + error); + if (reply != NULL) + g_dbus_send_message(connection, reply); + } else + g_dbus_send_reply(connection, technology_pending, + DBUS_TYPE_INVALID); - dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, - NULL, &entry); + dbus_message_unref(technology_pending); + technology_pending = NULL; + } - dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); + technology_type = CONNMAN_SERVICE_TYPE_UNKNOWN; +} - dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, - DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING, - &value); +static gboolean technology_abort(gpointer user_data) +{ + DBG(""); - dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY, - DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter); + technology_timeout = 0; - __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_CONNECTION, &iter); + technology_reply(ETIMEDOUT); - dbus_message_iter_close_container(&value, &iter); + return FALSE; +} - dbus_message_iter_close_container(&entry, &value); +static void technology_notify(enum connman_service_type type, + connman_bool_t enabled) +{ + DBG("type %d enabled %d", type, enabled); - dbus_message_iter_close_container(dict, &entry); + if (type == technology_type && enabled == technology_enabled) + technology_reply(0); } -static DBusMessage *get_properties(DBusConnection *conn, +static struct connman_notifier technology_notifier = { + .name = "manager", + .priority = CONNMAN_NOTIFIER_PRIORITY_HIGH, + .service_enabled= technology_notify, +}; + +static DBusMessage *enable_technology(DBusConnection *conn, DBusMessage *msg, void *data) { - DBusMessage *reply; - DBusMessageIter array, dict; + enum connman_service_type type; const char *str; + int err; DBG("conn %p", conn); - if (__connman_security_check_privilege(msg, - CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0) - return __connman_error_permission_denied(msg); + if (technology_pending != NULL) + return __connman_error_in_progress(msg); - reply = dbus_message_new_method_return(msg); - if (reply == NULL) - return NULL; + dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str, + DBUS_TYPE_INVALID); - dbus_message_iter_init_append(reply, &array); + if (g_strcmp0(str, "ethernet") == 0) + type = CONNMAN_SERVICE_TYPE_ETHERNET; + else if (g_strcmp0(str, "wifi") == 0) + type = CONNMAN_SERVICE_TYPE_WIFI; + else if (g_strcmp0(str, "wimax") == 0) + type = CONNMAN_SERVICE_TYPE_WIMAX; + else if (g_strcmp0(str, "bluetooth") == 0) + type = CONNMAN_SERVICE_TYPE_BLUETOOTH; + else if (g_strcmp0(str, "cellular") == 0) + type = CONNMAN_SERVICE_TYPE_CELLULAR; + else + return __connman_error_invalid_arguments(msg); - dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY, - DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING - DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING - DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); + if (__connman_notifier_is_registered(type) == FALSE) + return __connman_error_not_registered(msg); - append_profiles(&dict); + if (__connman_notifier_is_enabled(type) == TRUE) + return __connman_error_already_enabled(msg); - append_devices(&dict); - append_connections(&dict); + technology_type = type; + technology_enabled = TRUE; + technology_pending = dbus_message_ref(msg); - if (__connman_element_count(NULL, CONNMAN_ELEMENT_TYPE_CONNECTION) > 0) - str = "online"; + err = __connman_element_enable_technology(type); + if (err < 0 && err != -EINPROGRESS) + technology_reply(-err); else - str = "offline"; + technology_timeout = g_timeout_add_seconds(15, + technology_abort, NULL); - connman_dbus_dict_append_variant(&dict, "State", - DBUS_TYPE_STRING, &str); + return NULL; +} - str = policy2string(global_policy); - if (str != NULL) - connman_dbus_dict_append_variant(&dict, "Policy", - DBUS_TYPE_STRING, &str); +static DBusMessage *disable_technology(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + enum connman_service_type type; + const char *str; + int err; + + DBG("conn %p", conn); + + if (technology_pending != NULL) + return __connman_error_in_progress(msg); + + dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str, + DBUS_TYPE_INVALID); + + if (g_strcmp0(str, "ethernet") == 0) + type = CONNMAN_SERVICE_TYPE_ETHERNET; + else if (g_strcmp0(str, "wifi") == 0) + type = CONNMAN_SERVICE_TYPE_WIFI; + else if (g_strcmp0(str, "wimax") == 0) + type = CONNMAN_SERVICE_TYPE_WIMAX; + else if (g_strcmp0(str, "bluetooth") == 0) + type = CONNMAN_SERVICE_TYPE_BLUETOOTH; + else if (g_strcmp0(str, "cellular") == 0) + type = CONNMAN_SERVICE_TYPE_CELLULAR; + else + return __connman_error_invalid_arguments(msg); + + if (__connman_notifier_is_registered(type) == FALSE) + return __connman_error_not_registered(msg); + + if (__connman_notifier_is_enabled(type) == FALSE) + return __connman_error_already_disabled(msg); + + technology_type = type; + technology_enabled = FALSE; + technology_pending = dbus_message_ref(msg); + + err = __connman_element_disable_technology(type); + if (err < 0 && err != -EINPROGRESS) + technology_reply(-err); + else + technology_timeout = g_timeout_add_seconds(10, + technology_abort, NULL); + + return NULL; +} + +static DBusMessage *get_services(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + DBusMessage *reply; + DBusMessageIter iter, array; + + reply = dbus_message_new_method_return(msg); + if (reply == NULL) + return NULL; + + dbus_message_iter_init_append(reply, &iter); - connman_dbus_dict_append_variant(&dict, "FlightMode", - DBUS_TYPE_BOOLEAN, &global_flightmode); + dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + DBUS_STRUCT_BEGIN_CHAR_AS_STRING + DBUS_TYPE_OBJECT_PATH_AS_STRING + DBUS_TYPE_ARRAY_AS_STRING + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + DBUS_TYPE_STRING_AS_STRING + DBUS_TYPE_VARIANT_AS_STRING + DBUS_DICT_ENTRY_END_CHAR_AS_STRING + DBUS_STRUCT_END_CHAR_AS_STRING, &array); - dbus_message_iter_close_container(&array, &dict); + __connman_service_list_struct(&array); + + dbus_message_iter_close_container(&iter, &array); return reply; } -static DBusMessage *set_property(DBusConnection *conn, +static DBusMessage *lookup_service(DBusConnection *conn, DBusMessage *msg, void *data) { - DBusMessageIter iter, value; - const char *name; + const char *pattern, *path; + int err; DBG("conn %p", conn); - if (dbus_message_iter_init(msg, &iter) == FALSE) - return __connman_error_invalid_arguments(msg); + dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern, + DBUS_TYPE_INVALID); - dbus_message_iter_get_basic(&iter, &name); - dbus_message_iter_next(&iter); - dbus_message_iter_recurse(&iter, &value); + err = __connman_service_lookup(pattern, &path); + if (err < 0) + return __connman_error_failed(msg, -err); + + return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_INVALID); +} + +static DBusMessage *connect_service(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + int err; + + DBG("conn %p", conn); if (__connman_security_check_privilege(msg, CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0) return __connman_error_permission_denied(msg); - if (g_str_equal(name, "Policy") == TRUE) { - enum connman_policy policy; - const char *str; + err = __connman_service_create_and_connect(msg); + if (err < 0) { + if (err == -EINPROGRESS) { + connman_error("Invalid return code from connect"); + err = -EINVAL; + } - dbus_message_iter_get_basic(&value, &str); - policy = string2policy(str); - if (policy == CONNMAN_POLICY_UNKNOWN) - return __connman_error_invalid_arguments(msg); + return __connman_error_failed(msg, -err); + } - global_policy = policy; - } else if (g_str_equal(name, "FlightMode") == TRUE) { - connman_bool_t flightmode; + return NULL; +} - dbus_message_iter_get_basic(&value, &flightmode); - if (global_flightmode == flightmode) - return __connman_error_invalid_arguments(msg); +static DBusMessage *connect_provider(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + int err; - global_flightmode = flightmode; + DBG("conn %p", conn); + + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0) + return __connman_error_permission_denied(msg); + + err = __connman_provider_create_and_connect(msg); + if (err < 0) { + if (err == -EINPROGRESS) { + connman_error("Invalid return code from connect"); + err = -EINVAL; + } - __connman_device_set_flightmode(flightmode); + return __connman_error_failed(msg, -err); } - return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); + return NULL; } static DBusMessage *register_agent(DBusConnection *conn, DBusMessage *msg, void *data) { - DBusMessage *reply; const char *sender, *path; + int err; DBG("conn %p", conn); @@ -251,51 +541,145 @@ static DBusMessage *register_agent(DBusConnection *conn, dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); - reply = dbus_message_new_method_return(msg); - if (reply == NULL) - return NULL; + err = __connman_agent_register(sender, path); + if (err < 0) + return __connman_error_failed(msg, -err); - dbus_message_append_args(reply, DBUS_TYPE_INVALID); + return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); +} + +static DBusMessage *unregister_agent(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *sender, *path; + int err; - __connman_agent_register(sender, path); + DBG("conn %p", conn); - return reply; + sender = dbus_message_get_sender(msg); + + dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_INVALID); + + err = __connman_agent_unregister(sender, path); + if (err < 0) + return __connman_error_failed(msg, -err); + + return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } -static DBusMessage *unregister_agent(DBusConnection *conn, +static DBusMessage *register_counter(DBusConnection *conn, DBusMessage *msg, void *data) { - DBusMessage *reply; const char *sender, *path; + unsigned int interval; + int err; DBG("conn %p", conn); sender = dbus_message_get_sender(msg); dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_UINT32, &interval, DBUS_TYPE_INVALID); - reply = dbus_message_new_method_return(msg); - if (reply == NULL) - return NULL; + err = __connman_counter_register(sender, path, interval); + if (err < 0) + return __connman_error_failed(msg, -err); - dbus_message_append_args(reply, DBUS_TYPE_INVALID); + return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); +} - __connman_agent_unregister(sender, path); +static DBusMessage *unregister_counter(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *sender, *path; + int err; - return reply; + DBG("conn %p", conn); + + sender = dbus_message_get_sender(msg); + + dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_INVALID); + + err = __connman_counter_unregister(sender, path); + if (err < 0) + return __connman_error_failed(msg, -err); + + return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); +} + +static DBusMessage *request_session(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *bearer, *sender, *service_path; + struct connman_service *service; + + DBG("conn %p", conn); + + sender = dbus_message_get_sender(msg); + + dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &bearer, + DBUS_TYPE_INVALID); + + service = __connman_session_request(bearer, sender); + if (service == NULL) + return __connman_error_failed(msg, EINVAL); + + service_path = __connman_service_get_path(service); + + return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &service_path, + DBUS_TYPE_INVALID); +} + +static DBusMessage *release_session(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *sender; + int err; + + DBG("conn %p", conn); + + sender = dbus_message_get_sender(msg); + + err = __connman_session_release(sender); + if (err < 0) + return __connman_error_failed(msg, -err); + + return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } static GDBusMethodTable manager_methods[] = { - { "GetProperties", "", "a{sv}", get_properties }, - { "SetProperty", "sv", "", set_property }, - { "RegisterAgent", "o", "", register_agent }, - { "UnregisterAgent", "o", "", unregister_agent }, + { "GetProperties", "", "a{sv}", get_properties }, + { "SetProperty", "sv", "", set_property }, + { "GetState", "", "s", get_state }, + { "CreateProfile", "s", "o", create_profile }, + { "RemoveProfile", "o", "", remove_profile }, + { "RemoveProvider", "s", "", remove_provider }, + { "RequestScan", "s", "", request_scan }, + { "EnableTechnology", "s", "", enable_technology, + G_DBUS_METHOD_FLAG_ASYNC }, + { "DisableTechnology", "s", "", disable_technology, + G_DBUS_METHOD_FLAG_ASYNC }, + { "GetServices", "", "a(oa{sv})", get_services }, + { "LookupService", "s", "o", lookup_service, }, + { "ConnectService", "a{sv}", "o", connect_service, + G_DBUS_METHOD_FLAG_ASYNC }, + { "ConnectProvider", "a{sv}", "o", connect_provider, + G_DBUS_METHOD_FLAG_ASYNC }, + { "RegisterAgent", "o", "", register_agent }, + { "UnregisterAgent", "o", "", unregister_agent }, + { "RegisterCounter", "ou", "", register_counter }, + { "UnregisterCounter", "o", "", unregister_counter }, + { "RequestSession", "s", "o", request_session }, + { "ReleaseSession", "s", "", release_session }, { }, }; static GDBusSignalTable manager_signals[] = { { "PropertyChanged", "sv" }, + { "StateChanged", "s" }, { }, }; @@ -351,7 +735,10 @@ static DBusMessage *nm_state(DBusConnection *conn, if (reply == NULL) return NULL; - state = NM_STATE_DISCONNECTED; + if (__connman_notifier_count_connected() > 0) + state = NM_STATE_CONNECTED; + else + state = NM_STATE_DISCONNECTED; dbus_message_append_args(reply, DBUS_TYPE_UINT32, &state, DBUS_TYPE_INVALID); @@ -366,17 +753,19 @@ static GDBusMethodTable nm_methods[] = { { }, }; -static DBusConnection *connection = NULL; static gboolean nm_compat = FALSE; -int __connman_manager_init(DBusConnection *conn, gboolean compat) +int __connman_manager_init(gboolean compat) { - DBG("conn %p", conn); + DBG(""); - connection = dbus_connection_ref(conn); + connection = connman_dbus_get_connection(); if (connection == NULL) return -1; + if (connman_notifier_register(&technology_notifier) < 0) + connman_error("Failed to register technology notifier"); + g_dbus_register_interface(connection, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, manager_methods, @@ -394,7 +783,12 @@ int __connman_manager_init(DBusConnection *conn, gboolean compat) void __connman_manager_cleanup(void) { - DBG("conn %p", connection); + DBG(""); + + connman_notifier_unregister(&technology_notifier); + + if (connection == NULL) + return; if (nm_compat == TRUE) { g_dbus_unregister_interface(connection, NM_PATH, NM_INTERFACE);