path: root/binding-bluetooth/bluetooth-agent.c

/*  Copyright 2016 ALPS ELECTRIC CO., LTD.
*
*   Licensed under the Apache License, Version 2.0 (the "License");
*   you may not use this file except in compliance with the License.
*   You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
*   Unless required by applicable law or agreed to in writing, software
*   distributed under the License is distributed on an "AS IS" BASIS,
*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*   See the License for the specific language governing permissions and
*   limitations under the License.
*/

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <gio/gio.h>

#include "bluetooth-agent.h"

#ifdef AGENT_THREAD

#include <pthread.h>

static GMainLoop *agentLoop = NULL;
#endif

static GDBusConnection *system_conn = NULL;
static gboolean agent_registered = FALSE;
static const char *agent_capability = NULL;
static Agent_RegisterCallback_t agent_RegisterCallback = { 0 };
static AGENTOrgBluezAgent1 * agnet_interface = NULL;

static struct Agent_Node *agent_event = NULL;


static void agent_event_auto_release(struct Agent_Node *event)
{
    if (NULL == event ){
        return;
    }
    g_dbus_method_invocation_return_dbus_error (event->invocation,
                                                ERROR_BLUEZ_REJECT, "");
    g_free(event);
}

/*
 * Store the agent event
 */
static void agent_event_new(AGENTOrgBluezAgent1      *object,
                    GDBusMethodInvocation   *invocation, int type)
{
    LOGD("\n");
    if(NULL !=agent_event )
    {
        agent_event_auto_release(agent_event);
    }
    agent_event = g_malloc0(sizeof(struct Agent_Node));
    agent_event->type = type;
    agent_event->object = object;
    agent_event->invocation = invocation;

}


/*
 * agent api
 *
 * Methods : void Release()
 * This method gets called when the service daemon
 * unregisters the agent. An agent can use it to do
 * cleanup tasks. There is no need to unregister the
 * agent, because when this method gets called it has
 * already been unregistered.
 */
static gboolean
on_handle_Release (AGENTOrgBluezAgent1      *object,
                    GDBusMethodInvocation   *invocation,
                    gpointer                user_data)
{
    LOGD("\n");

    //gboolean ret = FALSE;

    if (NULL != agent_RegisterCallback.agent_Release)
    {
        agent_RegisterCallback.agent_Release();
    }

    agent_org_bluez_agent1_complete_release(object, invocation);

    g_dbus_interface_skeleton_unexport(
        G_DBUS_INTERFACE_SKELETON(agnet_interface));

    g_object_unref(agnet_interface);
    agent_registered = FALSE;

#ifdef AGENT_THREAD
    if(agentLoop){
        g_main_loop_quit(agentLoop);
    }
#endif

    return TRUE;
}

/*
 * agent api
 * Methods : string RequestPinCode(object device)
 *
 * This method gets called when the service daemon
 * needs to get the passkey for an authentication.
 *
 * The return value should be a string of 1-16 characters
 * length. The string can be alphanumeric.
 */
static gboolean
on_handle_RequestPinCode (AGENTOrgBluezAgent1       *object,
                            GDBusMethodInvocation   *invocation,
                            const gchar             *device,
                            gpointer                user_data)
{

    LOGD("device:%s.\n",device);

    gboolean ret = FALSE;
    const gchar *error = ERROR_BLUEZ_REJECT;
    gchar *response;

    if (NULL != agent_RegisterCallback.agent_RequestPinCode)
    {
        ret = agent_RegisterCallback.agent_RequestPinCode (device,
                                                           &response, &error);
    }

    if (TRUE == ret)
    {
        agent_org_bluez_agent1_complete_request_pin_code(object,
                                                        invocation, response);
        g_free(response);

    }
    else
    {
         g_dbus_method_invocation_return_dbus_error (invocation, error, "");
    }

    return TRUE;
}

/*
 * agent api
 * Methods : void DisplayPinCode(object device, string pincode)
 *
 * This method gets called when the service daemon
 * needs to display a pincode for an authentication.
 */
static gboolean
on_handle_DisplayPinCode (AGENTOrgBluezAgent1   *object,
                        GDBusMethodInvocation   *invocation,
                        const gchar             *device,
                        const gchar             *pincode,
                        gpointer                user_data)
{

    LOGD("device:%s,pincode:%s.\n",device, pincode);

    gboolean ret = FALSE;
    const gchar *error = ERROR_BLUEZ_REJECT;

    if (NULL != agent_RegisterCallback.agent_DisplayPinCode)
    {
        ret = agent_RegisterCallback.agent_DisplayPinCode(device,
                                                            pincode, &error);
    }

    if (TRUE == ret)
    {
        agent_org_bluez_agent1_complete_display_pin_code(object, invocation);
    }
    else
    {
        g_dbus_method_invocation_return_dbus_error (invocation, error, "");
    }

     return TRUE;
}


