mirror of
https://git.kernel.org/pub/scm/network/wireless/iwd.git
synced 2024-11-29 22:19:23 +01:00
363 lines
8.8 KiB
C
363 lines
8.8 KiB
C
/*
|
|
*
|
|
* Wireless daemon for Linux
|
|
*
|
|
* Copyright (C) 2017 Intel Corporation. All rights reserved.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <ell/ell.h>
|
|
|
|
#include "agent.h"
|
|
#include "dbus-proxy.h"
|
|
#include "display.h"
|
|
|
|
#define IWD_AGENT_INTERFACE "net.connman.iwd.Agent"
|
|
|
|
#define PROMPT_USERNAME "Username:"
|
|
#define PROMPT_PASSWORD "Password:"
|
|
#define PROMPT_PASSPHRASE "Passphrase:"
|
|
|
|
enum AGENT_OP_TYPE {
|
|
AGENT_OP_TYPE_PASSPHRASE = 1,
|
|
AGENT_OP_TYPE_PASSWORD,
|
|
AGENT_OP_TYPE_UNAME_PASSWORD,
|
|
};
|
|
|
|
static struct l_dbus_message *pending_message;
|
|
static struct pending_op {
|
|
enum AGENT_OP_TYPE type;
|
|
char *last_label;
|
|
struct l_queue *saved_input;
|
|
} pending_op;
|
|
|
|
static struct l_dbus_message *release_method_call(struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
void *user_data)
|
|
{
|
|
display_agent_prompt_release(pending_op.last_label);
|
|
|
|
l_dbus_message_unref(pending_message);
|
|
pending_message = NULL;
|
|
|
|
return l_dbus_message_new_method_return(message);
|
|
}
|
|
|
|
static struct l_dbus_message *request_passphrase_method_call(
|
|
struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
void *user_data)
|
|
{
|
|
const struct proxy_interface *proxy;
|
|
const char *path;
|
|
|
|
if (dbus_message_has_error(message))
|
|
return NULL;
|
|
|
|
l_dbus_message_get_arguments(message, "o", &path);
|
|
if (!path)
|
|
return NULL;
|
|
|
|
proxy = proxy_interface_find(IWD_NETWORK_INTERFACE, path);
|
|
if (!proxy)
|
|
return NULL;
|
|
|
|
display("Type the network passphrase for %s.\n",
|
|
proxy_interface_get_identity_str(proxy));
|
|
display_agent_prompt(PROMPT_PASSPHRASE, true);
|
|
|
|
pending_op.type = AGENT_OP_TYPE_PASSPHRASE;
|
|
pending_op.last_label = PROMPT_PASSPHRASE;
|
|
|
|
pending_message = l_dbus_message_ref(message);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct l_dbus_message *request_private_key_passphrase_method_call(
|
|
struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
void *user_data)
|
|
{
|
|
const struct proxy_interface *proxy;
|
|
const char *path;
|
|
|
|
if (dbus_message_has_error(message))
|
|
return NULL;
|
|
|
|
l_dbus_message_get_arguments(message, "o", &path);
|
|
if (!path)
|
|
return NULL;
|
|
|
|
proxy = proxy_interface_find(IWD_NETWORK_INTERFACE, path);
|
|
if (!proxy)
|
|
return NULL;
|
|
|
|
display("Type the passphrase for the network encrypted private key for "
|
|
"%s.\n", proxy_interface_get_identity_str(proxy));
|
|
display_agent_prompt(PROMPT_PASSPHRASE, true);
|
|
|
|
pending_op.type = AGENT_OP_TYPE_PASSPHRASE;
|
|
pending_op.last_label = PROMPT_PASSPHRASE;
|
|
|
|
pending_message = l_dbus_message_ref(message);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct l_dbus_message *request_username_and_password_method_call(
|
|
struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
void *user_data)
|
|
{
|
|
const struct proxy_interface *proxy;
|
|
const char *path;
|
|
|
|
if (dbus_message_has_error(message))
|
|
return NULL;
|
|
|
|
l_dbus_message_get_arguments(message, "o", &path);
|
|
if (!path)
|
|
return NULL;
|
|
|
|
proxy = proxy_interface_find(IWD_NETWORK_INTERFACE, path);
|
|
if (!proxy)
|
|
return NULL;
|
|
|
|
display("Type the network credentials for %s.\n",
|
|
proxy_interface_get_identity_str(proxy));
|
|
display_agent_prompt(PROMPT_USERNAME, false);
|
|
|
|
pending_op.type = AGENT_OP_TYPE_UNAME_PASSWORD;
|
|
pending_op.last_label = PROMPT_USERNAME;
|
|
|
|
pending_message = l_dbus_message_ref(message);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct l_dbus_message *request_user_password_method_call(
|
|
struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
void *user_data)
|
|
{
|
|
const struct proxy_interface *proxy;
|
|
const char *path;
|
|
const char *username;
|
|
char *username_prompt;
|
|
|
|
if (dbus_message_has_error(message))
|
|
return NULL;
|
|
|
|
l_dbus_message_get_arguments(message, "os", &path, &username);
|
|
if (!path || !username)
|
|
return NULL;
|
|
|
|
proxy = proxy_interface_find(IWD_NETWORK_INTERFACE, path);
|
|
if (!proxy)
|
|
return NULL;
|
|
|
|
display("Type the network password for %s.\n",
|
|
proxy_interface_get_identity_str(proxy));
|
|
|
|
username_prompt = l_strdup_printf(COLOR_BLUE PROMPT_USERNAME " "
|
|
COLOR_OFF "%s\n", username);
|
|
display(username_prompt);
|
|
l_free(username_prompt);
|
|
|
|
display_agent_prompt(PROMPT_PASSWORD, true);
|
|
|
|
pending_op.type = AGENT_OP_TYPE_PASSWORD;
|
|
pending_op.last_label = PROMPT_PASSWORD;
|
|
|
|
pending_message = l_dbus_message_ref(message);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct l_dbus_message *cancel_method_call(struct l_dbus *dbus,
|
|
struct l_dbus_message *message,
|
|
void *user_data)
|
|
{
|
|
display_agent_prompt_release(pending_op.last_label);
|
|
|
|
l_dbus_message_unref(pending_message);
|
|
pending_message = NULL;
|
|
|
|
return l_dbus_message_new_method_return(message);
|
|
}
|
|
|
|
static void setup_agent_interface(struct l_dbus_interface *interface)
|
|
{
|
|
l_dbus_interface_method(interface, "Release", 0, release_method_call,
|
|
"", "");
|
|
|
|
l_dbus_interface_method(interface, "RequestPassphrase", 0,
|
|
request_passphrase_method_call, "s", "o",
|
|
"passphrase", "network");
|
|
|
|
l_dbus_interface_method(interface, "RequestPrivateKeyPassphrase", 0,
|
|
request_private_key_passphrase_method_call,
|
|
"s", "o", "private_key_path", "network");
|
|
|
|
l_dbus_interface_method(interface, "RequestUserNameAndPassword", 0,
|
|
request_username_and_password_method_call,
|
|
"ss", "o", "user", "password", "network");
|
|
|
|
l_dbus_interface_method(interface, "RequestUserPassword", 0,
|
|
request_user_password_method_call, "s", "os",
|
|
"password", "network", "user");
|
|
|
|
l_dbus_interface_method(interface, "Cancel", 0, cancel_method_call,
|
|
"", "s", "reason");
|
|
}
|
|
|
|
static void agent_send_reply(struct l_dbus_message *reply)
|
|
{
|
|
l_dbus_send(dbus_get_bus(), reply);
|
|
|
|
l_dbus_message_unref(pending_message);
|
|
pending_message = NULL;
|
|
}
|
|
|
|
static void process_input_username_password(const char *prompt)
|
|
{
|
|
struct l_dbus_message *reply;
|
|
char *username;
|
|
|
|
if (l_queue_isempty(pending_op.saved_input)) {
|
|
/* received username */
|
|
if (!strlen(prompt)) {
|
|
reply = l_dbus_message_new_error(pending_message,
|
|
IWD_AGENT_INTERFACE ".Error.Canceled",
|
|
"Canceled by user");
|
|
goto send_reply;
|
|
}
|
|
|
|
l_queue_push_tail(pending_op.saved_input, l_strdup(prompt));
|
|
|
|
display_agent_prompt(PROMPT_PASSWORD, true);
|
|
pending_op.last_label = PROMPT_PASSWORD;
|
|
|
|
return;
|
|
}
|
|
|
|
username = l_queue_pop_head(pending_op.saved_input);
|
|
|
|
reply = l_dbus_message_new_method_return(pending_message);
|
|
l_dbus_message_set_arguments(reply, "ss", username, prompt);
|
|
|
|
l_free(username);
|
|
|
|
send_reply:
|
|
agent_send_reply(reply);
|
|
}
|
|
|
|
static void process_input_passphrase(const char *prompt)
|
|
{
|
|
struct l_dbus_message *reply;
|
|
|
|
if (!strlen(prompt)) {
|
|
reply = l_dbus_message_new_error(pending_message,
|
|
IWD_AGENT_INTERFACE ".Error.Canceled",
|
|
"Canceled by user");
|
|
goto send_reply;
|
|
}
|
|
|
|
reply = l_dbus_message_new_method_return(pending_message);
|
|
l_dbus_message_set_arguments(reply, "s", prompt);
|
|
|
|
send_reply:
|
|
agent_send_reply(reply);
|
|
}
|
|
|
|
static void process_input_password(const char *prompt)
|
|
{
|
|
struct l_dbus_message *reply =
|
|
l_dbus_message_new_method_return(pending_message);
|
|
|
|
l_dbus_message_set_arguments(reply, "s", prompt);
|
|
|
|
agent_send_reply(reply);
|
|
}
|
|
|
|
bool agent_prompt(const char *prompt)
|
|
{
|
|
if (!pending_message)
|
|
return false;
|
|
|
|
display_agent_prompt_release(pending_op.last_label);
|
|
|
|
switch (pending_op.type) {
|
|
case AGENT_OP_TYPE_UNAME_PASSWORD:
|
|
process_input_username_password(prompt);
|
|
break;
|
|
case AGENT_OP_TYPE_PASSPHRASE:
|
|
process_input_password(prompt);
|
|
break;
|
|
case AGENT_OP_TYPE_PASSWORD:
|
|
process_input_passphrase(prompt);
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool agent_init(const char *path)
|
|
{
|
|
struct l_dbus *dbus = dbus_get_bus();
|
|
|
|
if (!l_dbus_register_interface(dbus, IWD_AGENT_INTERFACE,
|
|
setup_agent_interface, NULL, false)) {
|
|
l_info("Unable to register %s interface", IWD_AGENT_INTERFACE);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!l_dbus_object_add_interface(dbus, path, IWD_AGENT_INTERFACE,
|
|
NULL)) {
|
|
l_info("Unable to register the agent manager object on '%s'",
|
|
path);
|
|
l_dbus_unregister_interface(dbus, IWD_AGENT_INTERFACE);
|
|
|
|
return false;
|
|
}
|
|
|
|
pending_op.saved_input = l_queue_new();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool agent_exit(const char *path)
|
|
{
|
|
struct l_dbus *dbus = dbus_get_bus();
|
|
|
|
if (pending_message)
|
|
l_dbus_message_unref(pending_message);
|
|
|
|
l_queue_destroy(pending_op.saved_input, l_free);
|
|
|
|
l_dbus_unregister_object(dbus, path);
|
|
l_dbus_unregister_interface(dbus, IWD_AGENT_INTERFACE);
|
|
|
|
return true;
|
|
}
|