bt-oal/bluez_hal/src/bt-hal-mesh.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * @author: Anupam Roy <anupam.r@samsung.com>
   7  *
   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
  11  *
  12  *              http://www.apache.org/licenses/LICENSE-2.0
  13  *
  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.
  19  *
  20  */
  21
  22 #include <stdbool.h>
  23 #include <stddef.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include <ell/ell.h>
  27 #include <dlog.h>
  28 #include <glib.h>
  29
  30 #include "bt-hal.h"
  31 #include "bt-hal-log.h"
  32 #include "bt-hal-msg.h"
  33 #include "bt-hal-utils.h"
  34
  35 #include "bt-hal-mesh-dbus-handler.h"
  36 #include "bt-hal-event-receiver.h"
  37
  38 static const btmesh_callbacks_t *bt_hal_mesh_cbacks = NULL;
  39
  40 static bool interface_ready(void)
  41 {
  42         return bt_hal_mesh_cbacks != NULL;
  43 }
  44
  45 static void __bt_hal_mesh_network_attached(void *buf, uint16_t len)
  46 {
  47         struct hal_ev_mesh_network_attached *ev = buf;
  48         if (bt_hal_mesh_cbacks->network_attached_cb)
  49                 bt_hal_mesh_cbacks->network_attached_cb(ev->status,
  50                         (bt_mesh_token_t*)&ev->token,
  51                                 (bt_uuid_t*)&ev->uuid);
  52 }
  53
  54 static void __bt_hal_handle_network_scan_result(void *buf, uint16_t len)
  55 {
  56         struct hal_ev_mesh_scan_result *ev = buf;
  57         bt_mesh_scan_result_t result;
  58         memset(&result, 0x00, sizeof(bt_mesh_scan_result_t));
  59
  60         memcpy(result.dev_uuid.uu, ev->dev_uuid, 16);
  61         memcpy(&result.oob_info, ev->oob_info, 2);
  62         memcpy(&result.uri_hash, ev->uri_hash, 4);
  63         result.rssi = ev->rssi;
  64
  65         if (bt_hal_mesh_cbacks->scan_result_cb)
  66                 bt_hal_mesh_cbacks->scan_result_cb(ev->status,
  67                         (bt_uuid_t*)&ev->net_uuid,
  68                                 (bt_mesh_scan_result_t*)&result);
  69 }
  70
  71 static void __bt_hal_handle_network_scan_status(void *buf, uint16_t len)
  72 {
  73         struct hal_ev_mesh_scan_state_changed *ev = buf;
  74
  75         if (bt_hal_mesh_cbacks->scan_status_cb)
  76                 bt_hal_mesh_cbacks->scan_status_cb(ev->state, ev->status,
  77                         (bt_uuid_t*)&ev->net_uuid);
  78 }
  79
  80 static void __bt_hal_handle_network_provisioning_status(void *buf, uint16_t len)
  81 {
  82         struct hal_ev_mesh_provision_status *ev = buf;
  83
  84         INFO("Mesh: Send provstatus callback");
  85         if (bt_hal_mesh_cbacks->provisioning_status_cb)
  86                 bt_hal_mesh_cbacks->provisioning_status_cb(ev->status,
  87                                 (bt_uuid_t*)&ev->net_uuid,
  88                                         (bt_uuid_t*)&ev->dev_uuid);
  89         INFO("Mesh: Done Sending  provstatus callback");
  90 }
  91
  92 static void __bt_hal_handle_network_provisioning_finished(void *buf, uint16_t len)
  93 {
  94         struct hal_ev_mesh_provision_finished *ev = buf;
  95
  96         if (bt_hal_mesh_cbacks->provisioning_finished_cb)
  97                 bt_hal_mesh_cbacks->provisioning_finished_cb(ev->status, ev->reason,
  98                                 (bt_uuid_t*)&ev->net_uuid, (bt_uuid_t*)&ev->dev_uuid,
  99                                         ev->unicast, ev->count);
 100 }
 101
 102 static void __bt_hal_handle_network_provisioning_data_requested(void *buf,
 103                 uint16_t len)
 104 {
 105         struct hal_ev_mesh_provision_data_request *ev = buf;
 106
 107         if (bt_hal_mesh_cbacks->provisioning_data_requested_cb)
 108                 bt_hal_mesh_cbacks->provisioning_data_requested_cb(
 109                         (bt_uuid_t*)&ev->net_uuid, ev->count);
 110 }
 111
 112 static void __bt_hal_handle_authentication_requested(void *buf, uint16_t len)
 113 {
 114         struct hal_ev_mesh_authentication_request *ev = buf;
 115
 116         if (bt_hal_mesh_cbacks->authentication_requested_cb)
 117                 bt_hal_mesh_cbacks->authentication_requested_cb(
 118                         (bt_uuid_t*)&ev->net_uuid, ev->auth_type, ev->auth_value);
 119 }
 120
 121 static void __bt_hal_handle_netkey_execute_event(void *buf, uint16_t len)
 122 {
 123         struct hal_ev_mesh_netkey_execute_event *ev = buf;
 124
 125         if (bt_hal_mesh_cbacks->netkey_execute_cb)
 126                 bt_hal_mesh_cbacks->netkey_execute_cb(ev->status,
 127                         (bt_uuid_t*)&ev->net_uuid,
 128                                 ev->key_event, ev->key_idx);
 129 }
 130
 131 static void __bt_hal_handle_appkey_execute_event(void *buf, uint16_t len)
 132 {
 133         struct hal_ev_mesh_appkey_execute_event *ev = buf;
 134
 135         if (bt_hal_mesh_cbacks->appkey_execute_cb)
 136                 bt_hal_mesh_cbacks->appkey_execute_cb(ev->status,
 137                         (bt_uuid_t*)&ev->net_uuid, ev->key_event,
 138                                 ev->net_idx, ev->app_idx);
 139 }
 140
 141 static void __bt_hal_handle_devkey_message_received_event(void *buf, uint16_t len)
 142 {
 143         struct hal_ev_mesh_devkey_message_event *ev = buf;
 144
 145         if (bt_hal_mesh_cbacks->devkey_msg_cb)
 146                 bt_hal_mesh_cbacks->devkey_msg_cb((bt_uuid_t*)&ev->net_uuid,
 147                         ev->source_addr,
 148                                 ev->is_remote_devkey, ev->netkey_idx,
 149                                         ev->data_len, ev->data);
 150 }
 151
 152 static void __bt_hal_handle_mesh_events(int message, void *buf, uint16_t len)
 153 {
 154         DBG("+");
 155
 156         if (!interface_ready())
 157                 return;
 158
 159         switch (message) {
 160         case HAL_EV_MESH_NETWORK_ATTACHED:
 161                 DBG("Mesh Event: HAL_EV_MESH_NETWORK_ATTACHED");
 162                 __bt_hal_mesh_network_attached(buf, len);
 163                 break;
 164         case HAL_EV_MESH_SCAN_STATE_CHANGED:
 165                 DBG("Mesh Event: HAL_EV_MESH_SCAN_STATE_CHANGED");
 166                 __bt_hal_handle_network_scan_status(buf, len);
 167                 break;
 168         case HAL_EV_MESH_SCAN_RESULT:
 169                 DBG("Mesh Event: HAL_EV_MESH_SCAN_RESULT");
 170                 __bt_hal_handle_network_scan_result(buf, len);
 171                 break;
 172         case HAL_EV_MESH_PROVISIONING_STATUS:
 173                 DBG("Mesh Event: HAL_EV_MESH_PROVISIONING_STATUS");
 174                 __bt_hal_handle_network_provisioning_status(buf, len);
 175                 break;
 176         case HAL_EV_MESH_PROVISIONING_FINISHED:
 177                 DBG("Mesh Event: HAL_EV_MESH_PROVISIONING_FINISHED");
 178                 __bt_hal_handle_network_provisioning_finished(buf, len);
 179                 break;
 180         case HAL_EV_MESH_PROVISIONING_DATA_REQUEST:
 181                 DBG("Mesh Event: HAL_EV_MESH_PROVISIONING_DATA_REQUEST");
 182                 __bt_hal_handle_network_provisioning_data_requested(buf, len);
 183                 break;
 184         case HAL_EV_MESH_AUTHENTICATION_REQUEST:
 185                 DBG("Mesh Event: HAL_EV_MESH_AUTHENTICATION_REQUEST");
 186                 __bt_hal_handle_authentication_requested(buf, len);
 187                 break;
 188         case HAL_EV_MESH_NETKEY_EXECUTE_EVENT:
 189                 DBG("Mesh Event: HAL_EV_MESH_NETKEY_EXECUTE_EVENT");
 190                 __bt_hal_handle_netkey_execute_event(buf, len);
 191                 break;
 192         case HAL_EV_MESH_APPKEY_EXECUTE_EVENT:
 193                 DBG("Mesh Event: HAL_EV_MESH_APPKEY_EXECUTE_EVENT");
 194                 __bt_hal_handle_appkey_execute_event(buf, len);
 195                 break;
 196         case HAL_EV_MESH_DEVKEY_MESSAGE_EVENT:
 197                 DBG("Mesh Event: HAL_EV_MESH_DEVKEY_MESSAGE_EVENT");
 198                 __bt_hal_handle_devkey_message_received_event(buf, len);
 199                 break;
 200         default:
 201                 DBG("Mesh Event Currently not handled!!");
 202                 break;
 203         }
 204
 205         DBG("-");
 206 }
 207
 208 static bt_status_t mesh_create_network(bt_hal_mesh_node_t *node,
 209                 GSList *models, bool is_prov)
 210 {
 211         DBG("");
 212         return _bt_hal_mesh_create_network(node, models, is_prov);
 213 }
 214
 215 static bt_status_t mesh_scan(bt_uuid_t *network, bt_hal_mesh_scan_param_t *param)
 216 {
 217         DBG("");
 218         return _bt_hal_mesh_network_scan(network, param);
 219 }
 220
 221 static bt_status_t mesh_scan_cancel(bt_uuid_t *network)
 222 {
 223         DBG("");
 224         return _bt_hal_mesh_network_scan_cancel(network);
 225 }
 226
 227 static bt_status_t mesh_set_prov_caps(bt_uuid_t *network,
 228                 bt_hal_mesh_prov_caps_t *caps)
 229 {
 230         DBG("");
 231         return _bt_hal_mesh_network_set_caps(network, caps);
 232 }
 233
 234 static bt_status_t mesh_provision_device(bt_uuid_t *network,
 235                 bt_uuid_t *dev_uuid)
 236 {
 237         DBG("");
 238         return _bt_hal_mesh_provision_device(network, dev_uuid);
 239 }
 240
 241 static bt_status_t mesh_send_provision_data(bt_uuid_t* network_uuid,
 242                 uint16_t netkey_idx, uint16_t unicast)
 243 {
 244         DBG("");
 245         return _bt_hal_mesh_send_provision_data(network_uuid,
 246                         netkey_idx, unicast);
 247 }
 248
 249 static bt_status_t mesh_network_subnet_operation(bt_uuid_t* network_uuid,
 250                         bt_mesh_key_op_e op, uint16_t netkey_idx)
 251 {
 252         DBG("");
 253         return _bt_hal_mesh_network_subnet_execute(network_uuid,
 254                         op, netkey_idx);
 255 }
 256
 257 static bt_status_t mesh_network_appkey_operation(bt_uuid_t* network_uuid,
 258                         bt_mesh_key_op_e op, uint16_t netkey_idx,
 259                                 uint16_t appkey_idx)
 260 {
 261         DBG("");
 262         return _bt_hal_mesh_network_appkey_execute(network_uuid,
 263                         op, netkey_idx, appkey_idx);
 264 }
 265
 266 static bt_status_t mesh_auth_reply(bt_hal_mesh_auth_variant_e auth_type,
 267                 const char *auth_value)
 268 {
 269         DBG("");
 270         return _bt_hal_mesh_auth_reply(auth_type, auth_value);
 271 }
 272
 273 /* Remote Node operations */
 274 static bt_status_t mesh_send_configuration_message(bt_uuid_t *network,
 275                 uint16_t dest, bool is_dev_key, uint16_t netkey_idx,
 276                         uint8_t *buf, int len)
 277 {
 278         DBG("");
 279         return _bt_hal_mesh_send_configuration_message(network, dest,
 280                         is_dev_key, netkey_idx, buf, len);
 281 }
 282
 283 static bt_status_t mesh_key_configuration_message(bt_uuid_t *network,
 284                 uint16_t dest, bool is_netkey,
 285                         bool is_update, uint16_t key_idx,
 286                                 uint16_t netkey_idx)
 287 {
 288         DBG("");
 289         return _bt_hal_mesh_send_key_config_message(network, dest,
 290                 is_netkey, is_update,
 291                         key_idx, netkey_idx);
 292 }
 293
 294 static bt_status_t init(btmesh_callbacks_t *callbacks)
 295 {
 296         DBG("");
 297
 298         if (interface_ready())
 299                 return BT_STATUS_SUCCESS;
 300
 301         bt_hal_mesh_cbacks = callbacks;
 302         INFO("Register Mesh events callback function");
 303
 304         _bt_hal_mesh_register_dbus_handler_cb(__bt_hal_handle_mesh_events);
 305         _bt_hal_register_event_handler_cb(HAL_MESH, __bt_hal_handle_mesh_events);
 306
 307         if (!_bt_hal_mesh_stack_init())
 308                 return BT_STATUS_FAIL;
 309
 310         return BT_STATUS_SUCCESS;
 311 }
 312
 313 static void cleanup(void)
 314 {
 315         DBG("");
 316
 317         if (!interface_ready())
 318                 return;
 319
 320         _bt_hal_mesh_unregister_dbus_handler_cb();
 321         _bt_hal_unregister_event_handler_cb(HAL_MESH);
 322
 323         bt_hal_mesh_cbacks = NULL;
 324 }
 325
 326 static btmesh_interface_t mesh_if = {
 327         .size = sizeof(mesh_if),
 328         .init = init,
 329         .create = mesh_create_network,
 330         .scan = mesh_scan,
 331         .scan_cancel = mesh_scan_cancel,
 332         .capability = mesh_set_prov_caps,
 333         .provision = mesh_provision_device,
 334         .provision_data = mesh_send_provision_data,
 335         .auth_reply = mesh_auth_reply,
 336         .subnet_execute = mesh_network_subnet_operation,
 337         .appkey_execute = mesh_network_appkey_operation,
 338         .config_send = mesh_send_configuration_message,
 339         .key_send = mesh_key_configuration_message,
 340         .cleanup = cleanup
 341 };
 342
 343 btmesh_interface_t *bt_get_mesh_interface(void)
 344 {
 345         return &mesh_if;
 346 }