dnsproxy: Fix unused variable warnings

[framework/connectivity/connman.git] / src / agent.c

diff --git a/src/agent.c b/src/agent.c
index d000a56..3a8674e 100644 (file)
--- a/src/agent.c
+++ b/src/agent.c
@@ -94,7 +94,10 @@ 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 wps = FALSE;
+       char *identity = NULL;
        char *passphrase = NULL;
+       char *wpspin = NULL;
        char *key;
        DBusMessageIter iter, dict;
        DBusMessage *reply = dbus_pending_call_steal_reply(call);
@@ -112,29 +115,100 @@ static void request_input_passphrase_reply(DBusPendingCall *call, void *user_dat
                        break;
 
                dbus_message_iter_get_basic(&entry, &key);
-               if (g_str_equal(key, "Passphrase")) {
+
+               if (g_str_equal(key, "Identity")) {
+                       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, &identity);
+
+               } else if (g_str_equal(key, "Passphrase")) {
                        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, &passphrase);
+
+               } else if (g_str_equal(key, "WPS")) {
+                       wps = TRUE;
+
+                       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, &wpspin);
                        break;
                }
                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,
+       passphrase_reply->callback(passphrase_reply->service, identity,
                                passphrase, passphrase_reply->user_data);
        connman_service_unref(passphrase_reply->service);
        dbus_message_unref(reply);
        g_free(passphrase_reply);
 }
 
-static void request_input_append_passphrase(DBusMessageIter *iter, void *user_data)
+static void request_input_append_alternates(DBusMessageIter *iter,
+                                                       void *user_data)
+{
+       const char *str = user_data;
+       char **alternates, **alternative;
+
+       if (str == NULL)
+               return;
+
+       alternates = g_strsplit(str, ",", 0);
+       if (alternates == NULL)
+               return;
+
+       for (alternative = alternates; *alternative != NULL; alternative++)
+               dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+                                                               alternative);
+
+       g_strfreev(alternates);
+}
+
+static void request_input_append_identity(DBusMessageIter *iter,
+                                                       void *user_data)
+{
+       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);
+}
+
+static void request_input_append_passphrase(DBusMessageIter *iter,
+                                                       void *user_data)
 {
        struct connman_service *service = user_data;
        char *value;
+       const char *phase2;
 
        switch (__connman_service_get_security(service)) {
        case CONNMAN_SERVICE_SECURITY_WEP:
@@ -143,6 +217,17 @@ static void request_input_append_passphrase(DBusMessageIter *iter, void *user_da
        case CONNMAN_SERVICE_SECURITY_PSK:
                value = "psk";
                break;
+       case CONNMAN_SERVICE_SECURITY_8021X:
+               phase2 = __connman_service_get_phase2(service);
+
+               if (phase2 != NULL && (
+                               g_str_has_suffix(phase2, "GTC") == TRUE ||
+                               g_str_has_suffix(phase2, "OTP") == TRUE))
+                       value = "response";
+               else
+                       value = "passphrase";
+
+               break;
        default:
                value = "string";
                break;
@@ -152,6 +237,24 @@ static void request_input_append_passphrase(DBusMessageIter *iter, void *user_da
        value = "Mandatory";
        connman_dbus_dict_append_basic(iter, "Requirement",
                                DBUS_TYPE_STRING, &value);
+
+       if (__connman_service_wps_enabled(service) == TRUE) {
+               connman_dbus_dict_append_array(iter, "Alternates",
+                                       DBUS_TYPE_STRING,
+                                       request_input_append_alternates,
+                                       "WPS");
+       }
+}
+
+static void request_input_append_wps(DBusMessageIter *iter, void *user_data)
+{
+       const char *str = "wpspin";
+
+       connman_dbus_dict_append_basic(iter, "Type",
+                               DBUS_TYPE_STRING, &str);
+       str = "alternate";
+       connman_dbus_dict_append_basic(iter, "Requirement",
+                               DBUS_TYPE_STRING, &str);
 }
 
 int __connman_agent_request_input(struct connman_service *service,
@@ -180,8 +283,21 @@ int __connman_agent_request_input(struct connman_service *service,
                                DBUS_TYPE_OBJECT_PATH, &path);
 
        connman_dbus_dict_open(&iter, &dict);
+
+       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_wps_enabled(service) == TRUE) {
+           connman_dbus_dict_append_dict(&dict, "WPS",
+                               request_input_append_wps, NULL);
+       }
+
        connman_dbus_dict_close(&iter, &dict);
 
        passphrase_reply = g_try_new0(struct request_input_reply, 1);