/*
 * agent api
 * Methods : uint32 RequestPasskey(object device)
 *
 * This method gets called when the service daemon
 * needs to get the passkey for an authentication.
 *
 * The return value should be a numeric value
 * between 0-999999.
 */
static gboolean
on_handle_RequestPasskey (AGENTOrgBluezAgent1   *object,
                        GDBusMethodInvocation   *invocation,
                        const gchar             *device,
                        gpointer                user_data)
{

    LOGD("device:%s.\n",device);

    gboolean ret = FALSE;
    const gchar *error = ERROR_BLUEZ_REJECT;
    guint passkey;

    if (NULL != agent_RegisterCallback.agent_RequestPasskey)
    {
        ret = agent_RegisterCallback.agent_RequestPasskey(device,
                                                            &passkey, &error);
    }

    if (TRUE == ret)
    {
        agent_org_bluez_agent1_complete_request_passkey(object,
                                                        invocation, passkey);
    }
    else
    {
        g_dbus_method_invocation_return_dbus_error (invocation, error, "");
    }

    return TRUE;

}


/*
 * agent api
 * Methods : void DisplayPasskey(object device, uint32 passkey, uint16 entered)
 *
 * This method gets called when the service daemon
 * needs to display a passkey for an authentication.
 *
 * The entered parameter indicates the number of already
 * typed keys on the remote side.
 */
static gboolean
on_handle_DisplayPasskey (AGENTOrgBluezAgent1   *object,
                        GDBusMethodInvocation   *invocation,
                        const gchar             *device,
                        guint                   passkey,
                        guint16                 entered,
                        gpointer                user_data)
{

    LOGD("device:%s,passkey:%d,entered:%d.\n",device, passkey, entered);

    //gboolean ret = FALSE;

    if (NULL != agent_RegisterCallback.agent_DisplayPasskey)
    {
        agent_RegisterCallback.agent_DisplayPasskey(device, passkey, entered);
    }

    agent_org_bluez_agent1_complete_display_passkey(object, invocation);


    return TRUE;

}

/*
 * agent api
 * Methods : void RequestConfirmation(object device, uint32 passkey)
 *
 * This method gets called when the service daemon
 * needs to confirm a passkey for an authentication.
 *
 * To confirm the value it should return an empty reply
 * or an error in case the passkey is invalid.
 */
static gboolean
on_handle_RequestConfirmation (AGENTOrgBluezAgent1  *object,
                            GDBusMethodInvocation   *invocation,
                            const gchar             *device,
                            guint                   passkey,
                            gpointer                user_data)
{
    LOGD("device:%s,passkey:%d.\n", device, passkey);

    gboolean ret = FALSE;
    const gchar *error = ERROR_BLUEZ_REJECT;

    if (NULL != agent_RegisterCallback.agent_RequestConfirmation)
    {
        ret = agent_RegisterCallback.agent_RequestConfirmation(device,
                                                              passkey, &error);
    }
    LOGD("ret %d\n",ret);
    if (TRUE == ret)
    {
        agent_event_new(object, invocation,REQUEST_CONFIRMATION);
        //agent_org_bluez_agent1_complete_request_confirmation(object,
        //                                                    invocation);
    }
    else
    {
        g_dbus_method_invocation_return_dbus_error (invocation, error, "");
    }

    return TRUE;
}

/*
 * agent api
 * Methods : void RequestAuthorization(object device)
 *
 * This method gets called to request the user to
 * authorize an incoming pairing attempt which
 * would in other circumstances trigger the just-works
 * model.
 */
static gboolean
on_handle_RequestAuthorization (AGENTOrgBluezAgent1     *object,
                                GDBusMethodInvocation   *invocation,
                                const gchar             *device,
                                gpointer                user_data)
{
    LOGD("device:%s.\n",device);

    gboolean ret = FALSE;
    const gchar *error = ERROR_BLUEZ_REJECT;

    if (NULL != agent_RegisterCallback.agent_RequestAuthorization)
    {
        ret = agent_RegisterCallback.agent_RequestAuthorization(device,&error);
    }

    if (TRUE == ret)
    {
        agent_org_bluez_agent1_complete_request_authorization(object,
                                                                invocation);
    }
    else
    {
        g_dbus_method_invocation_return_dbus_error (invocation, error, "");
    }

    return TRUE;
}

/*
 * agent api
 * Methods : void AuthorizeService(object device, string uuid)
 *
 * This method gets called when the service daemon
 * needs to authorize a connection/service request.
 */
