X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fagent.c;h=581f977cff1dc43764798b8a2554407d5c553f95;hb=0e9992014e61671dc81685b7ce87c2da39b877fc;hp=56217efa6d9f8732012de3b8e863946c771087e0;hpb=3723f489f57481fdc996371ef4e3c1a47b6ff770;p=framework%2Fconnectivity%2Fconnman.git diff --git a/src/agent.c b/src/agent.c index 56217ef..581f977 100644 --- a/src/agent.c +++ b/src/agent.c @@ -2,7 +2,7 @@ * * Connection Manager * - * Copyright (C) 2007-2010 Intel Corporation. All rights reserved. + * Copyright (C) 2007-2012 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 @@ -85,6 +85,26 @@ int __connman_agent_unregister(const char *sender, const char *path) return 0; } +static connman_bool_t check_reply_has_dict(DBusMessage *reply) +{ + const char *signature = 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; + + if (dbus_message_has_signature(reply, signature) == TRUE) + return TRUE; + + connman_warn("Reply %s to %s from %s has wrong signature %s", + signature, + dbus_message_get_interface(reply), + dbus_message_get_sender(reply), + dbus_message_get_signature(reply)); + + return FALSE; +} + struct request_input_reply { struct connman_service *service; authentication_cb_t callback; @@ -94,17 +114,28 @@ struct request_input_reply { static void request_input_passphrase_reply(DBusPendingCall *call, void *user_data) { struct request_input_reply *passphrase_reply = user_data; + connman_bool_t values_received = FALSE; connman_bool_t wps = FALSE; + const char *error = NULL; char *identity = NULL; char *passphrase = NULL; char *wpspin = NULL; char *key; + char *name = NULL; + int name_len = 0; DBusMessageIter iter, dict; DBusMessage *reply = dbus_pending_call_steal_reply(call); - if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) + if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) { + error = dbus_message_get_error_name(reply); + goto done; + } + + if (check_reply_has_dict(reply) == FALSE) goto done; + values_received = TRUE; + dbus_message_iter_init(reply, &iter); dbus_message_iter_recurse(&iter, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { @@ -141,33 +172,41 @@ static void request_input_passphrase_reply(DBusPendingCall *call, void *user_dat dbus_message_iter_recurse(&entry, &value); dbus_message_iter_get_basic(&value, &wpspin); break; + } else if (g_str_equal(key, "Name")) { + dbus_message_iter_next(&entry); + if (dbus_message_iter_get_arg_type(&entry) + != DBUS_TYPE_VARIANT) + break; + dbus_message_iter_recurse(&entry, &value); + dbus_message_iter_get_basic(&value, &name); + name_len = strlen(name); + } else if (g_str_equal(key, "SSID")) { + dbus_message_iter_next(&entry); + if (dbus_message_iter_get_arg_type(&entry) + != DBUS_TYPE_VARIANT) + break; + dbus_message_iter_recurse(&entry, &value); + if (dbus_message_iter_get_arg_type(&value) + != DBUS_TYPE_VARIANT) + break; + if (dbus_message_iter_get_element_type(&value) + != DBUS_TYPE_VARIANT) + break; + dbus_message_iter_get_fixed_array(&value, &name, + &name_len); } dbus_message_iter_next(&dict); } - if (wps == TRUE) { - struct connman_network *network; - - network = __connman_service_get_network( - passphrase_reply->service); - if (network == NULL) - goto done; - - connman_network_set_bool(network, "WiFi.UseWPS", wps); - - if (wpspin != NULL && strlen(wpspin) > 0) - connman_network_set_string(network, - "WiFi.PinWPS", wpspin); - else - connman_network_set_string(network, - "WiFi.PinWPS", NULL); - } - done: - passphrase_reply->callback(passphrase_reply->service, identity, - passphrase, passphrase_reply->user_data); + passphrase_reply->callback(passphrase_reply->service, values_received, + name, name_len, + identity, passphrase, + wps, wpspin, error, + passphrase_reply->user_data); connman_service_unref(passphrase_reply->service); dbus_message_unref(reply); + dbus_pending_call_unref(call); g_free(passphrase_reply); } @@ -198,7 +237,7 @@ static void request_input_append_identity(DBusMessageIter *iter, connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &str); - str = "Mandatory"; + str = "mandatory"; connman_dbus_dict_append_basic(iter, "Requirement", DBUS_TYPE_STRING, &str); } @@ -234,7 +273,7 @@ static void request_input_append_passphrase(DBusMessageIter *iter, } connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &value); - value = "Mandatory"; + value = "mandatory"; connman_dbus_dict_append_basic(iter, "Requirement", DBUS_TYPE_STRING, &value); @@ -257,7 +296,108 @@ static void request_input_append_wps(DBusMessageIter *iter, void *user_data) DBUS_TYPE_STRING, &str); } -int __connman_agent_request_input(struct connman_service *service, +static void request_input_append_name(DBusMessageIter *iter, void *user_data) +{ + const char *str = "string"; + + connman_dbus_dict_append_basic(iter, "Type", + DBUS_TYPE_STRING, &str); + str = "mandatory"; + connman_dbus_dict_append_basic(iter, "Requirement", + DBUS_TYPE_STRING, &str); + connman_dbus_dict_append_array(iter, "Alternates", + DBUS_TYPE_STRING, + request_input_append_alternates, + "SSID"); +} + +static void request_input_append_ssid(DBusMessageIter *iter, void *user_data) +{ + const char *str = "ssid"; + + connman_dbus_dict_append_basic(iter, "Type", + DBUS_TYPE_STRING, &str); + str = "alternate"; + connman_dbus_dict_append_basic(iter, "Requirement", + DBUS_TYPE_STRING, &str); +} + +static void request_input_append_password(DBusMessageIter *iter, + void *user_data) +{ + char *str = "passphrase"; + + connman_dbus_dict_append_basic(iter, "Type", + DBUS_TYPE_STRING, &str); + str = "mandatory"; + connman_dbus_dict_append_basic(iter, "Requirement", + DBUS_TYPE_STRING, &str); +} + +static void request_input_login_reply(DBusPendingCall *call, void *user_data) +{ + struct request_input_reply *username_password_reply = user_data; + const char *error = NULL; + connman_bool_t values_received = FALSE; + char *username = NULL; + char *password = NULL; + char *key; + DBusMessageIter iter, dict; + DBusMessage *reply = dbus_pending_call_steal_reply(call); + + if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) { + error = dbus_message_get_error_name(reply); + goto done; + } + + if (check_reply_has_dict(reply) == FALSE) + goto done; + + values_received = TRUE; + + dbus_message_iter_init(reply, &iter); + dbus_message_iter_recurse(&iter, &dict); + while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { + DBusMessageIter entry, value; + + dbus_message_iter_recurse(&dict, &entry); + if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) + break; + + dbus_message_iter_get_basic(&entry, &key); + + if (g_str_equal(key, "Username")) { + dbus_message_iter_next(&entry); + if (dbus_message_iter_get_arg_type(&entry) + != DBUS_TYPE_VARIANT) + break; + dbus_message_iter_recurse(&entry, &value); + dbus_message_iter_get_basic(&value, &username); + + } else if (g_str_equal(key, "Password")) { + dbus_message_iter_next(&entry); + if (dbus_message_iter_get_arg_type(&entry) != + DBUS_TYPE_VARIANT) + break; + dbus_message_iter_recurse(&entry, &value); + dbus_message_iter_get_basic(&value, &password); + } + + dbus_message_iter_next(&dict); + } + +done: + username_password_reply->callback(username_password_reply->service, + values_received, NULL, 0, + username, password, + FALSE, NULL, error, + username_password_reply->user_data); + connman_service_unref(username_password_reply->service); + dbus_message_unref(reply); + g_free(username_password_reply); +} + +int __connman_agent_request_passphrase_input(struct connman_service *service, authentication_cb_t callback, void *user_data) { DBusMessage *message; @@ -284,14 +424,24 @@ int __connman_agent_request_input(struct connman_service *service, connman_dbus_dict_open(&iter, &dict); + if (__connman_service_is_hidden(service)) { + connman_dbus_dict_append_dict(&dict, "Name", + request_input_append_name, NULL); + connman_dbus_dict_append_dict(&dict, "SSID", + request_input_append_ssid, NULL); + } + if (__connman_service_get_security(service) == CONNMAN_SERVICE_SECURITY_8021X) { connman_dbus_dict_append_dict(&dict, "Identity", request_input_append_identity, service); } - connman_dbus_dict_append_dict(&dict, "Passphrase", - request_input_append_passphrase, service); + if (__connman_service_get_security(service) != + CONNMAN_SERVICE_SECURITY_NONE) { + connman_dbus_dict_append_dict(&dict, "Passphrase", + request_input_append_passphrase, service); + } if (__connman_service_wps_enabled(service) == TRUE) { connman_dbus_dict_append_dict(&dict, "WPS", @@ -306,8 +456,9 @@ int __connman_agent_request_input(struct connman_service *service, return -ENOMEM; } - if (dbus_connection_send_with_reply(connection, message, - &call, -1) == FALSE) { + if (dbus_connection_send_with_reply(connection, message, &call, + connman_timeout_input_request()) + == FALSE) { dbus_message_unref(message); g_free(passphrase_reply); return -ESRCH; @@ -328,7 +479,163 @@ int __connman_agent_request_input(struct connman_service *service, dbus_message_unref(message); - return -EIO; + return -EINPROGRESS; +} + +int __connman_agent_request_login_input(struct connman_service *service, + authentication_cb_t callback, void *user_data) +{ + DBusMessage *message; + const char *path; + DBusMessageIter iter; + DBusMessageIter dict; + DBusPendingCall *call; + struct request_input_reply *username_password_reply; + + if (service == NULL || agent_path == NULL || callback == NULL) + return -ESRCH; + + message = dbus_message_new_method_call(agent_sender, agent_path, + CONNMAN_AGENT_INTERFACE, + "RequestInput"); + if (message == NULL) + return -ENOMEM; + + dbus_message_iter_init_append(message, &iter); + + path = __connman_service_get_path(service); + dbus_message_iter_append_basic(&iter, + DBUS_TYPE_OBJECT_PATH, &path); + + connman_dbus_dict_open(&iter, &dict); + + connman_dbus_dict_append_dict(&dict, "Username", + request_input_append_identity, service); + + connman_dbus_dict_append_dict(&dict, "Password", + request_input_append_password, service); + + connman_dbus_dict_close(&iter, &dict); + + username_password_reply = g_try_new0(struct request_input_reply, 1); + if (username_password_reply == NULL) { + dbus_message_unref(message); + return -ENOMEM; + } + + if (dbus_connection_send_with_reply(connection, message, &call, + connman_timeout_input_request()) + == FALSE) { + dbus_message_unref(message); + g_free(username_password_reply); + return -ESRCH; + } + + if (call == NULL) { + dbus_message_unref(message); + g_free(username_password_reply); + return -ESRCH; + } + + username_password_reply->service = connman_service_ref(service); + username_password_reply->callback = callback; + username_password_reply->user_data = user_data; + + dbus_pending_call_set_notify(call, request_input_login_reply, + username_password_reply, NULL); + + dbus_message_unref(message); + + return -EINPROGRESS; +} + +struct request_browser_reply_data { + struct connman_service *service; + browser_authentication_cb_t callback; + void *user_data; +}; + +static void request_browser_reply(DBusPendingCall *call, void *user_data) +{ + struct request_browser_reply_data *browser_reply_data = user_data; + DBusMessage *reply = dbus_pending_call_steal_reply(call); + connman_bool_t result = FALSE; + const char *error = NULL; + + if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) { + error = dbus_message_get_error_name(reply); + goto done; + } + + result = TRUE; + +done: + browser_reply_data->callback(browser_reply_data->service, result, + error, browser_reply_data->user_data); + connman_service_unref(browser_reply_data->service); + dbus_message_unref(reply); + g_free(browser_reply_data); +} + +int __connman_agent_request_browser(struct connman_service *service, + browser_authentication_cb_t callback, + const char *url, void *user_data) +{ + struct request_browser_reply_data *browser_reply_data; + DBusPendingCall *call; + DBusMessage *message; + DBusMessageIter iter; + const char *path; + + if (service == NULL || agent_path == NULL || callback == NULL) + return -ESRCH; + + if (url == NULL) + url = ""; + + message = dbus_message_new_method_call(agent_sender, agent_path, + CONNMAN_AGENT_INTERFACE, + "RequestBrowser"); + if (message == NULL) + return -ENOMEM; + + dbus_message_iter_init_append(message, &iter); + + path = __connman_service_get_path(service); + dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path); + + dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &url); + + browser_reply_data = g_try_new0(struct request_browser_reply_data, 1); + if (browser_reply_data == NULL) { + dbus_message_unref(message); + return -ENOMEM; + } + + if (dbus_connection_send_with_reply(connection, message, &call, + connman_timeout_browser_launch()) + == FALSE) { + dbus_message_unref(message); + g_free(browser_reply_data); + return -ESRCH; + } + + if (call == NULL) { + dbus_message_unref(message); + g_free(browser_reply_data); + return -ESRCH; + } + + browser_reply_data->service = connman_service_ref(service); + browser_reply_data->callback = callback; + browser_reply_data->user_data = user_data; + + dbus_pending_call_set_notify(call, request_browser_reply, + browser_reply_data, NULL); + + dbus_message_unref(message); + + return -EINPROGRESS; } struct report_error_data { @@ -357,6 +664,7 @@ static void report_error_reply(DBusPendingCall *call, void *user_data) connman_service_unref(report_error->service); g_free(report_error); dbus_message_unref(reply); + dbus_pending_call_unref(call); } int __connman_agent_report_error(struct connman_service *service, @@ -393,8 +701,9 @@ int __connman_agent_report_error(struct connman_service *service, return -ENOMEM; } - if (dbus_connection_send_with_reply(connection, message, - &call, -1) == FALSE) { + if (dbus_connection_send_with_reply(connection, message, &call, + connman_timeout_input_request()) + == FALSE) { dbus_message_unref(message); g_free(report_error); return -ESRCH; @@ -413,7 +722,7 @@ int __connman_agent_report_error(struct connman_service *service, report_error, NULL); dbus_message_unref(message); - return -EIO; + return -EINPROGRESS; } int __connman_agent_init(void)