int agent_request_oob_data(struct agent *agent, struct btd_device *device,
agent_oob_data_cb cb, void *user_data,
GDestroyNotify destroy)
{
struct agent_request *req;
const gchar *dev_path = device_get_path(device);
int err;
if (agent->request)
return -EBUSY;
DBG("Calling Agent.RequestOobData: name=%s, path=%s",
agent->name, agent->path);
req = agent_request_new(agent, AGENT_REQUEST_OOB_DATA, cb,
user_data, destroy);
err = oob_data_request_new(req, dev_path);
if (err < 0)
goto failed;
agent->request = req;
return 0;
failed:
agent_request_free(req, FALSE);
return err;
}
int agent_request_pairing_consent(struct agent *agent, struct btd_device *device,
agent_cb cb, void *user_data,
GDestroyNotify destroy)
{
struct agent_request *req;
const gchar *dev_path = device_get_path(device);
int err;
if (agent->request)
return -EBUSY;
DBG("Calling Agent.RequestPairingConsent: name=%s, path=%s",
agent->name, agent->path);
req = agent_request_new(agent, AGENT_REQUEST_PAIRING_CONSENT, cb,
user_data, destroy);
err = pairing_consent_request_new(req, dev_path);
if (err < 0)
goto failed;
agent->request = req;
return 0;
failed:
agent_request_free(req, FALSE);
return err;
}
int agent_authorize(struct agent *agent,
// const char *path,
const struct btd_device *device, //CTS VERI
const char *uuid,
agent_cb cb,
void *user_data,
GDestroyNotify destroy)
{
struct agent_request *req;
int err;
if (agent->request)
return -EBUSY;
req = agent_request_new(agent, AGENT_REQUEST_AUTHORIZE, cb,
user_data, destroy);
// err = agent_call_authorize(req, path, uuid);
err = agent_call_authorize(req, device, uuid); //Broadocm Bluetooth feature - CTS VERI
if (err < 0) {
agent_request_free(req, FALSE);
return -ENOMEM;
}
agent->request = req;
// DBG("authorize request was sent for %s", path);
DBG("authorize request was sent for %s", device_get_path(device)); //Broadocm Bluetooth feature - CTS VERI
return 0;
}
static void pincode_reply(DBusPendingCall *call, void *user_data)
{
struct agent_request *req = user_data;
struct agent *agent = req->agent;
struct btd_adapter *adapter = agent->adapter;
agent_pincode_cb cb = req->cb;
DBusMessage *message;
DBusError err;
bdaddr_t sba;
size_t len;
char *pin;
adapter_get_address(adapter, &sba);
/* steal_reply will always return non-NULL since the callback
* is only called after a reply has been received */
message = dbus_pending_call_steal_reply(call);
dbus_error_init(&err);
if (dbus_set_error_from_message(&err, message)) {
error("Agent %s replied with an error: %s, %s",
agent->path, err.name, err.message);
cb(agent, &err, NULL, req->user_data);
dbus_error_free(&err);
goto done;
}
dbus_error_init(&err);
if (!dbus_message_get_args(message, &err,
DBUS_TYPE_STRING, &pin,
DBUS_TYPE_INVALID)) {
error("Wrong passkey reply signature: %s", err.message);
cb(agent, &err, NULL, req->user_data);
dbus_error_free(&err);
goto done;
}
len = strlen(pin);
dbus_error_init(&err);
if (len > 16 || len < 1) {
error("Invalid PIN length (%zu) from agent", len);
dbus_set_error_const(&err, "org.bluez.Error.InvalidArgs",
"Invalid passkey length");
cb(agent, &err, NULL, req->user_data);
dbus_error_free(&err);
goto done;
}
cb(agent, NULL, pin, req->user_data);
done:
if (message)
dbus_message_unref(message);
dbus_pending_call_cancel(req->call);
agent->request = NULL;
agent_request_free(req, TRUE);
}
int agent_display_pincode(struct agent *agent, struct btd_device *device,
const char *pincode, agent_cb cb,
void *user_data, GDestroyNotify destroy)
{
struct agent_request *req;
const char *dev_path = device_get_path(device);
int err;
if (agent->request)
return -EBUSY;
DBG("Calling Agent.DisplayPinCode: name=%s, path=%s, pincode=%s",
agent->owner, agent->path, pincode);
req = agent_request_new(agent, AGENT_REQUEST_DISPLAY_PINCODE, cb,
user_data, destroy);
err = display_pincode_request_new(req, dev_path, pincode);
if (err < 0)
goto failed;
agent->request = req;
return 0;
failed:
agent_request_free(req, FALSE);
return err;
}
int agent_request_oob_availability(struct agent *agent,
const char *path,
agent_cb cb,
void *user_data,
GDestroyNotify destroy)
{
struct agent_request *req;
int err;
if (agent->request)
return -EBUSY;
req = agent_request_new(agent, AGENT_REQUEST_OOB_AVAILABILITY, cb,
user_data, destroy);
err = agent_call_oob_availability(req, path);
if (err < 0) {
agent_request_free(req, FALSE);
return -ENOMEM;
}
agent->request = req;
DBG("oob availability request was sent for %s", path);
return 0;
}
int agent_confirm_mode_change(struct agent *agent, const char *new_mode,
agent_cb cb, void *user_data,
GDestroyNotify destroy)
{
struct agent_request *req;
int err;
if (agent->request)
return -EBUSY;
DBG("Calling Agent.ConfirmModeChange: name=%s, path=%s, mode=%s",
agent->name, agent->path, new_mode);
req = agent_request_new(agent, AGENT_REQUEST_CONFIRM_MODE,
cb, user_data, destroy);
err = confirm_mode_change_request_new(req, new_mode);
if (err < 0)
goto failed;
agent->request = req;
return 0;
failed:
agent_request_free(req, FALSE);
return err;
}
int agent_request_pincode(struct agent *agent, struct btd_device *device,
agent_pincode_cb cb, gboolean secure,
void *user_data, GDestroyNotify destroy)
{
struct agent_request *req;
const char *dev_path = device_get_path(device);
int err;
if (agent->request)
return -EBUSY;
req = agent_request_new(agent, AGENT_REQUEST_PINCODE, cb,
user_data, destroy);
err = pincode_request_new(req, dev_path, secure);
if (err < 0)
goto failed;
agent->request = req;
return 0;
failed:
agent_request_free(req, FALSE);
return err;
}
int agent_request_confirmation(struct agent *agent, struct btd_device *device,
uint32_t passkey, agent_cb cb,
void *user_data, GDestroyNotify destroy)
{
struct agent_request *req;
const gchar *dev_path = device_get_path(device);
int err;
if (agent->request)
return -EBUSY;
DBG("Calling Agent.RequestConfirmation: name=%s, path=%s, passkey=%06u",
agent->name, agent->path, passkey);
req = agent_request_new(agent, AGENT_REQUEST_CONFIRMATION, cb,
user_data, destroy);
err = confirmation_request_new(req, dev_path, passkey);
if (err < 0)
goto failed;
agent->request = req;
return 0;
failed:
agent_request_free(req, FALSE);
return err;
}
static void cancel_all_requests(struct connman_agent *agent)
{
GList *list;
DBG("request %p pending %p", agent->pending, agent->queue);
if (agent->pending) {
if (agent->pending->call)
send_cancel_request(agent, agent->pending);
agent_finalize_pending(agent, NULL);
}
for (list = agent->queue; list; list = list->next) {
struct connman_agent_request *request = list->data;
if (!request)
continue;
request->callback(NULL, request->user_data);
agent_request_free(request);
}
g_list_free(agent->queue);
agent->queue = NULL;
}
int agent_authorize(struct agent *agent,
const char *path,
const char *uuid,
agent_cb cb,
void *user_data,
GDestroyNotify destroy)
{
struct agent_request *req;
int err;
if (agent->request)
return -EBUSY;
req = agent_request_new(agent, AGENT_REQUEST_AUTHORIZE, cb,
user_data, destroy);
err = agent_call_authorize(req, path, uuid);
if (err < 0) {
agent_request_free(req, FALSE);
return -ENOMEM;
}
agent->request = req;
DBG("authorize request was sent for %s", path);
return 0;
}
int agent_request_authorization(struct agent *agent, struct btd_device *device,
agent_cb cb, void *user_data,
GDestroyNotify destroy)
{
struct agent_request *req;
const char *dev_path = device_get_path(device);
int err;
if (agent->request)
return -EBUSY;
DBG("Calling Agent.RequestAuthorization: name=%s, path=%s",
agent->owner, agent->path);
req = agent_request_new(agent, AGENT_REQUEST_AUTHORIZATION, cb,
user_data, destroy);
err = authorization_request_new(req, dev_path);
if (err < 0)
goto failed;
agent->request = req;
return 0;
failed:
agent_request_free(req, FALSE);
return err;
}
void connman_agent_cancel(void *user_context)
{
GHashTableIter iter;
gpointer key, value;
int err;
DBG("context %p", user_context);
g_hash_table_iter_init(&iter, agent_hash);
while (g_hash_table_iter_next(&iter, &key, &value)) {
GList *list, *next;
struct connman_agent *agent = value;
/*
* Cancel all the pending requests to a given agent and service
*/
list = agent->queue;
while (list) {
struct connman_agent_request *request = list->data;
next = list->next;
if (request && request->user_context &&
request->user_context ==
user_context) {
DBG("cancel pending %p", request);
agent->queue = g_list_delete_link(agent->queue,
list);
request->callback(NULL, request->user_data);
agent_request_free(request);
}
list = next;
}
/*
* If there is a request from client to a given service,
* we need to cancel it.
*/
if (agent->pending && agent->pending->user_context &&
agent->pending->user_context == user_context) {
DBG("cancel request %p", agent->pending);
if (agent->pending->call)
send_cancel_request(agent, agent->pending);
agent_finalize_pending(agent, NULL);
err = agent_send_next_request(agent);
if (err < 0 && err != -EBUSY)
DBG("send next request failed (%s/%d)",
strerror(-err), -err);
}
}
}
static void agent_finalize_pending(struct connman_agent *agent,
DBusMessage *reply)
{
struct connman_agent_request *pending = agent->pending;
if (pending) {
agent->pending = NULL;
pending->callback(reply, pending->user_data);
agent_request_free(pending);
}
}
static void simple_agent_reply(DBusPendingCall *call, void *user_data)
{
struct agent_request *req = user_data;
struct agent *agent = req->agent;
DBusMessage *message;
DBusError err;
agent_cb cb = req->cb;
/* steal_reply will always return non-NULL since the callback
* is only called after a reply has been received */
message = dbus_pending_call_steal_reply(call);
dbus_error_init(&err);
if (dbus_set_error_from_message(&err, message)) {
if ((g_str_equal(DBUS_ERROR_UNKNOWN_METHOD, err.name) ||
g_str_equal(DBUS_ERROR_NO_REPLY, err.name)) &&
request_fallback(req, simple_agent_reply) == 0) {
dbus_error_free(&err);
return;
}
error("Agent replied with an error: %s, %s",
err.name, err.message);
cb(agent, &err, req->user_data);
if (dbus_error_has_name(&err, DBUS_ERROR_NO_REPLY)) {
agent_cancel(agent);
dbus_message_unref(message);
dbus_error_free(&err);
return;
}
dbus_error_free(&err);
goto done;
}
dbus_error_init(&err);
if (!dbus_message_get_args(message, &err, DBUS_TYPE_INVALID)) {
error("Wrong reply signature: %s", err.message);
cb(agent, &err, req->user_data);
dbus_error_free(&err);
goto done;
}
cb(agent, NULL, req->user_data);
done:
dbus_message_unref(message);
agent->request = NULL;
agent_request_free(req, TRUE);
}
static void passkey_reply(DBusPendingCall *call, void *user_data)
{
struct agent_request *req = user_data;
struct agent *agent = req->agent;
agent_passkey_cb cb = req->cb;
DBusMessage *message;
DBusError err;
uint32_t passkey;
/* steal_reply will always return non-NULL since the callback
* is only called after a reply has been received */
message = dbus_pending_call_steal_reply(call);
dbus_error_init(&err);
if (dbus_set_error_from_message(&err, message)) {
error("Agent replied with an error: %s, %s",
err.name, err.message);
cb(agent, &err, 0, req->user_data);
// +s LGBT_COMMON_TEMPORARY [email protected] 120829
if (dbus_error_has_name(&err, "org.bluez.Error.Canceled")) {
DBG("User cancel the pairing");
DBG("->device_set_temporary");
device_set_temporary(((struct authentication_req*) req->user_data)->device, TRUE);
}
// +e LGBT_COMMON_TEMPORARY
dbus_error_free(&err);
goto done;
}
dbus_error_init(&err);
if (!dbus_message_get_args(message, &err,
DBUS_TYPE_UINT32, &passkey,
DBUS_TYPE_INVALID)) {
error("Wrong passkey reply signature: %s", err.message);
cb(agent, &err, 0, req->user_data);
dbus_error_free(&err);
goto done;
}
cb(agent, NULL, passkey, req->user_data);
done:
if (message)
dbus_message_unref(message);
dbus_pending_call_cancel(req->call);
agent->request = NULL;
agent_request_free(req, TRUE);
}
static void simple_agent_reply(DBusPendingCall *call, void *user_data)
{
struct agent_request *req = user_data;
struct agent *agent = req->agent;
DBusMessage *message;
DBusError err;
agent_cb cb = req->cb;
/* steal_reply will always return non-NULL since the callback
* is only called after a reply has been received */
message = dbus_pending_call_steal_reply(call);
/* Protect from the callback freeing the agent */
agent_ref(agent);
dbus_error_init(&err);
if (dbus_set_error_from_message(&err, message)) {
DBG("agent error reply: %s, %s", err.name, err.message);
cb(agent, &err, req->user_data);
if (dbus_error_has_name(&err, DBUS_ERROR_NO_REPLY)) {
error("Timed out waiting for reply from agent");
agent_cancel(agent);
dbus_message_unref(message);
dbus_error_free(&err);
agent_unref(agent);
return;
}
dbus_error_free(&err);
goto done;
}
if (!dbus_message_get_args(message, &err, DBUS_TYPE_INVALID)) {
error("Wrong reply signature: %s", err.message);
cb(agent, &err, req->user_data);
dbus_error_free(&err);
goto done;
}
cb(agent, NULL, req->user_data);
done:
dbus_message_unref(message);
agent->request = NULL;
agent_request_free(req, TRUE);
agent_unref(agent);
}
int agent_cancel(struct agent *agent)
{
if (!agent->request)
return -EINVAL;
if (agent->request->call) {
dbus_pending_call_cancel(agent->request->call);
send_cancel_request(agent->request);
}
agent_request_free(agent->request, TRUE);
agent->request = NULL;
return 0;
}
static void display_pincode_reply(DBusPendingCall *call, void *user_data)
{
struct agent_request *req = user_data;
struct agent *agent = req->agent;
DBusMessage *message;
DBusError err;
agent_cb cb = req->cb;
/* clear agent->request early; our callback will likely try
* another request */
agent->request = NULL;
/* steal_reply will always return non-NULL since the callback
* is only called after a reply has been received */
message = dbus_pending_call_steal_reply(call);
dbus_error_init(&err);
if (dbus_set_error_from_message(&err, message)) {
error("Agent replied with an error: %s, %s",
err.name, err.message);
cb(agent, &err, req->user_data);
if (dbus_error_has_name(&err, DBUS_ERROR_NO_REPLY)) {
agent_cancel(agent);
dbus_message_unref(message);
dbus_error_free(&err);
return;
}
dbus_error_free(&err);
goto done;
}
if (!dbus_message_get_args(message, &err, DBUS_TYPE_INVALID)) {
error("Wrong reply signature: %s", err.message);
cb(agent, &err, req->user_data);
dbus_error_free(&err);
goto done;
}
cb(agent, NULL, req->user_data);
done:
dbus_message_unref(message);
agent_request_free(req, TRUE);
}
static void passkey_reply(DBusPendingCall *call, void *user_data)
{
struct agent_request *req = user_data;
struct agent *agent = req->agent;
agent_passkey_cb cb = req->cb;
DBusMessage *message;
DBusError err;
uint32_t passkey;
/* steal_reply will always return non-NULL since the callback
* is only called after a reply has been received */
message = dbus_pending_call_steal_reply(call);
dbus_error_init(&err);
if (dbus_set_error_from_message(&err, message)) {
error("Agent replied with an error: %s, %s",
err.name, err.message);
cb(agent, &err, 0, req->user_data);
dbus_error_free(&err);
goto done;
}
if (!dbus_message_get_args(message, &err,
DBUS_TYPE_UINT32, &passkey,
DBUS_TYPE_INVALID)) {
error("Wrong passkey reply signature: %s", err.message);
cb(agent, &err, 0, req->user_data);
dbus_error_free(&err);
goto done;
}
cb(agent, NULL, passkey, req->user_data);
done:
if (message)
dbus_message_unref(message);
dbus_pending_call_cancel(req->call);
agent->request = NULL;
agent_request_free(req, TRUE);
}
