bt-api/bt-mesh.c

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