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