bt-api/bt-mesh.c

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * @author: Anupam Roy  <anupam.r@samsung.com>
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *              http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include "bluetooth-api.h"
  21 #include "bt-internal-types.h"
  22
  23 #include "bt-common.h"
  24 #include "bt-request-sender.h"
  25 #include "bt-event-handler.h"
  26
  27 #include "bluetooth-mesh-api.h"
  28
  29 #define BLUETOOTH_MESH_NETWORK_NAME_STRING_MAX 100
  30 #define BLUETOOTH_MESH_TOKEN_STRING_MAX 100
  31
  32 BT_EXPORT_API int bluetooth_mesh_init(mesh_cb_func_ptr cb,
  33                         void *user_data)
  34 {
  35         int ret;
  36
  37         if (cb == NULL) {
  38                 BT_ERR("callback is NULL");
  39                 return BLUETOOTH_ERROR_INVALID_PARAM;
  40         }
  41
  42         BT_INIT_PARAMS();
  43         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  44
  45         ret = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_INIT,
  46                 in_param1, in_param2, in_param3, in_param4, &out_param);
  47
  48         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  49
  50         if (ret != BLUETOOTH_ERROR_NONE &&
  51                         ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
  52                 BT_ERR("Fail to init the mesh in bt-service");
  53                 return ret;
  54         }
  55
  56         ret = _bt_init_event_handler();
  57
  58         if (ret != BLUETOOTH_ERROR_NONE &&
  59                         ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
  60                 BT_ERR("Fail to init the event handler");
  61                 return ret;
  62         }
  63
  64         _bt_set_user_data(BT_MESH, (void *)cb, user_data);
  65
  66         /* Register All events */
  67         ret = _bt_register_event(BT_MESH_EVENT, (void *)cb, user_data);
  68         if (ret != BLUETOOTH_ERROR_NONE &&
  69                         ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
  70                 _bt_deinit_event_handler();
  71                 return ret;
  72         }
  73
  74         BT_INFO("Mesh: Event registsred");
  75         return BLUETOOTH_ERROR_NONE;
  76 }
  77
  78 BT_EXPORT_API int bluetooth_mesh_deinit(void)
  79 {
  80         int ret;
  81
  82         _bt_unregister_event(BT_MESH_EVENT);
  83         _bt_set_user_data(BT_MESH, NULL, NULL);
  84
  85         BT_INIT_PARAMS();
  86         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  87
  88         ret = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_DEINIT,
  89                 in_param1, in_param2, in_param3, in_param4, &out_param);
  90
  91         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  92
  93         if (ret != BLUETOOTH_ERROR_NONE) {
  94                 BT_ERR("Fail to init the mesh in bt-service");
  95                 return ret;
  96         }
  97
  98         return BLUETOOTH_ERROR_NONE;
  99 }
 100
 101 BT_EXPORT_API int bluetooth_mesh_network_unload(bluetooth_mesh_network_t *network)
 102 {
 103         int result;
 104
 105         BT_CHECK_PARAMETER(network, return);
 106
 107         BT_INIT_PARAMS();
 108         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 109
 110         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 111
 112         BT_INFO("Mesh: Network Unload");
 113         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_UNLOAD,
 114                         in_param1, in_param2, in_param3, in_param4, &out_param);
 115         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 116
 117         return result;
 118 }
 119
 120 BT_EXPORT_API int bluetooth_mesh_network_destroy(bluetooth_mesh_network_t *network)
 121 {
 122         int result;
 123
 124         BT_CHECK_PARAMETER(network, return);
 125
 126         BT_INIT_PARAMS();
 127         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 128
 129         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 130
 131         BT_INFO("Mesh: Network Destroy");
 132         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_DESTROY,
 133                         in_param1, in_param2, in_param3, in_param4, &out_param);
 134         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 135
 136         return result;
 137 }
 138
 139 BT_EXPORT_API int bluetooth_mesh_node_reset(bluetooth_mesh_node_info_t *node)
 140 {
 141         int result;
 142
 143         BT_CHECK_PARAMETER(node, return);
 144
 145         BT_INIT_PARAMS();
 146         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 147
 148         g_array_append_vals(in_param1, node, sizeof(bluetooth_mesh_node_info_t));
 149
 150         BT_INFO("Mesh: Reset the Node");
 151         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NODE_RESET,
 152                         in_param1, in_param2, in_param3, in_param4, &out_param);
 153         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 154
 155         return result;
 156 }
 157
 158 BT_EXPORT_API int bluetooth_mesh_network_create(
 159         const char *net_name, bluetooth_mesh_node_t *node,
 160                 uint16_t total_models, bluetooth_mesh_model_t **models,
 161                         bluetooth_mesh_network_t *network)
 162 {
 163         int result;
 164         char network_name[BLUETOOTH_MESH_NETWORK_NAME_STRING_MAX+1];
 165
 166         BT_CHECK_PARAMETER(net_name, return);
 167         BT_CHECK_PARAMETER(node, return);
 168         BT_CHECK_PARAMETER(models, return);
 169
 170         BT_INIT_PARAMS();
 171         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 172
 173         g_array_append_vals(in_param1, node,  sizeof(bluetooth_mesh_node_t));
 174
 175         g_strlcpy(network_name, net_name, sizeof(network_name));
 176         g_array_append_vals(in_param2, network_name,
 177                         BLUETOOTH_MESH_NETWORK_NAME_STRING_MAX);
 178
 179         for (int i = 0; i < total_models; i++)
 180                 g_array_append_vals(in_param3, models[i],
 181                                 sizeof(bluetooth_mesh_model_t));
 182
 183         result = _bt_send_request(BT_BLUEZ_SERVICE,
 184                         BT_MESH_NETWORK_CREATE,
 185                                 in_param1, in_param2, in_param3,
 186                                         in_param4, &out_param);
 187
 188         if (result == BLUETOOTH_ERROR_NONE) {
 189                 *network = g_array_index(out_param,
 190                                 bluetooth_mesh_network_t, 0);
 191         }
 192
 193         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 194
 195         return result;
 196 }
 197
 198 BT_EXPORT_API int bluetooth_mesh_network_load(
 199                 const char *token,
 200                         bluetooth_mesh_network_t *network)
 201 {
 202         int result;
 203         char token_string[BLUETOOTH_MESH_TOKEN_STRING_MAX + 1];
 204
 205         BT_CHECK_PARAMETER(token, return);
 206         BT_CHECK_PARAMETER(network, return);
 207
 208         BT_INIT_PARAMS();
 209         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 210
 211         g_strlcpy(token_string, token, sizeof(token_string));
 212         g_array_append_vals(in_param1, token_string, BLUETOOTH_MESH_TOKEN_STRING_MAX);
 213
 214         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_LOAD,
 215                         in_param1, in_param2, in_param3, in_param4, &out_param);
 216
 217         if (result == BLUETOOTH_ERROR_NONE) {
 218                 *network = g_array_index(out_param,
 219                                 bluetooth_mesh_network_t, 0);
 220         }
 221
 222         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 223
 224         return result;
 225 }
 226
 227 BT_EXPORT_API int bluetooth_mesh_network_join(
 228                 bluetooth_mesh_node_t *node, uint16_t total_models,
 229                         bluetooth_mesh_model_t **models)
 230 {
 231         int result;
 232
 233         BT_CHECK_PARAMETER(node, return);
 234         BT_CHECK_PARAMETER(models, return);
 235
 236         BT_INIT_PARAMS();
 237         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 238
 239         g_array_append_vals(in_param1, node,  sizeof(bluetooth_mesh_node_t));
 240
 241         for (int i = 0; i < total_models; i++)
 242                 g_array_append_vals(in_param2, models[i],
 243                                 sizeof(bluetooth_mesh_model_t));
 244
 245         result = _bt_send_request(BT_BLUEZ_SERVICE,
 246                         BT_MESH_NETWORK_JOIN,
 247                                 in_param1, in_param2, in_param3,
 248                                         in_param4, &out_param);
 249         if (result == BLUETOOTH_ERROR_NONE) {
 250                 *node = g_array_index(out_param,
 251                                 bluetooth_mesh_node_t, 0);
 252         }
 253
 254         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 255
 256         return result;
 257 }
 258
 259 BT_EXPORT_API int bluetooth_mesh_cancel_join(
 260                 bluetooth_mesh_node_info_t *node)
 261 {
 262         int result;
 263
 264         BT_CHECK_PARAMETER(node, return);
 265
 266         BT_INIT_PARAMS();
 267         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 268         g_array_append_vals(in_param1, node,  sizeof(bluetooth_mesh_node_info_t));
 269
 270         BT_INFO("Mesh: Cancel Ongoing Join");
 271         BT_INFO("Mesh: Node UUID [%s]", node->net_uuid);
 272         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_CANCEL_JOIN,
 273                         in_param1, in_param2, in_param3, in_param4, &out_param);
 274         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 275
 276         return result;
 277 }
 278
 279 BT_EXPORT_API int bluetooth_mesh_network_scan(
 280                         bluetooth_mesh_network_t *network,
 281                                 bluetooth_mesh_scan_param_t *scan_param)
 282 {
 283         int result;
 284
 285         BT_CHECK_PARAMETER(network, return);
 286         BT_CHECK_PARAMETER(scan_param, return);
 287
 288         BT_INIT_PARAMS();
 289         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 290
 291         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 292
 293         g_array_append_vals(in_param2, scan_param, sizeof(bluetooth_mesh_scan_param_t));
 294
 295         BT_INFO("Mesh:Start Scan, time [%u]", scan_param->scan_time);
 296         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_SCAN,
 297                         in_param1, in_param2, in_param3, in_param4, &out_param);
 298         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 299
 300         return result;
 301 }
 302
 303 BT_EXPORT_API int bluetooth_mesh_network_cancel_scan(
 304                 bluetooth_mesh_network_t *network)
 305 {
 306         int result;
 307
 308         BT_CHECK_PARAMETER(network, return);
 309
 310         BT_INIT_PARAMS();
 311         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 312
 313         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 314
 315         BT_INFO("Mesh: Cancel Scan");
 316         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_CANCEL_SCAN,
 317                         in_param1, in_param2, in_param3, in_param4, &out_param);
 318         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 319
 320         return result;
 321 }
 322
 323 BT_EXPORT_API int bluetooth_mesh_network_set_capabilities(
 324         bluetooth_mesh_network_t *network,
 325                 bluetooth_mesh_provisioner_caps_t *caps)
 326 {
 327         int result;
 328
 329         BT_CHECK_PARAMETER(network, return);
 330         BT_CHECK_PARAMETER(caps, return);
 331
 332         BT_INIT_PARAMS();
 333         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 334
 335         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 336
 337         g_array_append_vals(in_param2, caps, sizeof(bluetooth_mesh_provisioner_caps_t));
 338
 339         BT_INFO("Mesh: Set Provisioner capabilities");
 340         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_SET_CAPABILITIES,
 341                         in_param1, in_param2, in_param3, in_param4, &out_param);
 342         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 343
 344         return result;
 345 }
 346
 347 BT_EXPORT_API int bluetooth_mesh_network_provision_device(
 348                 bluetooth_mesh_provisioning_request_t *req)
 349 {
 350         int result;
 351         bt_user_info_t *user_info;
 352
 353         BT_CHECK_PARAMETER(req, return);
 354
 355         user_info = _bt_get_user_data(BT_MESH);
 356         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 357
 358         BT_INIT_PARAMS();
 359         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 360
 361         g_array_append_vals(in_param1, req,
 362                         sizeof(bluetooth_mesh_provisioning_request_t));
 363
 364         BT_INFO("Mesh: Set Provision Device");
 365         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
 366                         BT_MESH_NETWORK_PROVISION_DEVICE,
 367                         in_param1, in_param2, in_param3, in_param4,
 368                         user_info->cb, user_info->user_data);
 369
 370         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 371
 372         return result;
 373 }
 374
 375 BT_EXPORT_API int bluetooth_mesh_authentication_reply(int auth_type,
 376                 const char *auth_val, gboolean reply)
 377 {
 378         int result;
 379
 380         char auth_string[BLUETOOTH_MESH_AUTH_VALUE_LENGTH_MAX];
 381
 382         BT_CHECK_PARAMETER(auth_val, return);
 383
 384         BT_INIT_PARAMS();
 385         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 386
 387         g_strlcpy(auth_string, auth_val,
 388                         sizeof(auth_string));
 389         g_array_append_vals(in_param1,
 390                         &auth_type, sizeof(int));
 391         g_array_append_vals(in_param2, auth_string,
 392                         BLUETOOTH_MESH_AUTH_VALUE_LENGTH_MAX);
 393         g_array_append_vals(in_param3, &reply, sizeof(gboolean));
 394
 395         BT_INFO("Mesh: Set Provisioner Authentication Reply");
 396         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_AUTHENTICATION_REPLY,
 397                         in_param1, in_param2, in_param3, in_param4, &out_param);
 398
 399         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 400
 401         return result;
 402 }
 403
 404 BT_EXPORT_API int bluetooth_mesh_network_set_name(
 405         bluetooth_mesh_network_t *network)
 406 {
 407         int result;
 408
 409         BT_CHECK_PARAMETER(network, return);
 410
 411         BT_INIT_PARAMS();
 412         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 413
 414         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 415
 416         BT_INFO("Mesh:Set Network Name");
 417         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_SET_NAME,
 418                         in_param1, in_param2, in_param3, in_param4, &out_param);
 419         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 420
 421         return result;
 422 }
 423
 424 BT_EXPORT_API int bluetooth_mesh_network_add_netkey(
 425                 bluetooth_mesh_network_t *network,
 426                         uint16_t *netkey_idx)
 427 {
 428         int result;
 429
 430         BT_CHECK_PARAMETER(network, return);
 431         BT_CHECK_PARAMETER(netkey_idx, return);
 432
 433         BT_INIT_PARAMS();
 434         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 435
 436         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 437
 438         BT_INFO("Mesh:Set Create Subnetwork key");
 439         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_ADD_NETKEY,
 440                         in_param1, in_param2, in_param3, in_param4, &out_param);
 441         if (result == BLUETOOTH_ERROR_NONE)
 442                 *netkey_idx = g_array_index(out_param, guint16, 0);
 443         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 444
 445         return result;
 446 }
 447
 448 BT_EXPORT_API int bluetooth_mesh_network_delete_netkey(
 449         bluetooth_mesh_network_t *network,
 450                 uint16_t netkey_idx)
 451 {
 452         int result;
 453
 454         BT_CHECK_PARAMETER(network, return);
 455
 456         BT_INIT_PARAMS();
 457         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 458
 459         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 460         g_array_append_vals(in_param2, &netkey_idx,  sizeof(guint16));
 461
 462         BT_INFO("Mesh: Delete Subnetwork key");
 463         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_DELETE_NETKEY,
 464                         in_param1, in_param2, in_param3, in_param4, &out_param);
 465         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 466
 467         return result;
 468 }
 469
 470 BT_EXPORT_API int bluetooth_mesh_network_update_netkey(
 471         bluetooth_mesh_network_t *network,
 472                 uint16_t netkey_idx)
 473 {
 474         int result;
 475
 476         BT_CHECK_PARAMETER(network, return);
 477
 478         BT_INIT_PARAMS();
 479         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 480
 481         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 482         g_array_append_vals(in_param2, &netkey_idx,  sizeof(guint16));
 483
 484         BT_INFO("Mesh: Update Subnetwork key");
 485         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_UPDATE_NETKEY,
 486                         in_param1, in_param2, in_param3, in_param4, &out_param);
 487         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 488
 489         return result;
 490 }
 491
 492 BT_EXPORT_API int bluetooth_mesh_network_add_appkey(
 493                 bluetooth_mesh_network_t *network,
 494                         uint16_t netkey_index,
 495                                 uint16_t *appkey_index)
 496 {
 497         int result;
 498
 499         BT_CHECK_PARAMETER(network, return);
 500         BT_CHECK_PARAMETER(appkey_index, return);
 501
 502         BT_INIT_PARAMS();
 503         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 504
 505         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 506         g_array_append_vals(in_param2, &netkey_index,  sizeof(guint16));
 507
 508         BT_INFO("Mesh: Create AppKey");
 509         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_ADD_APPKEY,
 510                         in_param1, in_param2, in_param3, in_param4, &out_param);
 511
 512         if (result == BLUETOOTH_ERROR_NONE)
 513                 *appkey_index = g_array_index(out_param, guint16, 0);
 514         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 515
 516         return result;
 517 }
 518
 519 BT_EXPORT_API int bluetooth_mesh_network_update_appkey(
 520                 bluetooth_mesh_network_t *network,
 521                         uint16_t netkey_index, uint16_t appkey_index)
 522 {
 523         int result;
 524
 525         BT_CHECK_PARAMETER(network, return);
 526
 527         BT_INIT_PARAMS();
 528         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 529
 530         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 531         g_array_append_vals(in_param2, &netkey_index,  sizeof(guint16));
 532         g_array_append_vals(in_param3, &appkey_index,  sizeof(guint16));
 533
 534         BT_INFO("Mesh:BTAPI: Update AppKey");
 535         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_UPDATE_APPKEY,
 536                         in_param1, in_param2, in_param3, in_param4, &out_param);
 537
 538         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 539
 540         return result;
 541 }
 542
 543 BT_EXPORT_API int bluetooth_mesh_network_delete_appkey(bluetooth_mesh_network_t *network,
 544                         uint16_t netkey_index, uint16_t appkey_index)
 545 {
 546         int result;
 547
 548         BT_CHECK_PARAMETER(network, return);
 549
 550         BT_INIT_PARAMS();
 551         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 552
 553         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 554         g_array_append_vals(in_param2, &netkey_index,  sizeof(guint16));
 555         g_array_append_vals(in_param3, &appkey_index,  sizeof(guint16));
 556
 557         BT_INFO("Mesh: Delete AppKey");
 558         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_DELETE_APPKEY,
 559                         in_param1, in_param2, in_param3, in_param4, &out_param);
 560
 561         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 562
 563         return result;
 564 }
 565
 566 BT_EXPORT_API int bluetooth_mesh_network_get_all_nodes(
 567                 bluetooth_mesh_network_t *network,
 568                         GPtrArray **nodes)
 569 {
 570         int result = BLUETOOTH_ERROR_NONE;
 571         guint size;
 572         int i;
 573         bluetooth_mesh_node_info_t *info;
 574
 575         BT_CHECK_PARAMETER(network, return);
 576         BT_CHECK_PARAMETER(nodes, return);
 577
 578         BT_INIT_PARAMS();
 579         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 580
 581         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 582
 583         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_NODES,
 584                         in_param1, in_param2, in_param3, in_param4, &out_param);
 585
 586         if (result == BLUETOOTH_ERROR_NONE) {
 587                 if (out_param == NULL) {
 588                         BT_ERR("Mesh: out_param is NULL");
 589                         result = BLUETOOTH_ERROR_INTERNAL;
 590                 } else {
 591                         size = (out_param->len) / sizeof(bluetooth_mesh_node_info_t);
 592
 593                         for (i = 0; i < size; i++) {
 594                                 bluetooth_mesh_node_info_t *data;
 595
 596                                 info = &g_array_index(out_param,
 597                                                 bluetooth_mesh_node_info_t, i);
 598
 599                                 data = g_memdup2(info, sizeof(bluetooth_mesh_node_info_t));
 600                                 g_ptr_array_add(*nodes, (gpointer)data);
 601                         }
 602                 }
 603         }
 604
 605         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 606
 607         return result;
 608 }
 609
 610 BT_EXPORT_API int bluetooth_mesh_element_get_all_models(
 611         bluetooth_mesh_network_t *network,
 612                 uint16_t node_addr, int elem_idx,
 613                         GPtrArray **models)
 614 {
 615         int result = BLUETOOTH_ERROR_NONE;
 616         guint size;
 617         int i;
 618
 619         BT_CHECK_PARAMETER(network, return);
 620         BT_CHECK_PARAMETER(models, return);
 621
 622         BT_INIT_PARAMS();
 623         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 624
 625         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 626         g_array_append_vals(in_param2, &node_addr,  sizeof(guint16));
 627         g_array_append_vals(in_param3, &elem_idx,  sizeof(int));
 628
 629         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_ELEMENT_GET_MODELS,
 630                         in_param1, in_param2, in_param3, in_param4, &out_param);
 631
 632         if (result == BLUETOOTH_ERROR_NONE) {
 633                 if (out_param == NULL) {
 634                         BT_ERR("Mesh: out_param is NULL");
 635                         result = BLUETOOTH_ERROR_INTERNAL;
 636                 } else {
 637                         size = (out_param->len) / sizeof(guint32);
 638                         BT_INFO("Mesh: Total Models found in Element [%d]", size);
 639
 640                         for (i = 0; i < size; i++) {
 641                                 uint32_t model_obj;
 642                                 uint32_t *model_ptr = NULL;
 643
 644                                 model_obj = g_array_index(out_param,
 645                                                 guint32, i);
 646
 647                                 model_ptr = g_memdup2(&model_obj, sizeof(guint32));
 648                                 g_ptr_array_add(*models, (gpointer)model_ptr);
 649                         }
 650                 }
 651         }
 652
 653         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 654
 655         return result;
 656 }
 657
 658 BT_EXPORT_API int bluetooth_mesh_node_browse_vendor_features(
 659                         bluetooth_mesh_node_features_t *req)
 660 {
 661         int result;
 662         bt_user_info_t *user_info;
 663
 664         BT_CHECK_PARAMETER(req, return);
 665
 666         user_info = _bt_get_user_data(BT_MESH);
 667         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 668
 669         BT_INIT_PARAMS();
 670         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 671
 672         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_features_t));
 673
 674         BT_INFO("Mesh: Browse Vendor features of Node");
 675         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_VENDOR_FEATURES,
 676                         in_param1, in_param2, in_param3, in_param4,
 677                         user_info->cb, user_info->user_data);
 678
 679         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 680
 681         return result;
 682 }
 683
 684 BT_EXPORT_API int bluetooth_mesh_browse_remote_node(
 685                         bluetooth_mesh_node_discover_t *req)
 686 {
 687         int result;
 688         bt_user_info_t *user_info;
 689
 690         BT_CHECK_PARAMETER(req, return);
 691
 692         user_info = _bt_get_user_data(BT_MESH);
 693         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 694
 695         BT_INIT_PARAMS();
 696         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 697
 698         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_discover_t));
 699
 700         BT_INFO("Mesh: Browse remote Node");
 701         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_BROWSE,
 702                         in_param1, in_param2, in_param3, in_param4,
 703                         user_info->cb, user_info->user_data);
 704
 705         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 706
 707         return result;
 708 }
 709
 710 BT_EXPORT_API int bluetooth_mesh_node_ttl_execute(
 711                         bluetooth_mesh_node_ttl_info_t *req)
 712 {
 713         int result;
 714         bt_user_info_t *user_info;
 715
 716         BT_CHECK_PARAMETER(req, return);
 717
 718         user_info = _bt_get_user_data(BT_MESH);
 719         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 720
 721         BT_INIT_PARAMS();
 722         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 723
 724         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_ttl_info_t));
 725
 726         BT_INFO("Mesh: Node TTL Execute");
 727         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_TTL_EXECUTE,
 728                         in_param1, in_param2, in_param3, in_param4,
 729                         user_info->cb, user_info->user_data);
 730
 731         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 732
 733         return result;
 734 }
 735
 736 BT_EXPORT_API int bluetooth_mesh_model_configure_appkey(
 737                         bluetooth_mesh_model_configure_t *req)
 738 {
 739         int result;
 740         bt_user_info_t *user_info;
 741
 742         BT_CHECK_PARAMETER(req, return);
 743
 744         user_info = _bt_get_user_data(BT_MESH);
 745         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 746
 747         BT_INIT_PARAMS();
 748         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 749
 750         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 751
 752         BT_INFO("Mesh: Node Model Configure AppKey");
 753         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_CONFIGURE_APPKEY,
 754                         in_param1, in_param2, in_param3, in_param4,
 755                         user_info->cb, user_info->user_data);
 756
 757         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 758
 759         return result;
 760 }
 761
 762 BT_EXPORT_API int bluetooth_mesh_model_send_msg(
 763                         bluetooth_mesh_model_msg_t *req)
 764 {
 765         int result;
 766         bt_user_info_t *user_info;
 767
 768         BT_CHECK_PARAMETER(req, return);
 769
 770         user_info = _bt_get_user_data(BT_MESH);
 771         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 772
 773         BT_INIT_PARAMS();
 774         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 775
 776         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_msg_t));
 777
 778         BT_INFO("Mesh: Node Model Send Msg");
 779         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_EXECUTE_MSG,
 780                         in_param1, in_param2, in_param3, in_param4,
 781                         user_info->cb, user_info->user_data);
 782
 783         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 784
 785         return result;
 786 }
 787
 788 BT_EXPORT_API int bluetooth_mesh_model_send_response(
 789                 bluetooth_mesh_model_msg_t *req)
 790 {
 791         int result;
 792         bt_user_info_t *user_info;
 793
 794         BT_CHECK_PARAMETER(req, return);
 795
 796         user_info = _bt_get_user_data(BT_MESH);
 797         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 798
 799         BT_INIT_PARAMS();
 800         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 801         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_msg_t));
 802
 803         BT_INFO("Mesh: Node Model Send Response");
 804         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_MODEL_RESPONSE_MSG,
 805                         in_param1, in_param2, in_param3, in_param4,
 806                                 &out_param);
 807
 808         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 809         return result;
 810 }
 811
 812 BT_EXPORT_API int bluetooth_mesh_node_configure_key(
 813                         bluetooth_mesh_key_configure_t *req)
 814 {
 815         int result;
 816         bt_user_info_t *user_info;
 817
 818         BT_CHECK_PARAMETER(req, return);
 819
 820         user_info = _bt_get_user_data(BT_MESH);
 821         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 822
 823         BT_INIT_PARAMS();
 824         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 825
 826         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_key_configure_t));
 827
 828         BT_INFO("Mesh:BTAPI: Node Key Configure");
 829         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_CONFIGURE_KEY,
 830                         in_param1, in_param2, in_param3, in_param4,
 831                         user_info->cb, user_info->user_data);
 832
 833         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 834
 835         return result;
 836 }
 837
 838 BT_EXPORT_API int bluetooth_mesh_network_get_all_groups(
 839                 bluetooth_mesh_network_t *network,
 840                         GPtrArray **groups)
 841 {
 842         int result = BLUETOOTH_ERROR_NONE;
 843         bluetooth_mesh_network_group_info_t *info;
 844         guint size;
 845         int i;
 846
 847         BT_CHECK_PARAMETER(network, return);
 848         BT_CHECK_PARAMETER(groups, return);
 849
 850         BT_INIT_PARAMS();
 851         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 852
 853         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 854
 855         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_GROUPS,
 856                         in_param1, in_param2, in_param3, in_param4, &out_param);
 857
 858         if (result == BLUETOOTH_ERROR_NONE) {
 859                 if (out_param == NULL) {
 860                         BT_ERR("Mesh: out_param is NULL");
 861                         result = BLUETOOTH_ERROR_INTERNAL;
 862                 } else {
 863                         size = (out_param->len) / sizeof(bluetooth_mesh_network_group_info_t);
 864
 865                         if (size == 0)
 866                                 BT_INFO("Mesh: No Groups created for the network");
 867
 868                         BT_INFO("Mesh: Total groups [%d]", size);
 869                         for (i = 0; i < size; i++) {
 870                                 bluetooth_mesh_network_group_info_t *grp_info = NULL;
 871
 872                                 info = &g_array_index(out_param,
 873                                         bluetooth_mesh_network_group_info_t, i);
 874                                 BT_INFO("Mesh: Group addr [0x%2.2x]", info->group_addr);
 875                                 BT_INFO("Mesh: Group is Virtual [%s]", info->is_virtual ? "YES" : "NO");
 876                                 BT_INFO("Mesh: Group net UUID[%s]", info->net_uuid);
 877                                 if (info->is_virtual)
 878                                         BT_INFO("Mesh: Virual Label UUID [%s]", info->label_uuid);
 879                                 grp_info = g_memdup2(info,
 880                                         sizeof(bluetooth_mesh_network_group_info_t));
 881                                 g_ptr_array_add(*groups, (gpointer)grp_info);
 882                         }
 883                 }
 884         }
 885
 886         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 887
 888         return result;
 889 }
 890
 891 BT_EXPORT_API int bluetooth_mesh_network_get_all_netkey(
 892                 bluetooth_mesh_network_t *network,
 893                         GPtrArray **netkeys)
 894 {
 895         int result = BLUETOOTH_ERROR_NONE;
 896         guint size;
 897         int i;
 898
 899         BT_CHECK_PARAMETER(network, return);
 900         BT_CHECK_PARAMETER(netkeys, return);
 901
 902         BT_INIT_PARAMS();
 903         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 904
 905         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 906
 907         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_NETKEYS,
 908                         in_param1, in_param2, in_param3, in_param4, &out_param);
 909
 910         if (result == BLUETOOTH_ERROR_NONE) {
 911                 if (out_param == NULL) {
 912                         BT_ERR("Mesh: out_param is NULL");
 913                         result = BLUETOOTH_ERROR_INTERNAL;
 914                 } else {
 915                         size = (out_param->len) / sizeof(guint16);
 916
 917                         if (size == 0) {
 918                                 BT_ERR("Mesh: No netkeys created for the network");
 919                                 result = BLUETOOTH_ERROR_NOT_FOUND;
 920                         }
 921
 922                         for (i = 0; i < size; i++) {
 923                                 uint16_t netkey_index;
 924                                 uint16_t *netkey_idx = NULL;
 925
 926                                 netkey_index = g_array_index(out_param,
 927                                                 guint16, i);
 928
 929                                 netkey_idx = g_memdup2(&netkey_index, sizeof(guint16));
 930                                 g_ptr_array_add(*netkeys, (gpointer)netkey_idx);
 931                         }
 932                 }
 933         }
 934
 935         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 936
 937         return result;
 938 }
 939
 940 BT_EXPORT_API int bluetooth_mesh_netkey_get_all_appkey(
 941                 bluetooth_mesh_network_t *network,
 942                         uint16_t netkey_idx,
 943                                 GPtrArray **appkeys)
 944 {
 945         int result = BLUETOOTH_ERROR_NONE;
 946         guint size;
 947         int i;
 948
 949         BT_CHECK_PARAMETER(network, return);
 950         BT_CHECK_PARAMETER(appkeys, return);
 951
 952         BT_INIT_PARAMS();
 953         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 954
 955         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 956         g_array_append_vals(in_param2, &netkey_idx,  sizeof(guint16));
 957
 958         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_APPKEYS,
 959                         in_param1, in_param2, in_param3, in_param4, &out_param);
 960
 961         if (result == BLUETOOTH_ERROR_NONE) {
 962                 if (out_param == NULL) {
 963                         BT_ERR("Mesh: out_param is NULL");
 964                         result = BLUETOOTH_ERROR_INTERNAL;
 965                 } else {
 966                         size = (out_param->len) / sizeof(guint16);
 967
 968                         if (size == 0)
 969                                 BT_ERR("Mesh: No Appkeys created for the NetKey in the network");
 970
 971                         for (i = 0; i < size; i++) {
 972                                 uint16_t appkey_index;
 973                                 uint16_t *appkey_idx = NULL;
 974
 975                                 appkey_index = g_array_index(out_param,
 976                                                 guint16, i);
 977
 978                                 appkey_idx = g_memdup2(&appkey_index, sizeof(guint16));
 979                                 g_ptr_array_add(*appkeys, (gpointer)appkey_idx);
 980                         }
 981                 }
 982         }
 983
 984         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 985
 986         return result;
 987 }
 988
 989 BT_EXPORT_API int bluetooth_mesh_node_get_all_netkeys(
 990                 bluetooth_mesh_node_discover_t *node,
 991                         GPtrArray **netkeys)
 992 {
 993         int result = BLUETOOTH_ERROR_NONE;
 994         guint size;
 995         int i;
 996
 997         BT_CHECK_PARAMETER(node, return);
 998         BT_CHECK_PARAMETER(netkeys, return);
 999
1000         BT_INIT_PARAMS();
1001         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1002
1003         g_array_append_vals(in_param1, node,  sizeof(bluetooth_mesh_node_discover_t));
1004
1005         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_NETKEYS,
1006                         in_param1, in_param2, in_param3, in_param4, &out_param);
1007
1008         if (result == BLUETOOTH_ERROR_NONE) {
1009                 if (out_param == NULL) {
1010                         BT_ERR("Mesh: out_param is NULL");
1011                         result = BLUETOOTH_ERROR_INTERNAL;
1012                 } else {
1013                         size = (out_param->len) / sizeof(guint16);
1014
1015                         for (i = 0; i < size; i++) {
1016                                 uint16_t netkey_index;
1017                                 uint16_t *netkey_idx = NULL;
1018
1019                                 netkey_index = g_array_index(out_param,
1020                                                 guint16, i);
1021
1022                                 netkey_idx = g_memdup2(&netkey_index, sizeof(guint16));
1023                                 g_ptr_array_add(*netkeys, (gpointer)netkey_idx);
1024                         }
1025                 }
1026         }
1027
1028         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1029
1030         return result;
1031 }
1032
1033 BT_EXPORT_API int bluetooth_mesh_node_get_all_appkeys(
1034         bluetooth_mesh_node_discover_t *req, GPtrArray **appkeys)
1035 {
1036         int result = BLUETOOTH_ERROR_NONE;
1037         guint size;
1038         int i;
1039
1040         BT_CHECK_PARAMETER(req, return);
1041         BT_CHECK_PARAMETER(appkeys, return);
1042
1043         BT_INIT_PARAMS();
1044         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1045
1046         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_discover_t));
1047
1048         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_APPKEYS,
1049                         in_param1, in_param2, in_param3, in_param4, &out_param);
1050
1051         if (result == BLUETOOTH_ERROR_NONE) {
1052                 if (out_param == NULL) {
1053                         BT_ERR("Mesh: out_param is NULL");
1054                         result = BLUETOOTH_ERROR_INTERNAL;
1055                 } else {
1056                         size = (out_param->len) / sizeof(guint16);
1057
1058                         for (i = 0; i < size; i++) {
1059                                 uint16_t appkey_index;
1060                                 uint16_t *appkey_idx = NULL;
1061
1062                                 appkey_index = g_array_index(out_param,
1063                                                 guint16, i);
1064
1065                                 appkey_idx = g_memdup2(&appkey_index, sizeof(guint16));
1066                                 g_ptr_array_add(*appkeys, (gpointer)appkey_idx);
1067                         }
1068                 }
1069         }
1070
1071         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1072
1073         return result;
1074 }
1075
1076 BT_EXPORT_API int bluetooth_mesh_model_get_all_appkeys(
1077                         bluetooth_mesh_model_configure_t *req)
1078 {
1079         int result = 0;
1080         bt_user_info_t *user_info;
1081
1082         BT_CHECK_PARAMETER(req, return);
1083
1084         user_info = _bt_get_user_data(BT_MESH);
1085         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1086
1087         BT_INIT_PARAMS();
1088         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1089
1090         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1091
1092         BT_INFO("Mesh:Node Model Get AppKey List ");
1093         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_APPKEY_LIST,
1094                         in_param1, in_param2, in_param3, in_param4,
1095                         user_info->cb, user_info->user_data);
1096
1097         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1098         return result;
1099 }
1100
1101 BT_EXPORT_API int bluetooth_mesh_model_set_publication(
1102                         bluetooth_mesh_model_configure_t *req)
1103 {
1104         int result = 0;
1105         bt_user_info_t *user_info;
1106
1107         BT_CHECK_PARAMETER(req, return);
1108
1109         user_info = _bt_get_user_data(BT_MESH);
1110         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1111
1112         BT_INIT_PARAMS();
1113         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1114
1115         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1116
1117         BT_INFO("Mesh: Model Set Publication");
1118         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_SET_PUBLICATION,
1119                         in_param1, in_param2, in_param3, in_param4,
1120                         user_info->cb, user_info->user_data);
1121
1122         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1123         return result;
1124 }
1125
1126 BT_EXPORT_API int bluetooth_mesh_model_get_publication(
1127                         bluetooth_mesh_model_configure_t *req)
1128 {
1129         int result = 0;
1130         bt_user_info_t *user_info;
1131
1132         BT_CHECK_PARAMETER(req, return);
1133
1134         user_info = _bt_get_user_data(BT_MESH);
1135         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1136
1137         BT_INIT_PARAMS();
1138         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1139
1140         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1141
1142         BT_INFO("Mesh:BTAPI:  Model Get Publication");
1143         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_PUBLICATION,
1144                         in_param1, in_param2, in_param3, in_param4,
1145                         user_info->cb, user_info->user_data);
1146
1147         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1148         return result;
1149 }
1150
1151 BT_EXPORT_API int bluetooth_mesh_model_get_subscriptopn_list(
1152                         bluetooth_mesh_model_configure_t *req)
1153 {
1154         int result = 0;
1155         bt_user_info_t *user_info;
1156
1157         BT_CHECK_PARAMETER(req, return);
1158
1159         user_info = _bt_get_user_data(BT_MESH);
1160         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1161
1162         BT_INIT_PARAMS();
1163         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1164
1165         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1166
1167         BT_INFO("Mesh:BTAPI:  Model Get Subscription List ");
1168         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_SUBSCRIPTION_LIST,
1169                         in_param1, in_param2, in_param3, in_param4,
1170                         user_info->cb, user_info->user_data);
1171
1172         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1173         return result;
1174 }
1175
1176 BT_EXPORT_API int bluetooth_mesh_network_remove_group(
1177                 bluetooth_mesh_network_t *network,
1178                         bluetooth_mesh_network_group_info_t *req)
1179 {
1180         int result;
1181
1182         BT_CHECK_PARAMETER(network, return);
1183         BT_CHECK_PARAMETER(req, return);
1184
1185         BT_INIT_PARAMS();
1186         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1187
1188         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
1189         g_array_append_vals(in_param2, req,  sizeof(bluetooth_mesh_network_group_info_t));
1190
1191         BT_INFO("Mesh: Remove Group Request");
1192         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_REMOVE_GROUP,
1193                         in_param1, in_param2, in_param3, in_param4, &out_param);
1194
1195         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1196
1197         return result;
1198 }
1199
1200 BT_EXPORT_API int bluetooth_mesh_network_create_group(
1201                 bluetooth_mesh_network_t *network, bool is_virtual,
1202                         uint16_t grp_addr, bluetooth_mesh_network_group_info_t *info)
1203 {
1204         int result;
1205
1206         BT_CHECK_PARAMETER(network, return);
1207         BT_CHECK_PARAMETER(info, return);
1208
1209         BT_INIT_PARAMS();
1210         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1211
1212         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
1213         g_array_append_vals(in_param2, &is_virtual,  sizeof(gboolean));
1214         g_array_append_vals(in_param3, &grp_addr,  sizeof(guint16));
1215
1216         BT_INFO("Mesh: Create Group Request");
1217         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_CREATE_GROUP,
1218                         in_param1, in_param2, in_param3, in_param4, &out_param);
1219
1220         if (result == BLUETOOTH_ERROR_NONE) {
1221                 *info = g_array_index(out_param,
1222                                 bluetooth_mesh_network_group_info_t, 0);
1223         }
1224         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1225
1226         return result;
1227 }
1228
1229 BT_EXPORT_API int bluetooth_mesh_model_configure_group_sub(
1230                         bluetooth_mesh_model_configure_t *req)
1231 {
1232         int result = 0;
1233         bt_user_info_t *user_info;
1234
1235         BT_CHECK_PARAMETER(req, return);
1236
1237         user_info = _bt_get_user_data(BT_MESH);
1238         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1239
1240         BT_INIT_PARAMS();
1241         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1242
1243         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1244
1245         BT_INFO("Mesh:Model Group Subscription Request");
1246         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_CONFIG_GROUP_SUB,
1247                         in_param1, in_param2, in_param3, in_param4,
1248                         user_info->cb, user_info->user_data);
1249
1250         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1251         return result;
1252 }
1253
1254 BT_EXPORT_API int bluetooth_mesh_model_configure_virtual_group_sub(
1255                         bluetooth_mesh_model_configure_t *req)
1256 {
1257         int result = 0;
1258         bt_user_info_t *user_info;
1259
1260         BT_CHECK_PARAMETER(req, return);
1261
1262         user_info = _bt_get_user_data(BT_MESH);
1263         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1264
1265         BT_INIT_PARAMS();
1266         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1267
1268         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1269
1270         BT_INFO("Mesh: Model Virtual Group Subscription Request");
1271         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
1272                         BT_MESH_MODEL_CONFIG_VIRTUAL_GROUP_SUB,
1273                         in_param1, in_param2, in_param3, in_param4,
1274                         user_info->cb, user_info->user_data);
1275
1276         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1277         return result;
1278 }