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_memdup(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_memdup(&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_node_configure_key(
 789                         bluetooth_mesh_key_configure_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
 802         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_key_configure_t));
 803
 804         BT_INFO("Mesh:BTAPI: Node Key Configure");
 805         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_CONFIGURE_KEY,
 806                         in_param1, in_param2, in_param3, in_param4,
 807                         user_info->cb, user_info->user_data);
 808
 809         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 810
 811         return result;
 812 }
 813
 814 BT_EXPORT_API int bluetooth_mesh_network_get_all_groups(
 815                 bluetooth_mesh_network_t *network,
 816                         GPtrArray **groups)
 817 {
 818         int result = BLUETOOTH_ERROR_NONE;
 819         bluetooth_mesh_network_group_info_t *info;
 820         guint size;
 821         int i;
 822
 823         BT_CHECK_PARAMETER(network, return);
 824         BT_CHECK_PARAMETER(groups, return);
 825
 826         BT_INIT_PARAMS();
 827         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 828
 829         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 830
 831         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_GROUPS,
 832                         in_param1, in_param2, in_param3, in_param4, &out_param);
 833
 834         if (result == BLUETOOTH_ERROR_NONE) {
 835                 if (out_param == NULL) {
 836                         BT_ERR("Mesh: out_param is NULL");
 837                         result = BLUETOOTH_ERROR_INTERNAL;
 838                 } else {
 839                         size = (out_param->len) / sizeof(bluetooth_mesh_network_group_info_t);
 840
 841                         if (size == 0)
 842                                 BT_INFO("Mesh: No Groups created for the network");
 843
 844                         BT_INFO("Mesh: Total groups [%d]", size);
 845                         for (i = 0; i < size; i++) {
 846                                 bluetooth_mesh_network_group_info_t *grp_info = NULL;
 847
 848                                 info = &g_array_index(out_param,
 849                                         bluetooth_mesh_network_group_info_t, i);
 850                                 BT_INFO("Mesh: Group addr [0x%2.2x]", info->group_addr);
 851                                 BT_INFO("Mesh: Group is Virtual [%s]", info->is_virtual ? "YES" : "NO");
 852                                 BT_INFO("Mesh: Group net UUID[%s]", info->net_uuid);
 853                                 if (info->is_virtual)
 854                                         BT_INFO("Mesh: Virual Label UUID [%s]", info->label_uuid);
 855                                 grp_info = g_memdup(info,
 856                                         sizeof(bluetooth_mesh_network_group_info_t));
 857                                 g_ptr_array_add(*groups, (gpointer)grp_info);
 858                         }
 859                 }
 860         }
 861
 862         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 863
 864         return result;
 865 }
 866
 867 BT_EXPORT_API int bluetooth_mesh_network_get_all_netkey(
 868                 bluetooth_mesh_network_t *network,
 869                         GPtrArray **netkeys)
 870 {
 871         int result = BLUETOOTH_ERROR_NONE;
 872         guint size;
 873         int i;
 874
 875         BT_CHECK_PARAMETER(network, return);
 876         BT_CHECK_PARAMETER(netkeys, return);
 877
 878         BT_INIT_PARAMS();
 879         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 880
 881         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 882
 883         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_NETKEYS,
 884                         in_param1, in_param2, in_param3, in_param4, &out_param);
 885
 886         if (result == BLUETOOTH_ERROR_NONE) {
 887                 if (out_param == NULL) {
 888                         BT_ERR("Mesh: out_param is NULL");
 889                         result = BLUETOOTH_ERROR_INTERNAL;
 890                 } else {
 891                         size = (out_param->len) / sizeof(guint16);
 892
 893                         if (size == 0) {
 894                                 BT_ERR("Mesh: No netkeys created for the network");
 895                                 result = BLUETOOTH_ERROR_NOT_FOUND;
 896                         }
 897
 898                         for (i = 0; i < size; i++) {
 899                                 uint16_t netkey_index;
 900                                 uint16_t *netkey_idx = NULL;
 901
 902                                 netkey_index = g_array_index(out_param,
 903                                                 guint16, i);
 904
 905                                 netkey_idx = g_memdup(&netkey_index, sizeof(guint16));
 906                                 g_ptr_array_add(*netkeys, (gpointer)netkey_idx);
 907                         }
 908                 }
 909         }
 910
 911         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 912
 913         return result;
 914 }
 915
 916 BT_EXPORT_API int bluetooth_mesh_netkey_get_all_appkey(
 917                 bluetooth_mesh_network_t *network,
 918                         uint16_t netkey_idx,
 919                                 GPtrArray **appkeys)
 920 {
 921         int result = BLUETOOTH_ERROR_NONE;
 922         guint size;
 923         int i;
 924
 925         BT_CHECK_PARAMETER(network, return);
 926         BT_CHECK_PARAMETER(appkeys, return);
 927
 928         BT_INIT_PARAMS();
 929         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 930
 931         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 932         g_array_append_vals(in_param2, &netkey_idx,  sizeof(guint16));
 933
 934         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_APPKEYS,
 935                         in_param1, in_param2, in_param3, in_param4, &out_param);
 936
 937         if (result == BLUETOOTH_ERROR_NONE) {
 938                 if (out_param == NULL) {
 939                         BT_ERR("Mesh: out_param is NULL");
 940                         result = BLUETOOTH_ERROR_INTERNAL;
 941                 } else {
 942                         size = (out_param->len) / sizeof(guint16);
 943
 944                         if (size == 0)
 945                                 BT_ERR("Mesh: No Appkeys created for the NetKey in the network");
 946
 947                         for (i = 0; i < size; i++) {
 948                                 uint16_t appkey_index;
 949                                 uint16_t *appkey_idx = NULL;
 950
 951                                 appkey_index = g_array_index(out_param,
 952                                                 guint16, i);
 953
 954                                 appkey_idx = g_memdup(&appkey_index, sizeof(guint16));
 955                                 g_ptr_array_add(*appkeys, (gpointer)appkey_idx);
 956                         }
 957                 }
 958         }
 959
 960         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 961
 962         return result;
 963 }
 964
 965 BT_EXPORT_API int bluetooth_mesh_node_get_all_netkeys(
 966                 bluetooth_mesh_node_discover_t *node,
 967                         GPtrArray **netkeys)
 968 {
 969         int result = BLUETOOTH_ERROR_NONE;
 970         guint size;
 971         int i;
 972
 973         BT_CHECK_PARAMETER(node, return);
 974         BT_CHECK_PARAMETER(netkeys, return);
 975
 976         BT_INIT_PARAMS();
 977         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 978
 979         g_array_append_vals(in_param1, node,  sizeof(bluetooth_mesh_node_discover_t));
 980
 981         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_NETKEYS,
 982                         in_param1, in_param2, in_param3, in_param4, &out_param);
 983
 984         if (result == BLUETOOTH_ERROR_NONE) {
 985                 if (out_param == NULL) {
 986                         BT_ERR("Mesh: out_param is NULL");
 987                         result = BLUETOOTH_ERROR_INTERNAL;
 988                 } else {
 989                         size = (out_param->len) / sizeof(guint16);
 990
 991                         for (i = 0; i < size; i++) {
 992                                 uint16_t netkey_index;
 993                                 uint16_t *netkey_idx = NULL;
 994
 995                                 netkey_index = g_array_index(out_param,
 996                                                 guint16, i);
 997
 998                                 netkey_idx = g_memdup(&netkey_index, sizeof(guint16));
 999                                 g_ptr_array_add(*netkeys, (gpointer)netkey_idx);
1000                         }
1001                 }
1002         }
1003
1004         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1005
1006         return result;
1007 }
1008
1009 BT_EXPORT_API int bluetooth_mesh_node_get_all_appkeys(
1010         bluetooth_mesh_node_discover_t *req, GPtrArray **appkeys)
1011 {
1012         int result = BLUETOOTH_ERROR_NONE;
1013         guint size;
1014         int i;
1015
1016         BT_CHECK_PARAMETER(req, return);
1017         BT_CHECK_PARAMETER(appkeys, return);
1018
1019         BT_INIT_PARAMS();
1020         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1021
1022         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_discover_t));
1023
1024         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_APPKEYS,
1025                         in_param1, in_param2, in_param3, in_param4, &out_param);
1026
1027         if (result == BLUETOOTH_ERROR_NONE) {
1028                 if (out_param == NULL) {
1029                         BT_ERR("Mesh: out_param is NULL");
1030                         result = BLUETOOTH_ERROR_INTERNAL;
1031                 } else {
1032                         size = (out_param->len) / sizeof(guint16);
1033
1034                         for (i = 0; i < size; i++) {
1035                                 uint16_t appkey_index;
1036                                 uint16_t *appkey_idx = NULL;
1037
1038                                 appkey_index = g_array_index(out_param,
1039                                                 guint16, i);
1040
1041                                 appkey_idx = g_memdup(&appkey_index, sizeof(guint16));
1042                                 g_ptr_array_add(*appkeys, (gpointer)appkey_idx);
1043                         }
1044                 }
1045         }
1046
1047         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1048
1049         return result;
1050 }
1051
1052 BT_EXPORT_API int bluetooth_mesh_model_get_all_appkeys(
1053                         bluetooth_mesh_model_configure_t *req)
1054 {
1055         int result = 0;
1056         bt_user_info_t *user_info;
1057
1058         BT_CHECK_PARAMETER(req, return);
1059
1060         user_info = _bt_get_user_data(BT_MESH);
1061         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1062
1063         BT_INIT_PARAMS();
1064         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1065
1066         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1067
1068         BT_INFO("Mesh:Node Model Get AppKey List ");
1069         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_APPKEY_LIST,
1070                         in_param1, in_param2, in_param3, in_param4,
1071                         user_info->cb, user_info->user_data);
1072
1073         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1074         return result;
1075 }
1076
1077 BT_EXPORT_API int bluetooth_mesh_model_set_publication(
1078                         bluetooth_mesh_model_configure_t *req)
1079 {
1080         int result = 0;
1081         bt_user_info_t *user_info;
1082
1083         BT_CHECK_PARAMETER(req, return);
1084
1085         user_info = _bt_get_user_data(BT_MESH);
1086         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1087
1088         BT_INIT_PARAMS();
1089         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1090
1091         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1092
1093         BT_INFO("Mesh: Model Set Publication");
1094         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_SET_PUBLICATION,
1095                         in_param1, in_param2, in_param3, in_param4,
1096                         user_info->cb, user_info->user_data);
1097
1098         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1099         return result;
1100 }
1101
1102 BT_EXPORT_API int bluetooth_mesh_model_get_publication(
1103                         bluetooth_mesh_model_configure_t *req)
1104 {
1105         int result = 0;
1106         bt_user_info_t *user_info;
1107
1108         BT_CHECK_PARAMETER(req, return);
1109
1110         user_info = _bt_get_user_data(BT_MESH);
1111         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1112
1113         BT_INIT_PARAMS();
1114         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1115
1116         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1117
1118         BT_INFO("Mesh:BTAPI:  Model Get Publication");
1119         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_PUBLICATION,
1120                         in_param1, in_param2, in_param3, in_param4,
1121                         user_info->cb, user_info->user_data);
1122
1123         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1124         return result;
1125 }
1126
1127 BT_EXPORT_API int bluetooth_mesh_model_get_subscriptopn_list(
1128                         bluetooth_mesh_model_configure_t *req)
1129 {
1130         int result = 0;
1131         bt_user_info_t *user_info;
1132
1133         BT_CHECK_PARAMETER(req, return);
1134
1135         user_info = _bt_get_user_data(BT_MESH);
1136         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1137
1138         BT_INIT_PARAMS();
1139         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1140
1141         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1142
1143         BT_INFO("Mesh:BTAPI:  Model Get Subscription List ");
1144         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_SUBSCRIPTION_LIST,
1145                         in_param1, in_param2, in_param3, in_param4,
1146                         user_info->cb, user_info->user_data);
1147
1148         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1149         return result;
1150 }
1151
1152 BT_EXPORT_API int bluetooth_mesh_network_remove_group(
1153                 bluetooth_mesh_network_t *network,
1154                         bluetooth_mesh_network_group_info_t *req)
1155 {
1156         int result;
1157
1158         BT_CHECK_PARAMETER(network, return);
1159         BT_CHECK_PARAMETER(req, return);
1160
1161         BT_INIT_PARAMS();
1162         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1163
1164         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
1165         g_array_append_vals(in_param2, req,  sizeof(bluetooth_mesh_network_group_info_t));
1166
1167         BT_INFO("Mesh: Remove Group Request");
1168         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_REMOVE_GROUP,
1169                         in_param1, in_param2, in_param3, in_param4, &out_param);
1170
1171         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1172
1173         return result;
1174 }
1175
1176 BT_EXPORT_API int bluetooth_mesh_network_create_group(
1177                 bluetooth_mesh_network_t *network, bool is_virtual,
1178                         uint16_t grp_addr, bluetooth_mesh_network_group_info_t *info)
1179 {
1180         int result;
1181
1182         BT_CHECK_PARAMETER(network, return);
1183         BT_CHECK_PARAMETER(info, 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, &is_virtual,  sizeof(gboolean));
1190         g_array_append_vals(in_param3, &grp_addr,  sizeof(guint16));
1191
1192         BT_INFO("Mesh: Create Group Request");
1193         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_CREATE_GROUP,
1194                         in_param1, in_param2, in_param3, in_param4, &out_param);
1195
1196         if (result == BLUETOOTH_ERROR_NONE) {
1197                 *info = g_array_index(out_param,
1198                                 bluetooth_mesh_network_group_info_t, 0);
1199         }
1200         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1201
1202         return result;
1203 }
1204
1205 BT_EXPORT_API int bluetooth_mesh_model_configure_group_sub(
1206                         bluetooth_mesh_model_configure_t *req)
1207 {
1208         int result = 0;
1209         bt_user_info_t *user_info;
1210
1211         BT_CHECK_PARAMETER(req, return);
1212
1213         user_info = _bt_get_user_data(BT_MESH);
1214         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1215
1216         BT_INIT_PARAMS();
1217         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1218
1219         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1220
1221         BT_INFO("Mesh:Model Group Subscription Request");
1222         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_CONFIG_GROUP_SUB,
1223                         in_param1, in_param2, in_param3, in_param4,
1224                         user_info->cb, user_info->user_data);
1225
1226         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1227         return result;
1228 }
1229
1230 BT_EXPORT_API int bluetooth_mesh_model_configure_virtual_group_sub(
1231                         bluetooth_mesh_model_configure_t *req)
1232 {
1233         int result = 0;
1234         bt_user_info_t *user_info;
1235
1236         BT_CHECK_PARAMETER(req, return);
1237
1238         user_info = _bt_get_user_data(BT_MESH);
1239         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1240
1241         BT_INIT_PARAMS();
1242         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1243
1244         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1245
1246         BT_INFO("Mesh: Model Virtual Group Subscription Request");
1247         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
1248                         BT_MESH_MODEL_CONFIG_VIRTUAL_GROUP_SUB,
1249                         in_param1, in_param2, in_param3, in_param4,
1250                         user_info->cb, user_info->user_data);
1251
1252         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1253         return result;
1254 }