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_message_received_event(void *buf, uint16_t len)
 153 {
 154         struct hal_ev_mesh_message_event *ev = buf;
 155
 156         if (bt_hal_mesh_cbacks->msg_cb)
 157                 bt_hal_mesh_cbacks->msg_cb((bt_uuid_t*)&ev->net_uuid,
 158                         ev->source_addr,
 159                                 ev->dest_addr, ev->key_idx,
 160                                         ev->data_len, ev->data);
 161 }
 162
 163 static void __bt_hal_handle_mesh_events(int message, void *buf, uint16_t len)
 164 {
 165         DBG("+");
 166
 167         if (!interface_ready())
 168                 return;
 169
 170         switch (message) {
 171         case HAL_EV_MESH_NETWORK_ATTACHED:
 172                 DBG("Mesh Event: HAL_EV_MESH_NETWORK_ATTACHED");
 173                 __bt_hal_mesh_network_attached(buf, len);
 174                 break;
 175         case HAL_EV_MESH_SCAN_STATE_CHANGED:
 176                 DBG("Mesh Event: HAL_EV_MESH_SCAN_STATE_CHANGED");
 177                 __bt_hal_handle_network_scan_status(buf, len);
 178                 break;
 179         case HAL_EV_MESH_SCAN_RESULT:
 180                 DBG("Mesh Event: HAL_EV_MESH_SCAN_RESULT");
 181                 __bt_hal_handle_network_scan_result(buf, len);
 182                 break;
 183         case HAL_EV_MESH_PROVISIONING_STATUS:
 184                 DBG("Mesh Event: HAL_EV_MESH_PROVISIONING_STATUS");
 185                 __bt_hal_handle_network_provisioning_status(buf, len);
 186                 break;
 187         case HAL_EV_MESH_PROVISIONING_FINISHED:
 188                 DBG("Mesh Event: HAL_EV_MESH_PROVISIONING_FINISHED");
 189                 __bt_hal_handle_network_provisioning_finished(buf, len);
 190                 break;
 191         case HAL_EV_MESH_PROVISIONING_DATA_REQUEST:
 192                 DBG("Mesh Event: HAL_EV_MESH_PROVISIONING_DATA_REQUEST");
 193                 __bt_hal_handle_network_provisioning_data_requested(buf, len);
 194                 break;
 195         case HAL_EV_MESH_AUTHENTICATION_REQUEST:
 196                 DBG("Mesh Event: HAL_EV_MESH_AUTHENTICATION_REQUEST");
 197                 __bt_hal_handle_authentication_requested(buf, len);
 198                 break;
 199         case HAL_EV_MESH_NETKEY_EXECUTE_EVENT:
 200                 DBG("Mesh Event: HAL_EV_MESH_NETKEY_EXECUTE_EVENT");
 201                 __bt_hal_handle_netkey_execute_event(buf, len);
 202                 break;
 203         case HAL_EV_MESH_APPKEY_EXECUTE_EVENT:
 204                 DBG("Mesh Event: HAL_EV_MESH_APPKEY_EXECUTE_EVENT");
 205                 __bt_hal_handle_appkey_execute_event(buf, len);
 206                 break;
 207         case HAL_EV_MESH_DEVKEY_MESSAGE_EVENT:
 208                 DBG("Mesh Event: HAL_EV_MESH_DEVKEY_MESSAGE_EVENT");
 209                 __bt_hal_handle_devkey_message_received_event(buf, len);
 210                 break;
 211         case HAL_EV_MESH_MESSAGE_EVENT:
 212                 DBG("Mesh Event: HAL_EV_MESH_MESSAGE_EVENT");
 213                 __bt_hal_handle_message_received_event(buf, len);
 214                 break;
 215         default:
 216                 DBG("Mesh Event Currently not handled!!");
 217                 break;
 218         }
 219
 220         DBG("-");
 221 }
 222
 223 static bt_status_t mesh_create_network(bt_hal_mesh_node_t *node,
 224                 GSList *models, bool is_prov)
 225 {
 226         DBG("");
 227         return _bt_hal_mesh_create_network(node, models, is_prov);
 228 }
 229
 230 static bt_status_t mesh_scan(bt_uuid_t *network, bt_hal_mesh_scan_param_t *param)
 231 {
 232         DBG("");
 233         return _bt_hal_mesh_network_scan(network, param);
 234 }
 235
 236 static bt_status_t mesh_scan_cancel(bt_uuid_t *network)
 237 {
 238         DBG("");
 239         return _bt_hal_mesh_network_scan_cancel(network);
 240 }
 241
 242 static bt_status_t mesh_set_prov_caps(bt_uuid_t *network,
 243                 bt_hal_mesh_prov_caps_t *caps)
 244 {
 245         DBG("");
 246         return _bt_hal_mesh_network_set_caps(network, caps);
 247 }
 248
 249 static bt_status_t mesh_provision_device(bt_uuid_t *network,
 250                 bt_uuid_t *dev_uuid)
 251 {
 252         DBG("");
 253         return _bt_hal_mesh_provision_device(network, dev_uuid);
 254 }
 255
 256 static bt_status_t mesh_send_provision_data(bt_uuid_t* network_uuid,
 257                 uint16_t netkey_idx, uint16_t unicast)
 258 {
 259         DBG("");
 260         return _bt_hal_mesh_send_provision_data(network_uuid,
 261                         netkey_idx, unicast);
 262 }
 263
 264 static bt_status_t mesh_network_subnet_operation(bt_uuid_t* network_uuid,
 265                         bt_mesh_key_op_e op, uint16_t netkey_idx)
 266 {
 267         DBG("");
 268         return _bt_hal_mesh_network_subnet_execute(network_uuid,
 269                         op, netkey_idx);
 270 }
 271
 272 static bt_status_t mesh_network_appkey_operation(bt_uuid_t* network_uuid,
 273                         bt_mesh_key_op_e op, uint16_t netkey_idx,
 274                                 uint16_t appkey_idx)
 275 {
 276         DBG("");
 277         return _bt_hal_mesh_network_appkey_execute(network_uuid,
 278                         op, netkey_idx, appkey_idx);
 279 }
 280
 281 static bt_status_t mesh_auth_reply(bt_hal_mesh_auth_variant_e auth_type,
 282                 const char *auth_value)
 283 {
 284         DBG("");
 285         return _bt_hal_mesh_auth_reply(auth_type, auth_value);
 286 }
 287
 288 /* Remote Node operations */
 289 static bt_status_t mesh_send_configuration_message(bt_uuid_t *network,
 290                 uint16_t dest, bool is_dev_key, uint16_t netkey_idx,
 291                         uint8_t *buf, int len)
 292 {
 293         DBG("");
 294         return _bt_hal_mesh_send_configuration_message(network, dest,
 295                         is_dev_key, netkey_idx, buf, len);
 296 }
 297
 298 static bt_status_t mesh_key_configuration_message(bt_uuid_t *network,
 299                 uint16_t dest, bool is_netkey,
 300                         bool is_update, uint16_t key_idx,
 301                                 uint16_t netkey_idx)
 302 {
 303         DBG("");
 304         return _bt_hal_mesh_send_key_config_message(network, dest,
 305                 is_netkey, is_update,
 306                         key_idx, netkey_idx);
 307 }
 308
 309 static bt_status_t mesh_model_execute_message(bt_uuid_t *network,
 310                 uint16_t dest, uint16_t appkey_idx, uint8_t *buf,
 311                 int len)
 312 {
 313         DBG("");
 314         return _bt_hal_mesh_model_execute_message(network, dest,
 315                         appkey_idx, buf, len);
 316 }
 317
 318 static bt_status_t init(btmesh_callbacks_t *callbacks)
 319 {
 320         DBG("");
 321
 322         if (interface_ready())
 323                 return BT_STATUS_SUCCESS;
 324
 325         bt_hal_mesh_cbacks = callbacks;
 326         INFO("Register Mesh events callback function");
 327
 328         _bt_hal_mesh_register_dbus_handler_cb(__bt_hal_handle_mesh_events);
 329         _bt_hal_register_event_handler_cb(HAL_MESH, __bt_hal_handle_mesh_events);
 330
 331         if (!_bt_hal_mesh_stack_init())
 332                 return BT_STATUS_FAIL;
 333
 334         return BT_STATUS_SUCCESS;
 335 }
 336
 337 static void cleanup(void)
 338 {
 339         DBG("");
 340
 341         if (!interface_ready())
 342                 return;
 343
 344         _bt_hal_mesh_unregister_dbus_handler_cb();
 345         _bt_hal_unregister_event_handler_cb(HAL_MESH);
 346
 347         _bt_hal_mesh_stack_deinit();
 348
 349         bt_hal_mesh_cbacks = NULL;
 350 }
 351
 352 static btmesh_interface_t mesh_if = {
 353         .size = sizeof(mesh_if),
 354         .init = init,
 355         .create = mesh_create_network,
 356         .scan = mesh_scan,
 357         .scan_cancel = mesh_scan_cancel,
 358         .capability = mesh_set_prov_caps,
 359         .provision = mesh_provision_device,
 360         .provision_data = mesh_send_provision_data,
 361         .auth_reply = mesh_auth_reply,
 362         .subnet_execute = mesh_network_subnet_operation,
 363         .appkey_execute = mesh_network_appkey_operation,
 364         .config_send = mesh_send_configuration_message,
 365         .key_send = mesh_key_configuration_message,
 366         .msg_execute = mesh_model_execute_message,
 367         .cleanup = cleanup
 368 };
 369
 370 btmesh_interface_t *bt_get_mesh_interface(void)
 371 {
 372         return &mesh_if;
 373 }