4 * Copyright (c) 2015 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Anupam Roy <anupam.r@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
26 #include <vconf-keys.h>
28 #include <bt-hal-gap-agent.h>
29 #include <bt-hal-agent.h>
30 #include <bt-hal-internal.h>
33 #include "bt-hal-log.h"
34 #include "bt-hal-msg.h"
35 #include "bt-hal-utils.h"
41 #include "bt-hal-adapter-dbus-handler.h"
42 #include "bt-hal-dbus-common-utils.h"
44 static GDBusConnection *connection = NULL;
47 GAP_AGENT_ERROR_REJECT,
48 GAP_AGENT_ERROR_CANCEL,
49 GAP_AGENT_ERROR_TIMEOUT,
52 #define GAP_AGENT_ERROR (gap_agent_error_quark())
54 static GQuark gap_agent_error_quark(void)
56 static GQuark quark = 0;
58 quark = g_quark_from_static_string("agent");
64 /* Forward declaration */
65 static gboolean __gap_agent_unregister(GapAgentPrivate *agent);
66 static GDBusNodeInfo *__bt_service_create_method_node_info
67 (const gchar *introspection_data);
68 static void __bt_gap_agent_method(GDBusConnection *connection,
70 const gchar *object_path,
71 const gchar *interface_name,
72 const gchar *method_name,
74 GDBusMethodInvocation *invocation,
76 void _gap_agent_set_canceled(GapAgentPrivate *agent, gboolean value);
78 static gint gap_agent_id = -1;
81 static void __bt_hal_free_osp_server(gpointer data)
83 bt_hal_agent_osp_server_t *server = data;
90 /* TODO: Free additional elements if present */
96 static void __bt_hal_gap_agent_remove_osp_servers(GSList *osp_servers)
101 ERR("osp_servers is NULL");
106 g_slist_free_full(osp_servers, __bt_hal_free_osp_server);
112 gboolean _gap_agent_register(GapAgentPrivate *agent)
114 GapAgentPrivate *priv = agent;
115 GDBusProxy *agent_manager;
116 GError *error = NULL;
124 if (priv->agent_manager == NULL) {
125 agent_manager = g_dbus_proxy_new_sync(connection,
126 G_DBUS_PROXY_FLAGS_NONE, NULL,
127 BT_HAL_BLUEZ_NAME, BT_HAL_BLUEZ_PATH,
128 BT_HAL_AGENT_MANAGER_INTERFACE, NULL, &error);
129 if (!agent_manager) {
131 ERR("Unable to create proxy: %s", error->message);
132 g_clear_error(&error);
137 agent_manager = priv->agent_manager;
140 reply = g_dbus_proxy_call_sync(agent_manager, "RegisterAgent",
141 #ifdef TIZEN_BT_IO_CAPA_NO_INPUT_OUTPUT
142 g_variant_new("(os)", priv->path, "NoInputNoOutput"),
144 g_variant_new("(os)", priv->path, "DisplayYesNo"),
146 G_DBUS_CALL_FLAGS_NONE, -1,
149 ERR("Agent registration failed");
151 ERR("Agent registration failed: errCode[%x], message[%s]",
152 error->code, error->message);
153 g_clear_error(&error);
155 g_object_unref(agent_manager);
156 priv->agent_manager = NULL;
159 g_variant_unref(reply);
162 /* Set the defalut agent */
163 DBG("agent_manager[%p] priv->path[%s]", agent_manager, priv->path);
164 reply = g_dbus_proxy_call_sync(agent_manager, "RequestDefaultAgent",
165 g_variant_new("(o)", priv->path),
166 G_DBUS_CALL_FLAGS_NONE, -1,
169 ERR("Request Default Agent failed");
171 ERR("Request Default Agent failed: errCode[%x], message[%s]",
172 error->code, error->message);
173 g_clear_error(&error);
175 g_object_unref(agent_manager);
176 priv->agent_manager = NULL;
179 g_variant_unref(reply);
181 priv->agent_manager = agent_manager;
186 static const gchar gap_agent_bluez_introspection_xml[] =
188 " <interface name='org.bluez.Agent1'>"
189 " <method name='RequestPinCode'>"
190 " <arg type='o' name='device' direction='in'/>"
191 " <arg type='s' name='pincode' direction='out'/>"
193 " <method name='RequestPasskey'>"
194 " <arg type='o' name='device' direction='in'/>"
195 " <arg type='u' name='passkey' direction='out'/>"
197 " <method name='DisplayPasskey'>"
198 " <arg type='o' name='device' direction='in'/>"
199 " <arg type='u' name='passkey' direction='in'/>"
200 " <arg type='q' name='entered' direction='in'/>"
202 " <method name='RequestConfirmation'>"
203 " <arg type='o' name='device' direction='in'/>"
204 " <arg type='u' name='passkey' direction='in'/>"
206 " <method name='RequestAuthorization'>"
207 " <arg type='o' name='device' direction='in'/>"
209 " <method name='AuthorizeService'>"
210 " <arg type='o' name='device' direction='in'/>"
211 " <arg type='s' name='uuid' direction='in'/>"
213 " <method name='Cancel'>"
215 " <method name='Release'>"
217 " <method name='ReplyPinCode'>"
218 " <arg type='u' name='accept' direction='in'/>"
219 " <arg type='s' name='pincode' direction='in'/>"
221 " <method name='ReplyPasskey'>"
222 " <arg type='u' name='accept' direction='in'/>"
223 " <arg type='s' name='passkey' direction='in'/>"
225 " <method name='ReplyConfirmation'>"
226 " <arg type='u' name='accept' direction='in'/>"
228 " <method name='ReplyAuthorize'>"
229 " <arg type='u' name='accept' direction='in'/>"
231 " <method name='ConfirmModeChange'>"
232 " <arg type='s' name='mode' direction='in'/>"
234 " <method name='GetDiscoverableTimeout'>"
235 " <arg type='u' name='timeout' direction='out'/>"
241 static const GDBusInterfaceVTable method_table = {
242 __bt_gap_agent_method,
247 void _gap_agent_setup_dbus(GapAgentPrivate *agent, GAP_AGENT_FUNC_CB *func_cb,
251 GapAgentPrivate *priv = agent;
253 GDBusNodeInfo *node_info;
254 GError *error = NULL;
257 priv->path = g_strdup(path);
259 node_info = __bt_service_create_method_node_info(
260 gap_agent_bluez_introspection_xml);
261 if (node_info == NULL)
264 DBG("path is [%s]", path);
266 connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
269 ERR("Unable to connect to gdbus: %s", error->message);
270 g_clear_error(&error);
275 if (gap_agent_id == -1) {
276 gap_agent_id = g_dbus_connection_register_object(connection, path,
277 node_info->interfaces[0],
282 g_dbus_node_info_unref(node_info);
284 if (gap_agent_id == 0) {
285 ERR("Failed to register for Path: %s", path);
287 ERR("Failed to register: %s", error->message);
288 g_clear_error(&error);
293 memcpy(&priv->cb, func_cb, sizeof(GAP_AGENT_FUNC_CB));
295 priv->exec_type = GAP_AGENT_EXEC_NO_OPERATION;
296 memset(priv->pairing_addr, 0x00, sizeof(priv->pairing_addr));
297 memset(priv->authorize_addr, 0x00, sizeof(priv->authorize_addr));
298 priv->reply_context = NULL;
300 DBG("path: %s", path);
302 proxy = g_dbus_proxy_new_sync(connection,
303 G_DBUS_PROXY_FLAGS_NONE, NULL,
304 BT_HAL_BLUEZ_NAME, path,
305 BT_HAL_AGENT_INTERFACE, NULL, &error);
308 ERR("Unable to create proxy");
310 ERR("Error: %s", error->message);
311 g_clear_error(&error);
313 priv->busname = NULL;
315 priv->busname = g_strdup(g_dbus_proxy_get_name(proxy));
316 g_object_unref(proxy);
317 DBG("Busname: %s", priv->busname);
322 void _gap_agent_reset_dbus(GapAgentPrivate *agent)
324 GapAgentPrivate *priv = agent;
326 /* Fix : NULL_RETURNS */
330 __gap_agent_unregister(agent);
332 if (gap_agent_id > 0) {
335 g_dbus_connection_unregister_object(connection,
341 if (priv->osp_servers)
342 __bt_hal_gap_agent_remove_osp_servers(priv->osp_servers);
345 g_object_ref(priv->adapter);
346 priv->adapter = NULL;
351 g_free(priv->busname);
352 priv->busname = NULL;
355 gchar* _gap_agent_get_path(GapAgentPrivate *agent)
357 GapAgentPrivate *priv = agent;
359 /* Fix : NULL_RETURNS */
366 gboolean _gap_agent_is_canceled(GapAgentPrivate *agent)
368 GapAgentPrivate *priv = agent;
370 /* Fix : NULL_RETURNS */
374 return priv->canceled;
377 void _gap_agent_set_canceled(GapAgentPrivate *agent, gboolean value)
379 GapAgentPrivate *priv = agent;
381 /* Fix : NULL_RETURNS */
385 priv->canceled = value;
388 static gboolean __gap_agent_unregister(GapAgentPrivate *agent)
390 GapAgentPrivate *priv = agent;
391 GDBusProxy *agent_manager;
392 GError *error = NULL;
395 if (priv == NULL || priv->path == NULL || connection == NULL)
398 if (priv->agent_manager == NULL) {
399 agent_manager = g_dbus_proxy_new_sync(connection,
400 G_DBUS_PROXY_FLAGS_NONE, NULL,
401 BT_HAL_BLUEZ_NAME, BT_HAL_BLUEZ_PATH,
402 BT_HAL_AGENT_MANAGER_INTERFACE, NULL, &error);
403 if (!agent_manager) {
405 ERR("Unable to create proxy: %s", error->message);
406 g_clear_error(&error);
411 agent_manager = priv->agent_manager;
414 reply = g_dbus_proxy_call_sync(agent_manager, "UnregisterAgent",
415 g_variant_new("o", priv->path),
416 G_DBUS_CALL_FLAGS_NONE, -1,
418 g_object_unref(agent_manager);
419 priv->agent_manager = NULL;
422 ERR("Agent unregistration failed");
424 ERR("Agent unregistration failed: errCode[%x], message[%s]",
425 error->code, error->message);
426 g_clear_error(&error);
430 g_variant_unref(reply);
435 static GDBusNodeInfo *__bt_service_create_method_node_info
436 (const gchar *introspection_data)
439 GDBusNodeInfo *node_info = NULL;
441 if (introspection_data == NULL)
444 node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
447 ERR("Unable to create node: %s", err->message);
453 static void __bt_gap_agent_method(GDBusConnection *connection,
455 const gchar *object_path,
456 const gchar *interface_name,
457 const gchar *method_name,
458 GVariant *parameters,
459 GDBusMethodInvocation *invocation,
465 DBG("Method[%s] Object Path[%s] Interface Name[%s]",
466 method_name, object_path, interface_name);
469 if (g_strcmp0(method_name, "RequestPinCode") == 0) {
470 GapAgentPrivate *agent = user_data;
474 GDBusConnection *conn;
479 g_variant_get(parameters, "(&o)", &path);
480 DBG("Request pin code, Device Path :%s", path);
483 if (g_strcmp0(sender, agent->busname) != 0)
487 if (!agent->cb.passkey_func)
489 conn = _bt_hal_get_system_gconn();
492 device = g_dbus_proxy_new_sync(conn,
493 G_DBUS_PROXY_FLAGS_NONE, NULL,
494 BT_HAL_BLUEZ_NAME, path,
495 BT_HAL_PROPERTIES_INTERFACE, NULL, &err);
497 ERR("Fail to make device proxy");
498 g_dbus_method_invocation_return_error(invocation,
499 GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
500 "No proxy for device");
502 ERR("Unable to create proxy: %s", err->message);
508 agent->exec_type = GAP_AGENT_EXEC_PAIRING;
509 agent->reply_context = invocation;
511 addr = strstr(path, "dev_");
515 g_strlcpy(agent->pairing_addr, addr, sizeof(agent->pairing_addr));
517 while ((pos = strchr(agent->pairing_addr, '_')) != NULL)
520 agent->cb.pincode_func(agent, device);
521 g_object_unref(device);
523 } else if (g_strcmp0(method_name, "RequestPasskey") == 0) {
524 GapAgentPrivate *priv = user_data;
528 GDBusConnection *conn;
533 g_variant_get(parameters, "(&o)", &path);
534 DBG("Request passkey : sender %s priv->busname %s Device Path :%s",
535 sender, priv->busname, path);
537 if (g_strcmp0(sender, agent->busname) != 0)
540 if (!priv->cb.passkey_func)
542 conn = _bt_hal_get_system_gconn();
546 device = g_dbus_proxy_new_sync(conn,
547 G_DBUS_PROXY_FLAGS_NONE, NULL,
548 BT_HAL_BLUEZ_NAME, path,
549 BT_HAL_PROPERTIES_INTERFACE, NULL, &err);
552 ERR("Fail to make device proxy");
554 g_dbus_method_invocation_return_error(invocation,
555 GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
556 "No proxy for device");
558 ERR("Unable to create proxy: %s", err->message);
563 priv->exec_type = GAP_AGENT_EXEC_PAIRING;
564 priv->reply_context = invocation;
566 addr = strstr(path, "dev_");
570 g_strlcpy(priv->pairing_addr, addr, sizeof(priv->pairing_addr));
572 while ((pos = strchr(priv->pairing_addr, '_')) != NULL)
575 priv->cb.passkey_func(priv, device);
576 g_object_unref(device);
578 } else if (g_strcmp0(method_name, "DisplayPasskey") == 0) {
579 GapAgentPrivate *priv = user_data;
584 GDBusConnection *conn;
588 g_variant_get(parameters, "(&ouq)", &path, &passkey, &entered);
589 DBG("Request passkey display :sender %s priv->busname %s"
590 " Device Path :%s, Passkey: %d, Entered: %d",
591 sender, priv->busname, path, passkey, entered);
592 /* Do not show popup for Key event while typing*/
596 if (g_strcmp0(sender, agent->busname) != 0)
599 if (!priv->cb.display_func)
602 conn = _bt_hal_get_system_gconn();
605 device = g_dbus_proxy_new_sync(conn,
606 G_DBUS_PROXY_FLAGS_NONE, NULL,
607 BT_HAL_BLUEZ_NAME, path,
608 BT_HAL_PROPERTIES_INTERFACE, NULL, &err);
610 ERR("Fail to make device proxy");
612 g_dbus_method_invocation_return_error(invocation,
613 GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
614 "No proxy for device");
616 ERR("Unable to create proxy: %s", err->message);
621 g_dbus_method_invocation_return_value(invocation, NULL);
622 priv->cb.display_func(priv, device, passkey);
623 g_object_unref(device);
625 } else if (g_strcmp0(method_name, "RequestConfirmation") == 0) {
626 GapAgentPrivate *priv = user_data;
631 GDBusConnection *conn;
636 g_variant_get(parameters, "(&ou)", &path, &passkey);
637 DBG("Request passkey confirmation, Device Path :%s, Passkey: %d",
640 DBG("Sender: [%s] priv->busname: [%s]", sender, priv->busname);
642 if (g_strcmp0(sender, agent->busname) != 0)
645 DBG("priv->cb.confirm_func [%p]", priv->cb.confirm_func);
646 if (!priv->cb.confirm_func)
648 conn = _bt_hal_get_system_gconn();
651 device = g_dbus_proxy_new_sync(conn,
652 G_DBUS_PROXY_FLAGS_NONE, NULL,
653 BT_HAL_BLUEZ_NAME, path,
654 BT_HAL_PROPERTIES_INTERFACE, NULL, &err);
656 ERR("Fail to make device proxy");
657 g_dbus_method_invocation_return_error(invocation,
658 GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
659 "No proxy for device");
661 ERR("Unable to create proxy: %s", err->message);
666 priv->exec_type = GAP_AGENT_EXEC_PAIRING;
667 priv->reply_context = invocation;
668 addr = strstr(path, "dev_");
672 g_strlcpy(priv->pairing_addr, addr, sizeof(priv->pairing_addr));
674 while ((pos = strchr(priv->pairing_addr, '_')) != NULL)
678 DBG("Pairing address [%s]", priv->pairing_addr);
679 priv->cb.confirm_func(priv, device, passkey);
680 g_object_unref(device);
682 } else if (g_strcmp0(method_name, "AuthorizeService") == 0) {
683 GapAgentPrivate *priv = user_data;
685 GDBusConnection *conn;
693 g_variant_get(parameters, "(&o&s)", &path, &uuid);
694 DBG("Request authorization :sender %s priv->busname %s "
695 "Device Path :%s UUID: %s",
696 sender, priv->busname, path, uuid);
699 if (g_strcmp0(sender, agent->busname) != 0)
703 if (!priv->cb.authorize_func)
706 conn = _bt_hal_get_system_gconn();
710 device = g_dbus_proxy_new_sync(conn,
711 G_DBUS_PROXY_FLAGS_NONE, NULL,
712 BT_HAL_BLUEZ_NAME, path,
713 BT_HAL_PROPERTIES_INTERFACE, NULL, &err);
716 ERR("Fail to make device proxy");
718 g_dbus_method_invocation_return_error(invocation,
719 GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
720 "No proxy for device");
723 ERR("Unable to create proxy: %s", err->message);
730 priv->exec_type = GAP_AGENT_EXEC_AUTHORZATION;
731 priv->reply_context = invocation;
733 addr = strstr(path, "dev_");
737 g_strlcpy(priv->authorize_addr, addr,
738 sizeof(priv->authorize_addr));
740 while ((pos = strchr(priv->authorize_addr, '_')) != NULL)
744 priv->cb.authorize_func(priv, device, uuid);
746 g_object_unref(device);
748 } else if (g_strcmp0(method_name, "RequestAuthorization") == 0) {
749 g_dbus_method_invocation_return_value(invocation, NULL);
750 } else if (g_strcmp0(method_name, "ConfirmModeChange") == 0) {
751 g_dbus_method_invocation_return_value(invocation, NULL);
752 } else if (g_strcmp0(method_name, "Cancel") == 0) {
753 GapAgentPrivate *priv = user_data;
757 DBG("Cancelled : agent %p sender %p", priv, sender);
759 if (g_strcmp0(sender, agent->busname) != 0)
762 if (priv->cb.authorization_cancel_func &&
763 priv->exec_type == GAP_AGENT_EXEC_AUTHORZATION) {
764 DBG("Call GAP agent cancel Authorization method.");
765 priv->cb.authorization_cancel_func(priv,
766 priv->authorize_addr);
767 memset(priv->authorize_addr, 0x00,
768 sizeof(priv->authorize_addr));
769 } else if (priv->cb.pairing_cancel_func &&
770 priv->exec_type == GAP_AGENT_EXEC_PAIRING) {
771 DBG("Call GAP agent cancel Pairing method.");
772 priv->cb.pairing_cancel_func(priv,
774 memset(priv->pairing_addr, 0x00, sizeof(priv->pairing_addr));
776 if (priv->exec_type != GAP_AGENT_EXEC_CONFIRM_MODE &&
777 priv->exec_type != GAP_AGENT_EXEC_NO_OPERATION &&
778 priv->reply_context != NULL) {
780 g_dbus_method_invocation_return_error(priv->reply_context,
781 GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
782 "Rejected by remote cancel");
785 /* Canceled flag is set when user cancels pairing request
786 * Since here bluez has cancelled pairing request, we set the flag to false
788 priv->canceled = FALSE;
789 priv->exec_type = GAP_AGENT_EXEC_NO_OPERATION;
790 priv->reply_context = NULL;
792 } else if (g_strcmp0(method_name, "Release") == 0) {
793 GapAgentPrivate *priv = user_data;
798 DBG("Released : sender %s\n", sender);
801 if (g_strcmp0(sender, agent->busname) != 0)
805 g_dbus_method_invocation_return_value(invocation, NULL);
808 priv->exec_type = GAP_AGENT_EXEC_NO_OPERATION;
809 priv->reply_context = NULL;
811 memset(priv->pairing_addr, 0x00, sizeof(priv->pairing_addr));
812 memset(priv->authorize_addr, 0x00, sizeof(priv->authorize_addr));
815 } else if (g_strcmp0(method_name, "GetDiscoverableTimeout") == 0) {
817 } else if (g_strcmp0(method_name, "ReplyPinCode") == 0) {
818 GapAgentPrivate *priv = user_data;
819 const char *pin_code;
822 g_variant_get(parameters, "(u&s)", &accept, &pin_code);
823 DBG("Accept: %d PinCode: %s", accept, pin_code);
824 gap_agent_reply_pin_code(priv, accept, pin_code, invocation);
825 } else if (g_strcmp0(method_name, "ReplyPasskey") == 0) {
826 GapAgentPrivate *priv = user_data;
830 g_variant_get(parameters, "(u&s)", &accept, &passkey);
831 DBG("Accept: %d PinCode: %s", accept, passkey);
832 gap_agent_reply_passkey(priv, accept, passkey, invocation);
833 } else if (g_strcmp0(method_name, "ReplyConfirmation") == 0) {
834 GapAgentPrivate *priv = user_data;
837 g_variant_get(parameters, "(u)", &accept);
838 DBG("Accept: %d", accept);
839 gap_agent_reply_confirmation(priv, accept, invocation);
840 } else if (g_strcmp0(method_name, "ReplyAuthorize") == 0) {
841 GapAgentPrivate *priv = user_data;
844 g_variant_get(parameters, "(u)", &accept);
845 DBG("Accept: %d", accept);
846 gap_agent_reply_authorize(priv, accept, invocation);
851 gboolean gap_agent_reply_confirmation(GapAgentPrivate *agent, const guint accept,
852 GDBusMethodInvocation *context)
857 GapAgentPrivate *priv = agent;
859 /* Fix : NULL_RETURNS */
863 if (priv->exec_type != GAP_AGENT_EXEC_NO_OPERATION &&
864 priv->reply_context != NULL) {
865 if (accept == GAP_AGENT_ACCEPT || accept == GAP_AGENT_ACCEPT_ALWAYS) {
866 g_dbus_method_invocation_return_value(priv->reply_context, NULL);
867 priv->canceled = FALSE;
870 case GAP_AGENT_CANCEL:
871 g_dbus_method_invocation_return_error(priv->reply_context,
872 GAP_AGENT_ERROR, GAP_AGENT_ERROR_CANCEL,
874 priv->canceled = TRUE;
876 case GAP_AGENT_TIMEOUT:
877 case GAP_AGENT_REJECT:
879 g_dbus_method_invocation_return_error(priv->reply_context,
880 GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
881 "Confirmation request rejected");
882 priv->canceled = FALSE;
888 priv->exec_type = GAP_AGENT_EXEC_NO_OPERATION;
889 priv->reply_context = NULL;
890 memset(priv->pairing_addr, 0x00, sizeof(priv->pairing_addr));
896 gboolean gap_agent_reply_pin_code(GapAgentPrivate *agent, const guint accept,
897 const char *pin_code,
898 GDBusMethodInvocation *context)
901 GapAgentPrivate *priv = agent;
903 /* Fix : NULL_RETURNS */
907 if (priv->exec_type != GAP_AGENT_EXEC_NO_OPERATION &&
908 priv->reply_context != NULL) {
909 if (accept == GAP_AGENT_ACCEPT) {
910 g_dbus_method_invocation_return_value(priv->reply_context,
911 g_variant_new("(s)", pin_code));
912 priv->canceled = FALSE;
915 case GAP_AGENT_CANCEL:
916 g_dbus_method_invocation_return_error(priv->reply_context,
917 GAP_AGENT_ERROR, GAP_AGENT_ERROR_CANCEL,
919 priv->canceled = TRUE;
921 case GAP_AGENT_TIMEOUT:
922 case GAP_AGENT_REJECT:
924 g_dbus_method_invocation_return_error(priv->reply_context,
925 GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
926 "Pairing request rejected");
927 priv->canceled = FALSE;
932 priv->exec_type = GAP_AGENT_EXEC_NO_OPERATION;
933 priv->reply_context = NULL;
934 memset(priv->pairing_addr, 0x00, sizeof(priv->pairing_addr));
940 gboolean gap_agent_reply_passkey(GapAgentPrivate *agent, const guint accept,
942 GDBusMethodInvocation *context)
945 GapAgentPrivate *priv = agent;
947 /* Fix : NULL_RETURNS */
951 if (priv->exec_type != GAP_AGENT_EXEC_NO_OPERATION &&
952 priv->reply_context != NULL) {
953 if (accept == GAP_AGENT_ACCEPT) {
954 guint pass_key = atoi(passkey);
955 g_dbus_method_invocation_return_value(priv->reply_context,
956 g_variant_new("(u)", pass_key));
957 priv->canceled = FALSE;
960 case GAP_AGENT_CANCEL:
961 g_dbus_method_invocation_return_error(priv->reply_context,
962 GAP_AGENT_ERROR, GAP_AGENT_ERROR_CANCEL,
964 priv->canceled = TRUE;
966 case GAP_AGENT_TIMEOUT:
967 case GAP_AGENT_REJECT:
969 g_dbus_method_invocation_return_error(priv->reply_context,
970 GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
971 "Passkey request rejected");
972 priv->canceled = FALSE;
978 priv->exec_type = GAP_AGENT_EXEC_NO_OPERATION;
979 priv->reply_context = NULL;
980 memset(priv->pairing_addr, 0x00, sizeof(priv->pairing_addr));
986 gboolean gap_agent_reply_authorize(GapAgentPrivate *agent, const guint accept,
987 GDBusMethodInvocation *context)
990 GapAgentPrivate *priv = agent;
993 /* Fix : NULL_RETURNS */
997 if (priv->exec_type != GAP_AGENT_EXEC_NO_OPERATION &&
998 priv->reply_context != NULL) {
999 if (accept == GAP_AGENT_ACCEPT) {
1000 g_dbus_method_invocation_return_value(priv->reply_context, NULL);
1001 } else if (accept == GAP_AGENT_ACCEPT_ALWAYS) {
1002 /* TODO: Enable below logic after set authorization API implementation */
1003 g_dbus_method_invocation_return_value(priv->reply_context, NULL);
1006 case GAP_AGENT_CANCEL:
1007 g_dbus_method_invocation_return_error(priv->reply_context,
1008 GAP_AGENT_ERROR, GAP_AGENT_ERROR_CANCEL,
1011 case GAP_AGENT_TIMEOUT:
1012 case GAP_AGENT_REJECT:
1014 g_dbus_method_invocation_return_error(priv->reply_context,
1015 GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
1016 "Authorization request rejected");
1022 g_dbus_method_invocation_return_value(context, NULL);
1026 g_dbus_method_invocation_return_error(context,
1027 GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
1032 priv->exec_type = GAP_AGENT_EXEC_NO_OPERATION;
1033 priv->reply_context = NULL;
1034 memset(priv->authorize_addr, 0x00, sizeof(priv->authorize_addr));
1041 bt_hal_agent_osp_server_t *_bt_hal_gap_agent_find_osp_server_by_type(GSList *servers, unsigned int type)
1044 bt_hal_agent_osp_server_t *server;
1046 for (l = servers; l != NULL; l = g_slist_next(l)) {
1052 if (type == server->type)
1059 gboolean _bt_hal_gap_agent_register_osp_server(GapAgentPrivate *agent, unsigned int type)
1061 bt_hal_agent_osp_server_t *server;
1065 GapAgentPrivate *priv = agent;
1069 if (type >= BT_OSP_SERVER_MAX)
1072 server = g_malloc0(sizeof(bt_hal_agent_osp_server_t));
1073 server->type = type;
1074 priv->osp_servers = g_slist_append(priv->osp_servers, server);
1080 gboolean _bt_hal_gap_agent_unregister_osp_server(GapAgentPrivate *agent, unsigned int type)
1082 bt_hal_agent_osp_server_t *server;
1084 GapAgentPrivate *priv = agent;
1090 if (type >= BT_OSP_SERVER_MAX)
1093 server = _bt_hal_gap_agent_find_osp_server_by_type(priv->osp_servers, type);
1097 priv->osp_servers = g_slist_remove(priv->osp_servers, server);
1098 __bt_hal_free_osp_server(server);