static gboolean
on_handle_AuthorizeService (AGENTOrgBluezAgent1     *object,
                            GDBusMethodInvocation   *invocation,
                            const gchar             *device,
                            const gchar             *uuid,
                            gpointer                user_data)
{

    LOGD("device:%s.uuid:%s\n",device,uuid);

    gboolean ret = FALSE;
    const gchar *error = ERROR_BLUEZ_REJECT;

    if (NULL != agent_RegisterCallback.agent_AuthorizeService)
    {
        ret = agent_RegisterCallback.agent_AuthorizeService(device,
                                                            uuid, &error);
    }

    if (TRUE == ret)
    {
        agent_org_bluez_agent1_complete_authorize_service(object, invocation);
    }
    else
    {
        g_dbus_method_invocation_return_dbus_error (invocation, error, "");
    }

    return TRUE;
}

/*
 * agent api
 * Methods : void Cancel()
 *
 * This method gets called to indicate that the agent
 * request failed before a reply was returned.
 */
static gboolean
on_handle_Cancel (AGENTOrgBluezAgent1           *object,
                       GDBusMethodInvocation    *invocation,
                       gpointer                 user_data)
{
    LOGD("\n");

    if (NULL != agent_RegisterCallback.agent_Cancel)
    {
        agent_RegisterCallback.agent_Cancel();
    }

    agent_org_bluez_agent1_complete_cancel(object, invocation);

    return TRUE;

}

/*
 * agent init
 * init the dbus and register the agent to bluez
 */
static int create_and_register_agent(const char *capability)
{
    GError *error = NULL;
    gboolean ret;
    GVariant *value;

    LOGD("%s\n",capability);

    if (agent_registered == TRUE) {
        LOGD("Agent is already registered\n");
        return -1;
    }

    system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);

    if (error)
    {
        LOGE("errr:%s",error->message);
        g_error_free(error);

        return -1;
    }

    agent_capability = capability;

    agnet_interface = agent_org_bluez_agent1_skeleton_new ();

    g_signal_connect (agnet_interface,
                        "handle-release",
                        G_CALLBACK (on_handle_Release),
                        NULL);

    g_signal_connect (agnet_interface,
                        "handle-request-pin-code",
                        G_CALLBACK (on_handle_RequestPinCode),
                        NULL);

    g_signal_connect (agnet_interface,
                        "handle-display-pin-code",
                        G_CALLBACK (on_handle_DisplayPinCode),
                        NULL);

    g_signal_connect (agnet_interface,
                        "handle-request-passkey",
                        G_CALLBACK (on_handle_RequestPasskey),
                        NULL);

    g_signal_connect (agnet_interface,
                        "handle-display-passkey",
                        G_CALLBACK (on_handle_DisplayPasskey),
                        NULL);

    g_signal_connect (agnet_interface,
                        "handle-request-confirmation",
                        G_CALLBACK (on_handle_RequestConfirmation),
                        NULL);

    g_signal_connect (agnet_interface,
                        "handle-request-authorization",
                        G_CALLBACK (on_handle_RequestAuthorization),
                        NULL);

    g_signal_connect (agnet_interface,
                        "handle-authorize-service",
                        G_CALLBACK (on_handle_AuthorizeService),
                        NULL);

    g_signal_connect (agnet_interface,
                        "handle-cancel",
                        G_CALLBACK (on_handle_Cancel),
                        NULL);

    ret = g_dbus_interface_skeleton_export (
                                   G_DBUS_INTERFACE_SKELETON (agnet_interface),
                                    system_conn,
                                    AGENT_PATH,
                                    &error);

    if (FALSE == ret)
    {
        LOGE("errr:%s",error->message);
        g_error_free(error);
        g_object_unref(system_conn);

        return -1;
    }

    value = g_dbus_connection_call_sync(system_conn, BLUEZ_SERVICE,
                    AGENT_PATH,   AGENT_MANAGER_INTERFACE,
                    "RegisterAgent",    g_variant_new("(os)", AGENT_PATH,
                        agent_capability),
                    NULL,  G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT,
                    NULL, &error);

    if (NULL == value) {
        LOGE ("RegisterAgent Err: %s", error->message);
        g_error_free(error);

        g_dbus_interface_skeleton_unexport(
            G_DBUS_INTERFACE_SKELETON(agnet_interface));

        g_object_unref(system_conn);
        return -1;
    }

    g_variant_unref(value);

    agent_capability = NULL;

    agent_registered = TRUE;

    return 0;
}

#ifdef AGENT_THREAD
/*
 * agent thread function
 */
static void *agent_event_loop_thread(const char *capability)
{

    agentLoop = g_main_loop_new(NULL, FALSE);
    guint id;
    GError *error = NULL;
    gboolean ret;

    ret = create_and_register_agent(capability);

    if (0 == ret)
    {
        LOGD("g_main_loop_run\n");
        g_main_loop_run(agentLoop);


    }

    g_main_loop_unref(agentLoop);
    agentLoop = NULL;
    LOGD("exit...\n");
}
#endif


