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