M7350/external/bluetooth/bluez/client/agent.c
2024-09-09 08:57:42 +00:00

493 lines
12 KiB
C

/*
*
* BlueZ - Bluetooth protocol stack for Linux
*
* Copyright (C) 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 as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; 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 <stdio.h>
#include <stdlib.h>
#include <readline/readline.h>
#include <gdbus.h>
#include "display.h"
#include "agent.h"
#define AGENT_PATH "/org/bluez/agent"
#define AGENT_INTERFACE "org.bluez.Agent1"
#define AGENT_PROMPT COLOR_RED "[agent]" COLOR_OFF " "
static gboolean agent_registered = FALSE;
static const char *agent_capability = NULL;
static DBusMessage *pending_message = NULL;
static char *agent_saved_prompt = NULL;
static int agent_saved_point = 0;
static void agent_prompt(const char *msg)
{
char *prompt;
/* Normal use should not prompt for user input to the agent a second
* time before it releases the prompt, but we take a safe action. */
if (agent_saved_prompt)
return;
agent_saved_point = rl_point;
agent_saved_prompt = g_strdup(rl_prompt);
rl_set_prompt("");
rl_redisplay();
prompt = g_strdup_printf(AGENT_PROMPT "%s", msg);
rl_set_prompt(prompt);
g_free(prompt);
rl_replace_line("", 0);
rl_redisplay();
}
static void agent_release_prompt(void)
{
if (!agent_saved_prompt)
return;
/* This will cause rl_expand_prompt to re-run over the last prompt, but
* our prompt doesn't expand anyway. */
rl_set_prompt(agent_saved_prompt);
rl_replace_line("", 0);
rl_point = agent_saved_point;
rl_redisplay();
g_free(agent_saved_prompt);
agent_saved_prompt = NULL;
}
dbus_bool_t agent_completion(void)
{
if (!pending_message)
return FALSE;
return TRUE;
}
static void pincode_response(DBusConnection *conn, const char *input)
{
g_dbus_send_reply(conn, pending_message, DBUS_TYPE_STRING, &input,
DBUS_TYPE_INVALID);
}
static void passkey_response(DBusConnection *conn, const char *input)
{
dbus_uint32_t passkey;
if (sscanf(input, "%u", &passkey) == 1)
g_dbus_send_reply(conn, pending_message, DBUS_TYPE_UINT32,
&passkey, DBUS_TYPE_INVALID);
else if (!strcmp(input, "no"))
g_dbus_send_error(conn, pending_message,
"org.bluez.Error.Rejected", NULL);
else
g_dbus_send_error(conn, pending_message,
"org.bluez.Error.Canceled", NULL);
}
static void confirm_response(DBusConnection *conn, const char *input)
{
if (!strcmp(input, "yes"))
g_dbus_send_reply(conn, pending_message, DBUS_TYPE_INVALID);
else if (!strcmp(input, "no"))
g_dbus_send_error(conn, pending_message,
"org.bluez.Error.Rejected", NULL);
else
g_dbus_send_error(conn, pending_message,
"org.bluez.Error.Canceled", NULL);
}
dbus_bool_t agent_input(DBusConnection *conn, const char *input)
{
const char *member;
if (!pending_message)
return FALSE;
agent_release_prompt();
member = dbus_message_get_member(pending_message);
if (!strcmp(member, "RequestPinCode"))
pincode_response(conn, input);
else if (!strcmp(member, "RequestPasskey"))
passkey_response(conn, input);
else if (!strcmp(member, "RequestConfirmation"))
confirm_response(conn, input);
else if (!strcmp(member, "RequestAuthorization"))
confirm_response(conn, input);
else if (!strcmp(member, "AuthorizeService"))
confirm_response(conn, input);
else
g_dbus_send_error(conn, pending_message,
"org.bluez.Error.Canceled", NULL);
dbus_message_unref(pending_message);
pending_message = NULL;
return TRUE;
}
static void agent_release(DBusConnection *conn)
{
agent_registered = FALSE;
agent_capability = NULL;
if (pending_message) {
dbus_message_unref(pending_message);
pending_message = NULL;
}
agent_release_prompt();
g_dbus_unregister_interface(conn, AGENT_PATH, AGENT_INTERFACE);
}
static DBusMessage *release_agent(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
rl_printf("Agent released\n");
agent_release(conn);
return dbus_message_new_method_return(msg);
}
static DBusMessage *request_pincode(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
const char *device;
rl_printf("Request PIN code\n");
dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &device,
DBUS_TYPE_INVALID);
agent_prompt("Enter PIN code: ");
pending_message = dbus_message_ref(msg);
return NULL;
}
static DBusMessage *display_pincode(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
const char *device;
const char *pincode;
dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &device,
DBUS_TYPE_STRING, &pincode, DBUS_TYPE_INVALID);
rl_printf(AGENT_PROMPT "PIN code: %s\n", pincode);
return dbus_message_new_method_return(msg);
}
static DBusMessage *request_passkey(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
const char *device;
rl_printf("Request passkey\n");
dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &device,
DBUS_TYPE_INVALID);
agent_prompt("Enter passkey (number in 0-999999): ");
pending_message = dbus_message_ref(msg);
return NULL;
}
static DBusMessage *display_passkey(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
const char *device;
dbus_uint32_t passkey;
dbus_uint16_t entered;
char passkey_full[7];
dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &device,
DBUS_TYPE_UINT32, &passkey, DBUS_TYPE_UINT16, &entered,
DBUS_TYPE_INVALID);
snprintf(passkey_full, sizeof(passkey_full), "%.6u", passkey);
passkey_full[6] = '\0';
if (entered > strlen(passkey_full))
entered = strlen(passkey_full);
rl_printf(AGENT_PROMPT "Passkey: "
COLOR_BOLDGRAY "%.*s" COLOR_BOLDWHITE "%s\n" COLOR_OFF,
entered, passkey_full, passkey_full + entered);
return dbus_message_new_method_return(msg);
}
static DBusMessage *request_confirmation(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
const char *device;
dbus_uint32_t passkey;
char *str;
rl_printf("Request confirmation\n");
dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &device,
DBUS_TYPE_UINT32, &passkey, DBUS_TYPE_INVALID);
str = g_strdup_printf("Confirm passkey %06u (yes/no): ", passkey);
agent_prompt(str);
g_free(str);
pending_message = dbus_message_ref(msg);
return NULL;
}
static DBusMessage *request_authorization(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
const char *device;
rl_printf("Request authorization\n");
dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &device,
DBUS_TYPE_INVALID);
agent_prompt("Accept pairing (yes/no): ");
pending_message = dbus_message_ref(msg);
return NULL;
}
static DBusMessage *authorize_service(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
const char *device, *uuid;
char *str;
rl_printf("Authorize service\n");
dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &device,
DBUS_TYPE_STRING, &uuid, DBUS_TYPE_INVALID);
str = g_strdup_printf("Authorize service %s (yes/no): ", uuid);
agent_prompt(str);
g_free(str);
pending_message = dbus_message_ref(msg);
return NULL;
}
static DBusMessage *cancel_request(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
rl_printf("Request canceled\n");
agent_release_prompt();
dbus_message_unref(pending_message);
pending_message = NULL;
return dbus_message_new_method_return(msg);
}
static const GDBusMethodTable methods[] = {
{ GDBUS_METHOD("Release", NULL, NULL, release_agent) },
{ GDBUS_ASYNC_METHOD("RequestPinCode",
GDBUS_ARGS({ "device", "o" }),
GDBUS_ARGS({ "pincode", "s" }), request_pincode) },
{ GDBUS_METHOD("DisplayPinCode",
GDBUS_ARGS({ "device", "o" }, { "pincode", "s" }),
NULL, display_pincode) },
{ GDBUS_ASYNC_METHOD("RequestPasskey",
GDBUS_ARGS({ "device", "o" }),
GDBUS_ARGS({ "passkey", "u" }), request_passkey) },
{ GDBUS_METHOD("DisplayPasskey",
GDBUS_ARGS({ "device", "o" }, { "passkey", "u" },
{ "entered", "q" }),
NULL, display_passkey) },
{ GDBUS_ASYNC_METHOD("RequestConfirmation",
GDBUS_ARGS({ "device", "o" }, { "passkey", "u" }),
NULL, request_confirmation) },
{ GDBUS_ASYNC_METHOD("RequestAuthorization",
GDBUS_ARGS({ "device", "o" }),
NULL, request_authorization) },
{ GDBUS_ASYNC_METHOD("AuthorizeService",
GDBUS_ARGS({ "device", "o" }, { "uuid", "s" }),
NULL, authorize_service) },
{ GDBUS_METHOD("Cancel", NULL, NULL, cancel_request) },
{ }
};
static void register_agent_setup(DBusMessageIter *iter, void *user_data)
{
const char *path = AGENT_PATH;
const char *capability = agent_capability;
dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &capability);
}
static void register_agent_reply(DBusMessage *message, void *user_data)
{
DBusConnection *conn = user_data;
DBusError error;
dbus_error_init(&error);
if (dbus_set_error_from_message(&error, message) == FALSE) {
agent_registered = TRUE;
rl_printf("Agent registered\n");
} else {
rl_printf("Failed to register agent: %s\n", error.name);
dbus_error_free(&error);
if (g_dbus_unregister_interface(conn, AGENT_PATH,
AGENT_INTERFACE) == FALSE)
rl_printf("Failed to unregister agent object\n");
}
}
void agent_register(DBusConnection *conn, GDBusProxy *manager,
const char *capability)
{
if (agent_registered == TRUE) {
rl_printf("Agent is already registered\n");
return;
}
agent_capability = capability;
if (g_dbus_register_interface(conn, AGENT_PATH,
AGENT_INTERFACE, methods,
NULL, NULL, NULL, NULL) == FALSE) {
rl_printf("Failed to register agent object\n");
return;
}
if (g_dbus_proxy_method_call(manager, "RegisterAgent",
register_agent_setup,
register_agent_reply,
conn, NULL) == FALSE) {
rl_printf("Failed to call register agent method\n");
return;
}
agent_capability = NULL;
}
static void unregister_agent_setup(DBusMessageIter *iter, void *user_data)
{
const char *path = AGENT_PATH;
dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
}
static void unregister_agent_reply(DBusMessage *message, void *user_data)
{
DBusConnection *conn = user_data;
DBusError error;
dbus_error_init(&error);
if (dbus_set_error_from_message(&error, message) == FALSE) {
rl_printf("Agent unregistered\n");
agent_release(conn);
} else {
rl_printf("Failed to unregister agent: %s\n", error.name);
dbus_error_free(&error);
}
}
void agent_unregister(DBusConnection *conn, GDBusProxy *manager)
{
if (agent_registered == FALSE) {
rl_printf("No agent is registered\n");
return;
}
if (!manager) {
rl_printf("Agent unregistered\n");
agent_release(conn);
return;
}
if (g_dbus_proxy_method_call(manager, "UnregisterAgent",
unregister_agent_setup,
unregister_agent_reply,
conn, NULL) == FALSE) {
rl_printf("Failed to call unregister agent method\n");
return;
}
}
static void request_default_setup(DBusMessageIter *iter, void *user_data)
{
const char *path = AGENT_PATH;
dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
}
static void request_default_reply(DBusMessage *message, void *user_data)
{
DBusError error;
dbus_error_init(&error);
if (dbus_set_error_from_message(&error, message) == TRUE) {
rl_printf("Failed to request default agent: %s\n", error.name);
dbus_error_free(&error);
return;
}
rl_printf("Default agent request successful\n");
}
void agent_default(DBusConnection *conn, GDBusProxy *manager)
{
if (agent_registered == FALSE) {
rl_printf("No agent is registered\n");
return;
}
if (g_dbus_proxy_method_call(manager, "RequestDefaultAgent",
request_default_setup,
request_default_reply,
NULL, NULL) == FALSE) {
rl_printf("Failed to call request default agent method\n");
return;
}
}