/* --- PUBLIC FUNCTIONS --- */


/*
 * start agent.
 * Returns: 0 - success or other errors
 */
int agent_register(const char *capability)
{
    int ret = 0;
    LOGD("\n");

    if (agent_registered == TRUE) {
        LOGD("Agent is already registered\n");
        return -1;
    }

#ifdef AGENT_THREAD
    pthread_t thread_id;
    pthread_create(&thread_id, NULL, agent_event_loop_thread, capability);
    pthread_setname_np(thread_id, "agent");

#else
    ret = create_and_register_agent(capability);
#endif

    return ret;
}

/*
 * stop agent.
 * Returns: 0 - success or other errors
 */
int stop_agent()
{
    GError *error = NULL;
    GVariant *value;

    LOGD("\n");

    if (agent_registered == FALSE) {
        LOGD("No agent is registered\n");
        return -1;
    }

    value = g_dbus_connection_call_sync(system_conn, BLUEZ_SERVICE,
                    AGENT_PATH,   AGENT_MANAGER_INTERFACE,
                    "UnregisterAgent",    g_variant_new("(o)", AGENT_PATH  ),
                    NULL,  G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT,
                    NULL, &error);

    if (NULL == value) {
        LOGE ("Error UnregisterAgent: %s", error->message);
        g_error_free(error);

        return -1;
    }

    g_dbus_interface_skeleton_unexport(
        G_DBUS_INTERFACE_SKELETON(agnet_interface));

    g_object_unref(agnet_interface);

    g_object_unref(system_conn);

    agent_registered = FALSE;

    memset(&agent_RegisterCallback, 0, sizeof(Agent_RegisterCallback_t));

#ifdef AGENT_THREAD
    if(agentLoop){
        g_main_loop_quit(agentLoop);
    }
#endif

    return 0;
}

/*
 * Register Agent Callback function
 */
void agent_API_register(const Agent_RegisterCallback_t* pstRegisterCallback)
{
    LOGD("\n");

    if (NULL != pstRegisterCallback)
    {
        if (NULL != pstRegisterCallback->agent_Release)
        {
            agent_RegisterCallback.agent_Release =
                pstRegisterCallback->agent_Release;
        }

        if (NULL != pstRegisterCallback->agent_RequestPinCode)
        {
            agent_RegisterCallback.agent_RequestPinCode =
                pstRegisterCallback->agent_RequestPinCode;
        }

        if (NULL != pstRegisterCallback->agent_DisplayPinCode)
        {
            agent_RegisterCallback.agent_DisplayPinCode =
                pstRegisterCallback->agent_DisplayPinCode;
        }

        if (NULL != pstRegisterCallback->agent_RequestPasskey)
        {
            agent_RegisterCallback.agent_RequestPasskey =
                pstRegisterCallback->agent_RequestPasskey;
        }

        if (NULL != pstRegisterCallback->agent_DisplayPasskey)
        {
            agent_RegisterCallback.agent_DisplayPasskey =
                pstRegisterCallback->agent_DisplayPasskey;
        }

        if (NULL != pstRegisterCallback->agent_RequestConfirmation)
        {
            agent_RegisterCallback.agent_RequestConfirmation =
                pstRegisterCallback->agent_RequestConfirmation;
        }

        if (NULL != pstRegisterCallback->agent_RequestAuthorization)
        {
            agent_RegisterCallback.agent_RequestAuthorization =
                pstRegisterCallback->agent_RequestAuthorization;
        }

        if (NULL != pstRegisterCallback->agent_AuthorizeService)
        {
            agent_RegisterCallback.agent_AuthorizeService =
                pstRegisterCallback->agent_AuthorizeService;
        }

        if (NULL != pstRegisterCallback->agent_Cancel)
        {
            agent_RegisterCallback.agent_Cancel =
                pstRegisterCallback->agent_Cancel;
        }

    }

}

/*
 * Send the agent event "RequestConfirmation" reply
 */
int agent_send_confirmation(gboolean confirmation)
{
    if (NULL == agent_event)
    {
        LOGW("Not agent event");
        return -1;
    }
    LOGD("%d-%d\n", confirmation, agent_event->type);

    if (REQUEST_CONFIRMATION != agent_event->type)
    {
        return -1;
    }

    if (TRUE == confirmation){
        agent_org_bluez_agent1_complete_request_confirmation(agent_event->object,
                                                      agent_event->invocation);
    }else{
        g_dbus_method_invocation_return_dbus_error (agent_event->invocation,
                                                    ERROR_BLUEZ_REJECT, "");
    }

    g_free(agent_event);
    agent_event = NULL;
    return 0;
}
/****************************** The End Of File ******************************/