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                         ev->is_prov,
  51                                 (bt_mesh_token_t*)&ev->token,
  52                                         (bt_uuid_t*)&ev->uuid);
  53 }
  54
  55 static void __bt_hal_mesh_network_destroyed(void *buf, uint16_t len)
  56 {
  57         struct hal_ev_mesh_network_destroyed *ev = buf;
  58         if (bt_hal_mesh_cbacks->network_destroyed_cb)
  59                 bt_hal_mesh_cbacks->network_destroyed_cb(ev->status,
  60                         (bt_mesh_token_t*)&ev->token,
  61                                 (bt_uuid_t*)&ev->uuid);
  62 }
  63
  64 static void __bt_hal_mesh_network_proxy_added(void *buf, uint16_t len)
  65 {
  66         struct hal_ev_mesh_network_proxy_added *ev = buf;
  67         if (bt_hal_mesh_cbacks->network_proxy_added_cb)
  68                 bt_hal_mesh_cbacks->network_proxy_added_cb(ev->status);
  69 }
  70
  71 static void __bt_hal_handle_network_scan_result(void *buf, uint16_t len)
  72 {
  73         struct hal_ev_mesh_scan_result *ev = buf;
  74         bt_mesh_scan_result_t result;
  75         memset(&result, 0x00, sizeof(bt_mesh_scan_result_t));
  76
  77         memcpy(result.dev_uuid.uu, ev->dev_uuid, 16);
  78         memcpy(&result.oob_info, ev->oob_info, 2);
  79         memcpy(&result.uri_hash, ev->uri_hash, 4);
  80         result.rssi = ev->rssi;
  81
  82         if (bt_hal_mesh_cbacks->scan_result_cb)
  83                 bt_hal_mesh_cbacks->scan_result_cb(ev->status,
  84                         (bt_uuid_t*)&ev->net_uuid,
  85                                 (bt_mesh_scan_result_t*)&result);
  86 }
  87
  88 static void __bt_hal_handle_network_scan_status(void *buf, uint16_t len)
  89 {
  90         struct hal_ev_mesh_scan_state_changed *ev = buf;
  91
  92         if (bt_hal_mesh_cbacks->scan_status_cb)
  93                 bt_hal_mesh_cbacks->scan_status_cb(ev->state, ev->status,
  94                         (bt_uuid_t*)&ev->net_uuid);
  95 }
  96
  97 static void __bt_hal_handle_network_provisioning_status(void *buf, uint16_t len)
  98 {
  99         struct hal_ev_mesh_provision_status *ev = buf;
 100
 101         INFO("Mesh: Send provstatus callback");
 102         if (bt_hal_mesh_cbacks->provisioning_status_cb)
 103                 bt_hal_mesh_cbacks->provisioning_status_cb(ev->status,
 104                                 (bt_uuid_t*)&ev->net_uuid,
 105                                         (bt_uuid_t*)&ev->dev_uuid);
 106         INFO("Mesh: Done Sending  provstatus callback");
 107 }
 108
 109 static void __bt_hal_handle_network_provisioning_finished(void *buf, uint16_t len)
 110 {
 111         struct hal_ev_mesh_provision_finished *ev = buf;
 112
 113         if (bt_hal_mesh_cbacks->provisioning_finished_cb)
 114                 bt_hal_mesh_cbacks->provisioning_finished_cb(ev->status, ev->reason,
 115                                 (bt_uuid_t*)&ev->net_uuid, (bt_uuid_t*)&ev->dev_uuid,
 116                                         ev->unicast, ev->count);
 117 }
 118
 119 static void __bt_hal_handle_network_provisioning_data_requested(void *buf,
 120                 uint16_t len)
 121 {
 122         struct hal_ev_mesh_provision_data_request *ev = buf;
 123
 124         if (bt_hal_mesh_cbacks->provisioning_data_requested_cb)
 125                 bt_hal_mesh_cbacks->provisioning_data_requested_cb(
 126                         (bt_uuid_t*)&ev->net_uuid, ev->count);
 127 }
 128
 129 static void __bt_hal_handle_authentication_requested(void *buf, uint16_t len)
 130 {
 131         struct hal_ev_mesh_authentication_request *ev = buf;
 132
 133         if (bt_hal_mesh_cbacks->authentication_requested_cb)
 134                 bt_hal_mesh_cbacks->authentication_requested_cb(
 135                         (bt_uuid_t*)&ev->net_uuid, ev->auth_type, ev->auth_value);
 136 }
 137
 138 static void __bt_hal_handle_netkey_execute_event(void *buf, uint16_t len)
 139 {
 140         struct hal_ev_mesh_netkey_execute_event *ev = buf;
 141
 142         if (bt_hal_mesh_cbacks->netkey_execute_cb)
 143                 bt_hal_mesh_cbacks->netkey_execute_cb(ev->status,
 144                         (bt_uuid_t*)&ev->net_uuid,
 145                                 ev->key_event, ev->key_idx);
 146 }
 147
 148 static void __bt_hal_handle_appkey_execute_event(void *buf, uint16_t len)
 149 {
 150         struct hal_ev_mesh_appkey_execute_event *ev = buf;
 151
 152         if (bt_hal_mesh_cbacks->appkey_execute_cb)
 153                 bt_hal_mesh_cbacks->appkey_execute_cb(ev->status,
 154                         (bt_uuid_t*)&ev->net_uuid, ev->key_event,
 155                                 ev->net_idx, ev->app_idx);
 156 }
 157
 158 static void __bt_hal_handle_devkey_message_received_event(void *buf, uint16_t len)
 159 {
 160         struct hal_ev_mesh_devkey_message_event *ev = buf;
 161
 162         if (bt_hal_mesh_cbacks->devkey_msg_cb)
 163                 bt_hal_mesh_cbacks->devkey_msg_cb((bt_uuid_t*)&ev->net_uuid,
 164                         ev->source_addr,
 165                                 ev->is_remote_devkey, ev->netkey_idx,
 166                                         ev->data_len, ev->data);
 167 }
 168
 169 static void __bt_hal_handle_message_received_event(void *buf, uint16_t len)
 170 {
 171         struct hal_ev_mesh_message_event *ev = buf;
 172
 173         if (bt_hal_mesh_cbacks->msg_cb)
 174                 bt_hal_mesh_cbacks->msg_cb((bt_uuid_t*)&ev->net_uuid,
 175                         ev->is_prov, ev->source_addr,
 176                                 ev->dest_addr, ev->key_idx,
 177                                         ev->data_len, ev->data);
 178 }
 179
 180 static void __bt_hal_handle_mesh_events(int message, void *buf, uint16_t len)
 181 {
 182         DBG("+");
 183
 184         if (!interface_ready())
 185                 return;
 186
 187         switch (message) {
 188         case HAL_EV_MESH_NETWORK_PROXY_ADDED:
 189                 DBG("Mesh Event: HAL_EV_MESH_NETWORK_PROXY_ADDED");
 190                 __bt_hal_mesh_network_proxy_added(buf, len);
 191                 break;
 192         case HAL_EV_MESH_NETWORK_ATTACHED:
 193                 DBG("Mesh Event: HAL_EV_MESH_NETWORK_ATTACHED");
 194                 __bt_hal_mesh_network_attached(buf, len);
 195                 break;
 196         case HAL_EV_MESH_NETWORK_DESTROYED:
 197                 DBG("Mesh Event: HAL_EV_MESH_NETWORK_DESTROYED");
 198                 __bt_hal_mesh_network_destroyed(buf, len);
 199                 break;
 200         case HAL_EV_MESH_SCAN_STATE_CHANGED:
 201                 DBG("Mesh Event: HAL_EV_MESH_SCAN_STATE_CHANGED");
 202                 __bt_hal_handle_network_scan_status(buf, len);
 203                 break;
 204         case HAL_EV_MESH_SCAN_RESULT:
 205                 DBG("Mesh Event: HAL_EV_MESH_SCAN_RESULT");
 206                 __bt_hal_handle_network_scan_result(buf, len);
 207                 break;
 208         case HAL_EV_MESH_PROVISIONING_STATUS:
 209                 DBG("Mesh Event: HAL_EV_MESH_PROVISIONING_STATUS");
 210                 __bt_hal_handle_network_provisioning_status(buf, len);
 211                 break;
 212         case HAL_EV_MESH_PROVISIONING_FINISHED:
 213                 DBG("Mesh Event: HAL_EV_MESH_PROVISIONING_FINISHED");
 214                 __bt_hal_handle_network_provisioning_finished(buf, len);
 215                 break;
 216         case HAL_EV_MESH_PROVISIONING_DATA_REQUEST:
 217                 DBG("Mesh Event: HAL_EV_MESH_PROVISIONING_DATA_REQUEST");
 218                 __bt_hal_handle_network_provisioning_data_requested(buf, len);
 219                 break;
 220         case HAL_EV_MESH_AUTHENTICATION_REQUEST:
 221                 DBG("Mesh Event: HAL_EV_MESH_AUTHENTICATION_REQUEST");
 222                 __bt_hal_handle_authentication_requested(buf, len);
 223                 break;
 224         case HAL_EV_MESH_NETKEY_EXECUTE_EVENT:
 225                 DBG("Mesh Event: HAL_EV_MESH_NETKEY_EXECUTE_EVENT");
 226                 __bt_hal_handle_netkey_execute_event(buf, len);
 227                 break;
 228         case HAL_EV_MESH_APPKEY_EXECUTE_EVENT:
 229                 DBG("Mesh Event: HAL_EV_MESH_APPKEY_EXECUTE_EVENT");
 230                 __bt_hal_handle_appkey_execute_event(buf, len);
 231                 break;
 232         case HAL_EV_MESH_DEVKEY_MESSAGE_EVENT:
 233                 DBG("Mesh Event: HAL_EV_MESH_DEVKEY_MESSAGE_EVENT");
 234                 __bt_hal_handle_devkey_message_received_event(buf, len);
 235                 break;
 236         case HAL_EV_MESH_MESSAGE_EVENT:
 237                 DBG("Mesh Event: HAL_EV_MESH_MESSAGE_EVENT");
 238                 __bt_hal_handle_message_received_event(buf, len);
 239                 break;
 240         default:
 241                 DBG("Mesh Event Currently not handled!!");
 242                 break;
 243         }
 244
 245         DBG("-");
 246 }
 247
 248 static bt_status_t mesh_create_network(bt_hal_mesh_node_t *node,
 249                 GSList *models, bool is_prov)
 250 {
 251         DBG("");
 252         return _bt_hal_mesh_create_network(node, models, is_prov);
 253 }
 254
 255 static bt_status_t mesh_release_network(bt_uuid_t *network)
 256 {
 257         DBG("");
 258         return _bt_hal_mesh_network_release(network);
 259 }
 260
 261 static bt_status_t mesh_destroy_network(bt_uuid_t *network)
 262 {
 263         DBG("");
 264         return _bt_hal_mesh_network_destroy(network);
 265 }
 266
 267 static bt_status_t mesh_join_network(bt_hal_mesh_node_t *node,
 268                 GSList *models)
 269 {
 270         DBG("");
 271         return _bt_hal_mesh_join_network(node, models);
 272 }
 273
 274 static bt_status_t mesh_join_cancel(bt_uuid_t *node_uuid)
 275 {
 276         DBG("");
 277         return _bt_hal_mesh_join_cancel(node_uuid);
 278 }
 279
 280 static bt_status_t mesh_delete_node(bt_uuid_t *network, uint16_t unicast,
 281                         uint16_t num_elements)
 282 {
 283         DBG("");
 284         return _bt_hal_mesh_node_delete(network, unicast, num_elements);
 285 }
 286
 287 static bt_status_t mesh_scan(bt_uuid_t *network, bt_hal_mesh_scan_param_t *param)
 288 {
 289         DBG("");
 290         return _bt_hal_mesh_network_scan(network, param);
 291 }
 292
 293 static bt_status_t mesh_scan_cancel(bt_uuid_t *network)
 294 {
 295         DBG("");
 296         return _bt_hal_mesh_network_scan_cancel(network);
 297 }
 298
 299 static bt_status_t mesh_set_prov_caps(bt_uuid_t *network,
 300                 bt_hal_mesh_prov_caps_t *caps)
 301 {
 302         DBG("");
 303         return _bt_hal_mesh_network_set_caps(network, caps);
 304 }
 305
 306 static bt_status_t mesh_provision_device(bt_uuid_t *network,
 307                 bt_uuid_t *dev_uuid)
 308 {
 309         DBG("");
 310         return _bt_hal_mesh_provision_device(network, dev_uuid);
 311 }
 312
 313 static bt_status_t mesh_send_provision_data(bt_uuid_t* network_uuid,
 314                 uint16_t netkey_idx, uint16_t unicast)
 315 {
 316         DBG("");
 317         return _bt_hal_mesh_send_provision_data(network_uuid,
 318                         netkey_idx, unicast);
 319 }
 320
 321 static bt_status_t mesh_network_subnet_operation(bt_uuid_t* network_uuid,
 322                         bt_mesh_key_op_e op, uint16_t netkey_idx)
 323 {
 324         DBG("");
 325         return _bt_hal_mesh_network_subnet_execute(network_uuid,
 326                         op, netkey_idx);
 327 }
 328
 329 static bt_status_t mesh_network_appkey_operation(bt_uuid_t* network_uuid,
 330                         bt_mesh_key_op_e op, uint16_t netkey_idx,
 331                                 uint16_t appkey_idx)
 332 {
 333         DBG("");
 334         return _bt_hal_mesh_network_appkey_execute(network_uuid,
 335                         op, netkey_idx, appkey_idx);
 336 }
 337
 338 static bt_status_t mesh_auth_reply(bt_hal_mesh_auth_variant_e auth_type,
 339                 const char *auth_value)
 340 {
 341         DBG("");
 342         return _bt_hal_mesh_auth_reply(auth_type, auth_value);
 343 }
 344
 345 /* Remote Node operations */
 346 static bt_status_t mesh_send_configuration_message(bt_uuid_t *network,
 347                 uint16_t dest, bool is_dev_key, uint16_t netkey_idx,
 348                         uint8_t *buf, int len)
 349 {
 350         DBG("");
 351         return _bt_hal_mesh_send_configuration_message(network, dest,
 352                         is_dev_key, netkey_idx, buf, len);
 353 }
 354
 355 static bt_status_t mesh_key_configuration_message(bt_uuid_t *network,
 356                 uint16_t dest, bool is_netkey,
 357                         bool is_update, uint16_t key_idx,
 358                                 uint16_t netkey_idx)
 359 {
 360         DBG("");
 361         return _bt_hal_mesh_send_key_config_message(network, dest,
 362                 is_netkey, is_update,
 363                         key_idx, netkey_idx);
 364 }
 365
 366 static bt_status_t mesh_model_execute_message(bt_uuid_t *network,
 367                 uint16_t dest, uint16_t appkey_idx, uint8_t *buf,
 368                 int len)
 369 {
 370         DBG("");
 371         return _bt_hal_mesh_model_execute_message(network, dest,
 372                         appkey_idx, buf, len);
 373 }
 374
 375 static bt_status_t init(btmesh_callbacks_t *callbacks)
 376 {
 377         DBG("");
 378
 379         if (interface_ready())
 380                 return BT_STATUS_SUCCESS;
 381
 382         bt_hal_mesh_cbacks = callbacks;
 383         INFO("Register Mesh events callback function");
 384
 385         _bt_hal_mesh_register_dbus_handler_cb(__bt_hal_handle_mesh_events);
 386         _bt_hal_register_event_handler_cb(HAL_MESH, __bt_hal_handle_mesh_events);
 387
 388         if (!_bt_hal_mesh_stack_init())
 389                 return BT_STATUS_FAIL;
 390
 391         return BT_STATUS_SUCCESS;
 392 }
 393
 394 static void cleanup(void)
 395 {
 396         DBG("");
 397
 398         if (!interface_ready())
 399                 return;
 400
 401         _bt_hal_mesh_unregister_dbus_handler_cb();
 402         _bt_hal_unregister_event_handler_cb(HAL_MESH);
 403
 404         _bt_hal_mesh_stack_deinit();
 405
 406         bt_hal_mesh_cbacks = NULL;
 407 }
 408
 409 static btmesh_interface_t mesh_if = {
 410         .size = sizeof(mesh_if),
 411         .init = init,
 412         .create = mesh_create_network,
 413         .destroy = mesh_destroy_network,
 414         .join = mesh_join_network,
 415         .cancel = mesh_join_cancel,
 416         .release = mesh_release_network,
 417         .delete_node = mesh_delete_node,
 418         .scan = mesh_scan,
 419         .scan_cancel = mesh_scan_cancel,
 420         .capability = mesh_set_prov_caps,
 421         .provision = mesh_provision_device,
 422         .provision_data = mesh_send_provision_data,
 423         .auth_reply = mesh_auth_reply,
 424         .subnet_execute = mesh_network_subnet_operation,
 425         .appkey_execute = mesh_network_appkey_operation,
 426         .config_send = mesh_send_configuration_message,
 427         .key_send = mesh_key_configuration_message,
 428         .msg_execute = mesh_model_execute_message,
 429         .cleanup = cleanup
 430 };
 431
 432 btmesh_interface_t *bt_get_mesh_interface(void)
 433 {
 434         return &mesh_if;
 435 }