bt-service/services/mesh/bt-service-mesh-config-client.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   5  *
   6  * @author: Anupam Roy <anupam.r@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *              http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21 #include <glib.h>
  22 #include <dlog.h>
  23 #include <fcntl.h>
  24 #include <dirent.h>
  25 #include <errno.h>
  26 #include <limits.h>
  27 #include <stdio.h>
  28 #include <unistd.h>
  29 #include <sys/stat.h>
  30 #include <ell/ell.h>
  31
  32 #include "bt-service-common.h"
  33 #include "bt-service-core-adapter.h"
  34 #include "bt-service-event-receiver.h"
  35 #include "bt-request-handler.h"
  36 #include "bluetooth-api.h"
  37
  38 #include "bluetooth-api.h"
  39 #include "bluetooth-mesh-api.h"
  40 #include "bt-internal-types.h"
  41 #include "bt-service-util.h"
  42 #include "bt-service-common.h"
  43 #include "bt-service-core-adapter.h"
  44 #include "bt-service-event-receiver.h"
  45 #include "bt-request-handler.h"
  46 #include "bluetooth-api.h"
  47
  48 #include "bluetooth-api.h"
  49 #include "bluetooth-mesh-api.h"
  50 #include "bt-internal-types.h"
  51 #include "bt-service-util.h"
  52 #include "bt-service-common.h"
  53 #include "bt-service-event.h"
  54
  55 #include "bt-service-mesh-network.h"
  56 #include "bt-service-mesh-cdb.h"
  57 #include "bt-service-mesh-nodes.h"
  58 #include "bt-service-mesh-keys.h"
  59 #include "bt-service-mesh-util.h"
  60
  61 #include <oal-hardware.h>
  62 #include <oal-manager.h>
  63 #include <oal-event.h>
  64 #include <oal-adapter-mgr.h>
  65 #include <oal-device-mgr.h>
  66 #include <oal-mesh.h>
  67
  68 #include "bt-internal-types.h"
  69
  70 #define MESH_CONFIG_BUFFER_MAX_LEN 100
  71
  72
  73 static void __bt_mesh_send_node_browsed_event(int result,
  74                 bluetooth_mesh_node_discover_t *browse_evt);
  75 static void __bt_mesh_handle_pending_dev_config_request_info(int result,
  76                 int service_function, void *param,
  77                         unsigned int size);
  78
  79 struct mesh_config_cmd {
  80         uint32_t opcode;
  81         uint32_t response;
  82         const char *descriptor;
  83 };
  84
  85 static struct l_queue *pending_requests;
  86
  87 struct mesh_pending_request {
  88         struct l_timeout *timer;
  89         const struct mesh_config_cmd *cmd;
  90         uint8_t net_uuid[16];
  91         uint16_t addr;
  92         void *data;
  93 };
  94
  95 static struct mesh_config_cmd commands[] = {
  96         { MESH_OPCODE_APPKEY_ADD, MESH_OPCODE_APPKEY_STATUS, "AppKeyAdd" },
  97         { MESH_OPCODE_APPKEY_DELETE, MESH_OPCODE_APPKEY_STATUS, "AppKeyDelete" },
  98         { MESH_OPCODE_APPKEY_GET, MESH_OPCODE_APPKEY_LIST, "AppKeyGet" },
  99         { MESH_OPCODE_APPKEY_LIST, MESH_RESPONSE_NONE, "AppKeyList" },
 100         { MESH_OPCODE_APPKEY_STATUS, MESH_RESPONSE_NONE, "AppKeyStatus" },
 101         { MESH_OPCODE_APPKEY_UPDATE, MESH_OPCODE_APPKEY_STATUS, "AppKeyUpdate" },
 102         { MESH_OPCODE_DEV_COMP_GET, MESH_OPCODE_DEV_COMP_STATUS, "DeviceCompositionGet" },
 103         { MESH_OPCODE_DEV_COMP_STATUS, MESH_RESPONSE_NONE, "DeviceCompositionStatus" },
 104         { MESH_OPCODE_CONFIG_BEACON_GET, MESH_OPCODE_CONFIG_BEACON_STATUS, "BeaconGet" },
 105         { MESH_OPCODE_CONFIG_BEACON_SET, MESH_OPCODE_CONFIG_BEACON_STATUS, "BeaconSet" },
 106         { MESH_OPCODE_CONFIG_BEACON_STATUS, MESH_RESPONSE_NONE, "BeaconStatus" },
 107         { MESH_OPCODE_CONFIG_DEFAULT_TTL_GET, MESH_OPCODE_CONFIG_DEFAULT_TTL_STATUS,
 108                 "DefaultTTLGet" },
 109         { MESH_OPCODE_CONFIG_DEFAULT_TTL_SET, MESH_OPCODE_CONFIG_DEFAULT_TTL_STATUS,
 110                 "DefaultTTLSet" },
 111         { MESH_OPCODE_CONFIG_DEFAULT_TTL_STATUS, MESH_RESPONSE_NONE, "DefaultTTLStatus" },
 112         { MESH_OPCODE_CONFIG_FRIEND_GET, MESH_OPCODE_CONFIG_FRIEND_STATUS, "FriendGet" },
 113         { MESH_OPCODE_CONFIG_FRIEND_SET, MESH_OPCODE_CONFIG_FRIEND_STATUS, "FrienSet" },
 114         { MESH_OPCODE_CONFIG_FRIEND_STATUS, MESH_RESPONSE_NONE, "FriendStatus" },
 115         { MESH_OPCODE_CONFIG_PROXY_GET, MESH_OPCODE_CONFIG_PROXY_STATUS, "ProxyGet" },
 116         { MESH_OPCODE_CONFIG_PROXY_SET, MESH_OPCODE_CONFIG_PROXY_STATUS, "ProxySet" },
 117         { MESH_OPCODE_CONFIG_PROXY_STATUS, MESH_RESPONSE_NONE, "ProxyStatus" },
 118         { MESH_OPCODE_CONFIG_KEY_REFRESH_PHASE_GET, MESH_OPCODE_CONFIG_KEY_REFRESH_PHASE_STATUS,
 119                 "KeyRefreshPhaseGet" },
 120         { MESH_OPCODE_CONFIG_KEY_REFRESH_PHASE_SET, MESH_OPCODE_CONFIG_KEY_REFRESH_PHASE_STATUS,
 121                 "KeyRefreshPhaseSet" },
 122         { MESH_OPCODE_CONFIG_KEY_REFRESH_PHASE_STATUS, MESH_RESPONSE_NONE,
 123                 "KeyRefreshPhaseStatus" },
 124         { MESH_OPCODE_CONFIG_MODEL_PUB_GET, MESH_OPCODE_CONFIG_MODEL_PUB_STATUS, "ModelPubGet" },
 125         { MESH_OPCODE_CONFIG_MODEL_PUB_SET, MESH_OPCODE_CONFIG_MODEL_PUB_STATUS, "ModelPubSet" },
 126         { MESH_OPCODE_CONFIG_MODEL_PUB_STATUS, MESH_RESPONSE_NONE, "ModelPubStatus" },
 127         { MESH_OPCODE_CONFIG_MODEL_PUB_VIRT_SET, MESH_OPCODE_CONFIG_MODEL_PUB_STATUS,
 128                 "ModelPubVirtualSet" },
 129         { MESH_OPCODE_CONFIG_MODEL_SUB_ADD, MESH_OPCODE_CONFIG_MODEL_SUB_STATUS, "ModelSubAdd" },
 130         { MESH_OPCODE_CONFIG_MODEL_SUB_DELETE, MESH_OPCODE_CONFIG_MODEL_SUB_STATUS,
 131                 "ModelSubDelete" },
 132         { MESH_OPCODE_CONFIG_MODEL_SUB_DELETE_ALL, MESH_OPCODE_CONFIG_MODEL_SUB_STATUS,
 133                 "ModelSubDeleteAll" },
 134         { MESH_OPCODE_CONFIG_MODEL_SUB_OVERWRITE, MESH_OPCODE_CONFIG_MODEL_SUB_STATUS,
 135                 "ModelSubOverwrite" },
 136         { MESH_OPCODE_CONFIG_MODEL_SUB_STATUS, MESH_RESPONSE_NONE, "ModelSubStatus" },
 137         { MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_ADD, MESH_OPCODE_CONFIG_MODEL_SUB_STATUS,
 138                 "ModelSubVirtAdd" },
 139         { MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_DELETE, MESH_OPCODE_CONFIG_MODEL_SUB_STATUS,
 140                 "ModelSubVirtDelete" },
 141         { MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_OVERWRITE, MESH_OPCODE_CONFIG_MODEL_SUB_STATUS,
 142                 "ModelSubVirtOverwrite" },
 143         { MESH_OPCODE_CONFIG_NETWORK_TRANSMIT_GET, MESH_OPCODE_CONFIG_NETWORK_TRANSMIT_STATUS,
 144                 "NetworkTransmitGet" },
 145         { MESH_OPCODE_CONFIG_NETWORK_TRANSMIT_SET, MESH_OPCODE_CONFIG_NETWORK_TRANSMIT_STATUS,
 146                 "NetworkTransmitSet" },
 147         { MESH_OPCODE_CONFIG_NETWORK_TRANSMIT_STATUS, MESH_RESPONSE_NONE,
 148                 "NetworkTransmitStatus" },
 149         { MESH_OPCODE_CONFIG_RELAY_GET, MESH_OPCODE_CONFIG_RELAY_STATUS, "RelayGet" },
 150         { MESH_OPCODE_CONFIG_RELAY_SET, MESH_OPCODE_CONFIG_RELAY_STATUS, "RelaySet" },
 151         { MESH_OPCODE_CONFIG_RELAY_STATUS, MESH_RESPONSE_NONE, "RelayStatus" },
 152         { MESH_OPCODE_CONFIG_MODEL_SUB_GET, MESH_OPCODE_CONFIG_MODEL_SUB_LIST, "ModelSubGet" },
 153         { MESH_OPCODE_CONFIG_MODEL_SUB_LIST, MESH_RESPONSE_NONE, "ModelSubList" },
 154         { MESH_OPCODE_CONFIG_VEND_MODEL_SUB_GET, MESH_OPCODE_CONFIG_VEND_MODEL_SUB_LIST,
 155                 "VendorModelSubGet" },
 156         { MESH_OPCODE_CONFIG_VEND_MODEL_SUB_LIST, MESH_RESPONSE_NONE, "VendorModelSubList" },
 157         { MESH_OPCODE_CONFIG_POLL_TIMEOUT_LIST, MESH_OPCODE_CONFIG_POLL_TIMEOUT_STATUS,
 158                 "PollTimeoutList" },
 159         { MESH_OPCODE_CONFIG_POLL_TIMEOUT_STATUS, MESH_RESPONSE_NONE, "PollTimeoutStatus" },
 160         { MESH_OPCODE_CONFIG_HEARTBEAT_PUB_GET, MESH_OPCODE_CONFIG_HEARTBEAT_PUB_STATUS,
 161                 "HeartbeatPubGet" },
 162         { MESH_OPCODE_CONFIG_HEARTBEAT_PUB_SET, MESH_OPCODE_CONFIG_HEARTBEAT_PUB_STATUS,
 163                 "HeartbeatPubSet" },
 164         { MESH_OPCODE_CONFIG_HEARTBEAT_PUB_STATUS, MESH_RESPONSE_NONE, "HeartbeatPubStatus" },
 165         { MESH_OPCODE_CONFIG_HEARTBEAT_SUB_GET, MESH_OPCODE_CONFIG_HEARTBEAT_SUB_STATUS,
 166                 "HeartbeatSubGet" },
 167         { MESH_OPCODE_CONFIG_HEARTBEAT_SUB_SET, MESH_OPCODE_CONFIG_HEARTBEAT_SUB_STATUS,
 168                 "HeartbeatSubSet" },
 169         { MESH_OPCODE_CONFIG_HEARTBEAT_SUB_STATUS, MESH_RESPONSE_NONE, "HeartbeatSubStatus" },
 170         { MESH_OPCODE_MODEL_APP_BIND, MESH_OPCODE_MODEL_APP_STATUS, "ModelAppBind" },
 171         { MESH_OPCODE_MODEL_APP_STATUS, MESH_RESPONSE_NONE, "ModelAppStatus" },
 172         { MESH_OPCODE_MODEL_APP_UNBIND, MESH_OPCODE_MODEL_APP_STATUS, "ModelAppUnbind" },
 173         { MESH_OPCODE_NETKEY_ADD, MESH_OPCODE_NETKEY_STATUS, "NetKeyAdd" },
 174         { MESH_OPCODE_NETKEY_DELETE, MESH_OPCODE_NETKEY_STATUS, "NetKeyDelete" },
 175         { MESH_OPCODE_NETKEY_GET, MESH_OPCODE_NETKEY_LIST, "NetKeyGet" },
 176         { MESH_OPCODE_NETKEY_LIST, MESH_RESPONSE_NONE, "NetKeyList" },
 177         { MESH_OPCODE_NETKEY_STATUS, MESH_RESPONSE_NONE, "NetKeyStatus" },
 178         { MESH_OPCODE_NETKEY_UPDATE, MESH_OPCODE_NETKEY_STATUS, "NetKeyUpdate" },
 179         { MESH_OPCODE_NODE_IDENTITY_GET, MESH_OPCODE_NODE_IDENTITY_STATUS, "NodeIdentityGet" },
 180         { MESH_OPCODE_NODE_IDENTITY_SET, MESH_OPCODE_NODE_IDENTITY_STATUS, "NodeIdentitySet" },
 181         { MESH_OPCODE_NODE_IDENTITY_STATUS, MESH_RESPONSE_NONE, "NodeIdentityStatus" },
 182         { MESH_OPCODE_NODE_RESET, MESH_OPCODE_NODE_RESET_STATUS, "NodeReset" },
 183         { MESH_OPCODE_NODE_RESET_STATUS, MESH_RESPONSE_NONE, "NodeResetStatus" },
 184         { MESH_OPCODE_MODEL_APP_GET, MESH_OPCODE_MODEL_APP_LIST, "ModelAppGet" },
 185         { MESH_OPCODE_MODEL_APP_LIST, MESH_RESPONSE_NONE, "ModelAppList" },
 186         { MESH_OPCODE_VENDOR_MODEL_APP_GET, MESH_OPCODE_VENDOR_MODEL_APP_LIST, "VendorModelAppGet" },
 187         { MESH_OPCODE_VENDOR_MODEL_APP_LIST, MESH_RESPONSE_NONE, "VendorModelAppList" }
 188 };
 189
 190
 191 static const struct mesh_config_cmd *__mesh_get_command(uint32_t opcode)
 192 {
 193         uint32_t n;
 194
 195         for (n = 0; n < L_ARRAY_SIZE(commands); n++) {
 196                 if (opcode == commands[n].opcode)
 197                         return &commands[n];
 198         }
 199
 200         return NULL;
 201 }
 202
 203 static const char *__mesh_get_opcode_string(uint32_t opcode)
 204 {
 205         const struct mesh_config_cmd *cmd;
 206
 207         cmd = __mesh_get_command(opcode);
 208         if (!cmd)
 209                 return "Unknown Command Received";
 210
 211         return cmd->descriptor;
 212 }
 213
 214 static void __mesh_request_remove(void *a)
 215 {
 216         struct mesh_pending_request *req = a;
 217
 218         if (req->data)
 219                 l_free(req->data);
 220         l_timeout_remove(req->timer);
 221         l_free(req);
 222 }
 223
 224 static void __bt_mesh_wait_response_timeout(
 225                 struct l_timeout *timeout, void *user_data)
 226 {
 227         struct mesh_pending_request *req = user_data;
 228
 229         BT_INFO("Mesh: No response for \"%s\" from %4.4x\n",
 230                         req->cmd->descriptor, req->addr);
 231
 232         /* Node reset case: delete the remote even if there is no response */
 233         /* TODO Reset the remote node, as no response is expected on reset command */
 234
 235
 236         switch (req->cmd->opcode) {
 237         case MESH_OPCODE_DEV_COMP_GET: {
 238                 /* Send event with timeout for Vendor Features */
 239                 bluetooth_mesh_node_features_t *vendor_event = \
 240                         g_malloc0(sizeof(bluetooth_mesh_node_features_t));
 241
 242                 _bt_mesh_util_convert_hex_to_string((uint8_t *) req->net_uuid, 16,
 243                         vendor_event->net_uuid,
 244                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
 245                 vendor_event->unicast = req->addr;
 246                  __bt_mesh_handle_pending_dev_config_request_info(
 247                         BLUETOOTH_ERROR_TIMEOUT, BT_MESH_NODE_GET_VENDOR_FEATURES,
 248                                 vendor_event, sizeof(bluetooth_mesh_node_features_t));
 249                 g_free(vendor_event);
 250
 251                 /* Send event with timeout for Node Browse */
 252                 event_mesh_devkey_message_t *event = \
 253                         g_malloc0(sizeof(event_mesh_devkey_message_t));
 254                 memcpy(event->net_uuid.uuid, req->net_uuid, 16);
 255                 event->source = req->addr;
 256
 257                  __bt_mesh_handle_pending_dev_config_request_info(
 258                         BLUETOOTH_ERROR_TIMEOUT, BT_MESH_NODE_BROWSE,
 259                                 event, sizeof(event_mesh_devkey_message_t));
 260
 261                 g_free(event);
 262                 break;
 263         }
 264         case MESH_OPCODE_CONFIG_MODEL_SUB_GET:
 265         case MESH_OPCODE_CONFIG_VEND_MODEL_SUB_GET:
 266                 BT_INFO("Mesh: Command TimedOut: Model Subscription list get");
 267                 /* Send event with timeout */
 268                  __bt_mesh_handle_pending_dev_config_request_info(
 269                         BLUETOOTH_ERROR_TIMEOUT,
 270                                 BT_MESH_MODEL_GET_SUBSCRIPTION_LIST, req->data,
 271                                         sizeof(bluetooth_mesh_model_configure_t));
 272         break;
 273         case MESH_OPCODE_NETKEY_ADD:
 274         case MESH_OPCODE_NETKEY_UPDATE:
 275         case MESH_OPCODE_NETKEY_DELETE:
 276         case MESH_OPCODE_APPKEY_ADD:
 277         case MESH_OPCODE_APPKEY_UPDATE:
 278         case MESH_OPCODE_APPKEY_DELETE:
 279                 /* Send event with timeout */
 280                  __bt_mesh_handle_pending_dev_config_request_info(
 281                         BLUETOOTH_ERROR_TIMEOUT,
 282                                 BT_MESH_NODE_CONFIGURE_KEY, req->data,
 283                                         sizeof(bluetooth_mesh_key_configure_t));
 284                 break;
 285         case MESH_OPCODE_CONFIG_DEFAULT_TTL_GET:
 286         case MESH_OPCODE_CONFIG_DEFAULT_TTL_SET:
 287                 /* Send event with timeout */
 288                  __bt_mesh_handle_pending_dev_config_request_info(
 289                         BLUETOOTH_ERROR_TIMEOUT,
 290                                 BT_MESH_NODE_TTL_EXECUTE, req->data,
 291                                         sizeof(bluetooth_mesh_node_ttl_info_t));
 292                 break;
 293         case MESH_OPCODE_CONFIG_MODEL_SUB_ADD:
 294         case MESH_OPCODE_CONFIG_MODEL_SUB_DELETE:
 295         case MESH_OPCODE_CONFIG_MODEL_SUB_OVERWRITE:
 296                 /* Send event with timeout */
 297                  __bt_mesh_handle_pending_dev_config_request_info(
 298                         BLUETOOTH_ERROR_TIMEOUT,
 299                                 BT_MESH_MODEL_CONFIG_GROUP_SUB, req->data,
 300                                         sizeof(bluetooth_mesh_model_configure_t));
 301                 break;
 302         case MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_ADD:
 303         case MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_DELETE:
 304         case MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_OVERWRITE:
 305                 /* Send event with timeout */
 306                  __bt_mesh_handle_pending_dev_config_request_info(
 307                         BLUETOOTH_ERROR_TIMEOUT,
 308                                 BT_MESH_MODEL_CONFIG_VIRTUAL_GROUP_SUB, req->data,
 309                                         sizeof(bluetooth_mesh_model_configure_t));
 310                 break;
 311         case MESH_OPCODE_CONFIG_MODEL_SUB_DELETE_ALL:
 312                 /* Send event with timeout */
 313                  __bt_mesh_handle_pending_dev_config_request_info(
 314                         BLUETOOTH_ERROR_TIMEOUT,
 315                                 BT_MESH_MODEL_CONFIG_VIRTUAL_GROUP_SUB, req->data,
 316                                         sizeof(bluetooth_mesh_model_configure_t));
 317                 /* Send event with timeout */
 318                  __bt_mesh_handle_pending_dev_config_request_info(
 319                         BLUETOOTH_ERROR_TIMEOUT,
 320                                 BT_MESH_MODEL_CONFIG_GROUP_SUB, req->data,
 321                                         sizeof(bluetooth_mesh_model_configure_t));
 322                 break;
 323         case MESH_OPCODE_CONFIG_MODEL_PUB_GET:
 324                 /* Send event with timeout */
 325                 __bt_mesh_handle_pending_dev_config_request_info(
 326                         BLUETOOTH_ERROR_TIMEOUT,
 327                                 BT_MESH_MODEL_GET_PUBLICATION, req->data,
 328                                 sizeof(bluetooth_mesh_model_configure_t));
 329                 break;
 330         case MESH_OPCODE_CONFIG_MODEL_PUB_SET:
 331                 /* Send event with timeout */
 332                 __bt_mesh_handle_pending_dev_config_request_info(
 333                         BLUETOOTH_ERROR_TIMEOUT,
 334                                 BT_MESH_MODEL_SET_PUBLICATION, req->data,
 335                                 sizeof(bluetooth_mesh_model_configure_t));
 336                 break;
 337         case MESH_OPCODE_MODEL_APP_BIND:
 338         case MESH_OPCODE_MODEL_APP_UNBIND:
 339                 /* Send event with timeout */
 340                 __bt_mesh_handle_pending_dev_config_request_info(
 341                         BLUETOOTH_ERROR_TIMEOUT,
 342                                 BT_MESH_MODEL_CONFIGURE_APPKEY, req->data,
 343                                 sizeof(bluetooth_mesh_model_configure_t));
 344                 break;
 345         default:
 346                 break;
 347         }
 348         BT_INFO("Mesh: Number of pending requests [%u] Remove the req",
 349                 l_queue_length(pending_requests));
 350         l_queue_remove(pending_requests, req);
 351         __mesh_request_remove(req);
 352 }
 353
 354 static void __bt_mesh_add_request(uint32_t opcode, uint16_t dest,
 355                         uint8_t net_uuid[], void *data)
 356 {
 357         struct mesh_pending_request *req;
 358         const struct mesh_config_cmd *cmd;
 359         char uuid_str[33];
 360
 361         cmd = __mesh_get_command(opcode);
 362         if (!cmd)
 363                 return;
 364         _bt_mesh_util_convert_hex_to_string((uint8_t *) net_uuid, 16, uuid_str,
 365                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
 366         BT_INFO("Mesh: Net UUID[%s]", uuid_str);
 367
 368         BT_INFO("Mesh: Adding command opcode [0x%2.2x] response [0x%2.2x]",
 369                         cmd->opcode, cmd->response);
 370         req = l_new(struct mesh_pending_request, 1);
 371         req->cmd = cmd;
 372         req->addr = dest;
 373         req->data = data;
 374         memcpy(req->net_uuid, net_uuid, 16);
 375         req->timer = l_timeout_create(MESH_DEFAULT_RESPONSE_TIMEOUT,
 376                         __bt_mesh_wait_response_timeout, req, NULL);
 377
 378         if (!pending_requests)
 379                 pending_requests = l_queue_new();
 380         l_queue_push_tail(pending_requests, req);
 381         BT_INFO("Mesh: Number of pending requests [%u]", l_queue_length(pending_requests));
 382 }
 383
 384 static struct mesh_pending_request *__bt_mesh_get_request_by_response(
 385                 uint16_t addr, uint8_t net_uuid[],
 386                         uint32_t response)
 387 {
 388         const struct l_queue_entry *entry;
 389         char uuid_str[33];
 390         char uuid_str1[33];
 391
 392         BT_INFO("Mesh: Number of pending requests [%u]", l_queue_length(pending_requests));
 393         entry = l_queue_get_entries(pending_requests);
 394
 395         for (; entry; entry = entry->next) {
 396                 struct mesh_pending_request *req = entry->data;
 397
 398                 /* Test */
 399                 BT_INFO("Mesh: Req addr [0x%2.2x] req opcode [0x%2.2x] res [0x%2.2x]", req->addr, req->cmd->opcode, req->cmd->response);
 400                 BT_INFO("Mesh: Current req addr [0x%2.2x] res [0x%2.2x]", addr, response);
 401                 _bt_mesh_util_convert_hex_to_string((uint8_t *) net_uuid, 16, uuid_str,
 402                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
 403                 BT_INFO("Mesh: Net UUID[%s]", uuid_str);
 404
 405                 _bt_mesh_util_convert_hex_to_string((uint8_t *) req->net_uuid, 16, uuid_str1,
 406                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
 407                 BT_INFO("Mesh: Net UUID1[%s]", uuid_str1);
 408                 if (!memcmp(net_uuid, req->net_uuid, 16) &&
 409                                 req->addr == addr &&
 410                                 req->cmd->response == response)
 411                         return req;
 412         }
 413
 414         return NULL;
 415 }
 416
 417 bool _bt_mesh_check_pending_request(uint32_t opcode,
 418                 uint16_t dest, uint8_t net_uuid[])
 419 {
 420         const struct mesh_config_cmd *cmd;
 421         cmd = __mesh_get_command(opcode);
 422
 423         if (!cmd)
 424                 return false;
 425
 426         if (__bt_mesh_get_request_by_response(dest,
 427                                 net_uuid, cmd->response)) {
 428                 BT_ERR("Mesh:Another command is pending\n");
 429                 return true;
 430         }
 431         return false;
 432 }
 433
 434 static uint32_t __bt_mesh_print_model_identifier(uint8_t *data,
 435                 bool vendor, const char *offset)
 436 {
 437         uint32_t mod_id;
 438
 439         if (!vendor) {
 440                 mod_id = l_get_le16(data);
 441                 BT_INFO("%sModel ID\t%4.4x\n", offset, mod_id);
 442                 mod_id = MESH_VENDOR_ID_MASK | mod_id;
 443         } else {
 444                 mod_id = l_get_le16(data + 2);
 445                 BT_INFO("%sModel ID\t%4.4x %4.4x\n", offset,
 446                                 l_get_le16(data), mod_id);
 447                 mod_id = l_get_le16(data) << 16 | mod_id;
 448         }
 449
 450         return mod_id;
 451 }
 452
 453 static void __bt_mesh_print_device_composition_data(
 454                 uint8_t *data, uint16_t len)
 455 {
 456         uint16_t features;
 457         int i = 0;
 458
 459         BT_INFO("Mesh: Received composion:\n");
 460
 461         /* skip page -- We only support Page Zero */
 462         data++;
 463         len--;
 464
 465         BT_INFO("\tCID: %4.4x", l_get_le16(&data[0]));
 466         BT_INFO("\tPID: %4.4x", l_get_le16(&data[2]));
 467         BT_INFO("\tVID: %4.4x", l_get_le16(&data[4]));
 468         BT_INFO("\tCRPL: %4.4x", l_get_le16(&data[6]));
 469
 470         features = l_get_le16(&data[8]);
 471         data += 10;
 472         len -= 10;
 473
 474         BT_INFO("\tFeature support:\n");
 475         BT_INFO("\t\trelay: %s\n", (features & MESH_FEATURE_RELAY) ?
 476                         "yes" : "no");
 477         BT_INFO("\t\tproxy: %s\n", (features & MESH_FEATURE_PROXY) ?
 478                         "yes" : "no");
 479         BT_INFO("\t\tfriend: %s\n", (features & MESH_FEATURE_FRIEND) ?
 480                         "yes" : "no");
 481         BT_INFO("\t\tlpn: %s\n", (features & MESH_FEATURE_LPN) ?
 482                         "yes" : "no");
 483         while (len) {
 484                 uint8_t m, v;
 485
 486                 BT_INFO("\t Element %d:\n", i);
 487                 BT_INFO("\t\tlocation: %4.4x\n", l_get_le16(data));
 488                 data += 2;
 489                 len -= 2;
 490
 491                 m = *data++;
 492                 v = *data++;
 493                 len -= 2;
 494
 495                 if (m)
 496                         BT_INFO("\t\tSIG defined models:\n");
 497
 498                 while (len >= 2 && m--) {
 499                         __bt_mesh_print_model_identifier(data, false, "\t\t  ");
 500                         data += 2;
 501                         len -= 2;
 502                 }
 503
 504                 if (v)
 505                         BT_INFO("\t\t Vendor defined models:\n");
 506
 507                 while (len >= 4 && v--) {
 508                         __bt_mesh_print_model_identifier(data, true, "\t\t  ");
 509                         data += 4;
 510                         len -= 4;
 511                 }
 512
 513                 i++;
 514         }
 515 }
 516
 517 static void __bt_mesh_send_model_publication_status_event(
 518                 int event, int result,
 519                         bluetooth_mesh_model_configure_t *evt)
 520 {
 521         GVariant *out_var = NULL, *param = NULL;
 522         GArray *info = NULL;
 523
 524         if (BLUETOOTH_ERROR_NONE == result) {
 525                 BT_INFO("Mesh: Model ID [0x%4.4x]", evt->model);
 526                 BT_INFO("Mesh: Model Publication Address [0x%2.2x]", evt->pub_addr);
 527                 /* Send event */
 528                 info = g_array_new(FALSE, FALSE, sizeof(gchar));
 529                 g_array_append_vals(info, evt,
 530                                 sizeof(bluetooth_mesh_model_configure_t));
 531
 532                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 533                                 info->data, info->len,
 534                                 TRUE, NULL, NULL);
 535
 536                 param = g_variant_new("(iv)", result, out_var);
 537                 _bt_send_event(BT_MESH_EVENT, event,
 538                                 param);
 539         }
 540 }
 541
 542 static void __bt_mesh_send_model_subscription_configure_event(
 543                 int event, int result,
 544                         bluetooth_mesh_model_configure_t *evt)
 545 {
 546         GVariant *out_var = NULL, *param = NULL;
 547         GArray *info = NULL;
 548
 549         if (BLUETOOTH_ERROR_NONE == result) {
 550                 /* Send event */
 551                 info = g_array_new(FALSE, FALSE, sizeof(gchar));
 552                 g_array_append_vals(info, evt,
 553                                 sizeof(bluetooth_mesh_model_configure_t));
 554
 555                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 556                                 info->data, info->len,
 557                                 TRUE, NULL, NULL);
 558
 559                 param = g_variant_new("(iv)", result, out_var);
 560                 _bt_send_event(BT_MESH_EVENT, event,
 561                                 param);
 562         }
 563 }
 564
 565 static void __bt_mesh_send_model_get_subscription_list_event(
 566         int result, bluetooth_mesh_model_configure_t *evt)
 567 {
 568         GVariant  *param = NULL;
 569         GVariantBuilder *builder = NULL;
 570         int i;
 571         char *net_uuid;
 572
 573         if (BLUETOOTH_ERROR_NONE == result) {
 574                 BT_INFO("Mesh: Total Subscriptions bound to model [%d]",
 575                                 evt->sublist_count);
 576                 BT_INFO("Mesh: Network [%s]", evt->net_uuid);
 577                 builder = g_variant_builder_new(G_VARIANT_TYPE("aq"));
 578                 for (i = 0; i < evt->sublist_count; i++) {
 579                         BT_INFO("Mesh: Subscription Address [0x%2.2x]",
 580                                 *evt->sub_list[i]);
 581                         g_variant_builder_add(builder, "q", *evt->sub_list[i]);
 582                 }
 583
 584                 net_uuid = g_strdup(evt->net_uuid);
 585                 param = g_variant_new("(isqiui(aq))", result, net_uuid,
 586                                 evt->primary_unicast, evt->elem_index, evt->model,
 587                                 evt->sublist_count, builder);
 588
 589                 g_variant_builder_unref(builder);
 590
 591                 /* Send event */
 592                 _bt_send_event(BT_MESH_EVENT,
 593                                 BLUETOOTH_EVENT_MESH_MODEL_SUBSCRIPTION_LIST,
 594                                 param);
 595
 596                 if (evt->sublist_count) {
 597                         /* Free List data */
 598                         for (int i = 0; i < evt->sublist_count; i++)
 599                                 g_free(evt->sub_list[i]);
 600                         g_free(evt->sub_list);
 601                 }
 602                 g_free(net_uuid);
 603                 BT_INFO("freed net uuid");
 604         }
 605 }
 606
 607 static void __bt_mesh_send_model_get_appkey_list_event(int result,
 608                 bluetooth_mesh_model_configure_t *evt)
 609 {
 610         GVariant  *param = NULL;
 611         GVariantBuilder *builder = NULL;
 612         char *net_uuid;
 613         int i;
 614
 615         if (BLUETOOTH_ERROR_NONE == result) {
 616                 builder = g_variant_builder_new(G_VARIANT_TYPE("aq"));
 617                 BT_INFO("Mesh: Total AppKeys bound to model [%d]",
 618                                 evt->appkeylist_count);
 619                 BT_INFO("Mesh: Network [%s]", evt->net_uuid);
 620                 for (i = 0; i < evt->appkeylist_count; i++)
 621                         g_variant_builder_add(builder, "q", *evt->appkey_list[i]);
 622                 net_uuid = g_strdup(evt->net_uuid);
 623                 param = g_variant_new("(isqiui(aq))", result, net_uuid,
 624                                 evt->primary_unicast, evt->elem_index, evt->model,
 625                                 evt->appkeylist_count, builder);
 626
 627                 g_variant_builder_unref(builder);
 628
 629                 /* Send event */
 630                 _bt_send_event(BT_MESH_EVENT,
 631                                 BLUETOOTH_EVENT_MESH_MODEL_APPKEY_LIST,
 632                                 param);
 633
 634                 if (evt->appkeylist_count) {
 635                         for (int i = 0; i < evt->appkeylist_count; i++)
 636                                 g_free(evt->appkey_list[i]);
 637
 638                         g_free(evt->appkey_list);
 639                 }
 640                 /* Free List data */
 641                 g_free(net_uuid);
 642         }
 643 }
 644
 645 static void __bt_mesh_send_model_configure_appkey_event(int result,
 646                 bluetooth_mesh_model_configure_t *evt)
 647 {
 648         GVariant *out_var = NULL, *param = NULL;
 649         GArray *info = NULL;
 650
 651         if (BLUETOOTH_ERROR_NONE == result) {
 652                 /* Send event */
 653                 info = g_array_new(FALSE, FALSE, sizeof(gchar));
 654                 g_array_append_vals(info, evt, sizeof(bluetooth_mesh_model_configure_t));
 655
 656                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 657                                 info->data, info->len,
 658                                 TRUE, NULL, NULL);
 659
 660                 param = g_variant_new("(iv)", result, out_var);
 661                 _bt_send_event(BT_MESH_EVENT,
 662                                 BLUETOOTH_EVENT_MESH_MODEL_APPKEY_BIND,
 663                                 param);
 664         }
 665 }
 666
 667 static void __bt_mesh_send_node_ttl_configuration_event(int result,
 668                 bluetooth_mesh_node_ttl_info_t *ttl_evt)
 669 {
 670         GVariant *out_var = NULL, *param = NULL;
 671         GArray *info = NULL;
 672
 673         if (BLUETOOTH_ERROR_NONE == result) {
 674                 /* Send event */
 675                 info = g_array_new(FALSE, FALSE, sizeof(gchar));
 676                 g_array_append_vals(info, ttl_evt,
 677                         sizeof(bluetooth_mesh_node_ttl_info_t));
 678
 679                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 680                                 info->data, info->len,
 681                                 TRUE, NULL, NULL);
 682
 683                 param = g_variant_new("(iv)", result, out_var);
 684                 _bt_send_event(BT_MESH_EVENT,
 685                                 BLUETOOTH_EVENT_MESH_NODE_TTL_CONFIGURED,
 686                                 param);
 687         }
 688 }
 689
 690 static void __bt_mesh_send_node_key_configuration_event(int result,
 691                 bluetooth_mesh_key_configure_t *key_evt)
 692 {
 693         GVariant *out_var = NULL, *param = NULL;
 694         GArray *info = NULL;
 695
 696         if (BLUETOOTH_ERROR_NONE == result) {
 697                 /* Send event */
 698                 info = g_array_new(FALSE, FALSE, sizeof(gchar));
 699                 g_array_append_vals(info, key_evt,
 700                         sizeof(bluetooth_mesh_key_configure_t));
 701
 702                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 703                                 info->data, info->len,
 704                                 TRUE, NULL, NULL);
 705
 706                 param = g_variant_new("(iv)", result, out_var);
 707                 _bt_send_event(BT_MESH_EVENT,
 708                                 BLUETOOTH_EVENT_MESH_NODE_KEY_CONFIGURED,
 709                                 param);
 710         }
 711 }
 712
 713 static void __bt_mesh_send_node_get_vendor_features_event(int result,
 714                 bluetooth_mesh_node_features_t *features_evt)
 715 {
 716         GVariant *out_var = NULL, *param = NULL;
 717         GArray *info = NULL;
 718
 719         if (BLUETOOTH_ERROR_NONE == result) {
 720                 /* Send event */
 721                 info = g_array_new(FALSE, FALSE, sizeof(gchar));
 722                 g_array_append_vals(info, features_evt,
 723                                 sizeof(bluetooth_mesh_node_features_t));
 724
 725                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 726                                 info->data, info->len,
 727                                 TRUE, NULL, NULL);
 728
 729                 param = g_variant_new("(iv)", result, out_var);
 730                 _bt_send_event(BT_MESH_EVENT,
 731                                 BLUETOOTH_EVENT_MESH_NODE_VENDOR_FEATURES,
 732                                 param);
 733         }
 734 }
 735
 736 static void __bt_mesh_send_node_browsed_event(int result,
 737                 bluetooth_mesh_node_discover_t *browse_evt)
 738 {
 739         GVariant *out_var = NULL, *param = NULL;
 740         GArray *info = NULL;
 741
 742         if (BLUETOOTH_ERROR_NONE == result) {
 743                 /* Send event */
 744                 info = g_array_new(FALSE, FALSE, sizeof(gchar));
 745                 g_array_append_vals(info, browse_evt,
 746                                 sizeof(bluetooth_mesh_node_discover_t));
 747
 748                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 749                                 info->data, info->len,
 750                                 TRUE, NULL, NULL);
 751
 752                 param = g_variant_new("(iv)", result, out_var);
 753                 _bt_send_event(BT_MESH_EVENT,
 754                                 BLUETOOTH_EVENT_MESH_NODE_BROWSED,
 755                                 param);
 756         }
 757 }
 758
 759 static void __bt_mesh_handle_pending_dev_config_request_info(int result,
 760                 int service_function, void *param, unsigned int size)
 761 {
 762         GSList *l;
 763         GArray *out_param;
 764         invocation_info_t *req_info = NULL;
 765
 766         for (l = _bt_get_invocation_list(); l != NULL; ) {
 767                 req_info = l->data;
 768                 l = g_slist_next(l);
 769                 if (req_info == NULL ||
 770                                 req_info->service_function != service_function)
 771                         continue;
 772
 773                 switch (service_function) {
 774                 case BT_MESH_NODE_GET_VENDOR_FEATURES: {
 775                         bluetooth_mesh_node_features_t *event;
 776                         bluetooth_mesh_node_features_t *req;
 777
 778                         event = (bluetooth_mesh_node_features_t*) param;
 779                         req = (bluetooth_mesh_node_features_t*)req_info->user_data;
 780
 781                         BT_DBG("Request Sender: [%s]", req_info->sender);
 782                         /* Match Network and Remote Node unicast*/
 783                         if (!g_strcmp0(event->net_uuid, req->net_uuid) && event->unicast == req->unicast) {
 784                                 event->unicast = req->unicast;
 785                                 event->elem_count = req->elem_count;
 786
 787                                 /* Send Event */
 788                                 __bt_mesh_send_node_get_vendor_features_event(result, event);
 789
 790                                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
 791                                 g_array_append_vals(out_param, event, sizeof(bluetooth_mesh_node_features_t));
 792
 793                                 /* Return DBUS Invocation*/
 794                                 _bt_service_method_return(req_info->context, out_param, result);
 795                                 _bt_free_info_from_invocation_list(req_info);
 796                                 g_array_free(out_param, TRUE);
 797                         }
 798                         break;
 799                 }
 800                 case BT_MESH_NODE_BROWSE: {
 801                         bluetooth_mesh_node_discover_t *node;
 802                         event_mesh_devkey_message_t *event;
 803                         uint16_t remote_addr;
 804                         uint8_t elem_count;
 805                         uint8_t dev_uuid[16];
 806                         char net_uuid[BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1];
 807
 808                         event = (event_mesh_devkey_message_t*) param;
 809                         node = (bluetooth_mesh_node_discover_t*)req_info->user_data;
 810                         BT_INFO("Mesh: Request Node UUID [%s]", node->dev_uuid);
 811                         BT_INFO("Mesh: Request Network UUID [%s]", node->net_uuid);
 812
 813                         _bt_mesh_util_convert_hex_to_string((uint8_t *) event->net_uuid.uuid, 16, net_uuid,
 814                                         BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
 815
 816                         _bt_mesh_util_convert_string_to_hex(node->dev_uuid, strlen(node->dev_uuid), dev_uuid, 16);
 817
 818                         /* Get Unicast from pending request's Dev UUID and match with event */
 819                         if (_bt_mesh_node_get_unicast_from_dev_uuid(event->net_uuid.uuid, dev_uuid, &remote_addr)) {
 820
 821                                 BT_DBG("Request Sender: [%s]", req_info->sender);
 822                                 /* Match Network and Remote Node unicast*/
 823                                 if (!g_strcmp0(node->net_uuid, net_uuid) && remote_addr == event->source) {
 824                                         _bt_mesh_node_get_element_count(event->net_uuid.uuid, remote_addr, &elem_count);
 825                                         node->unicast = event->source;
 826                                         node->count = elem_count;
 827                                         BT_INFO("Mesh: Browse event for Node: Unicast [0x%2.2x] Element Count [%d]",
 828                                                 node->unicast, elem_count);
 829                                         /* Send Event */
 830                                         __bt_mesh_send_node_browsed_event(result, node);
 831
 832                                         out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
 833                                         g_array_append_vals(out_param, node, sizeof(bluetooth_mesh_node_discover_t));
 834
 835                                         /* Return DBUS Invocation*/
 836                                         _bt_service_method_return(req_info->context, out_param, result);
 837                                         _bt_free_info_from_invocation_list(req_info);
 838                                         g_array_free(out_param, TRUE);
 839
 840                                 }
 841                         }
 842                         break;
 843                 }
 844                 case BT_MESH_NODE_CONFIGURE_KEY: {
 845                         bluetooth_mesh_key_configure_t *event;
 846                         bluetooth_mesh_key_configure_t *req;
 847
 848                         event = (bluetooth_mesh_key_configure_t*) param;
 849                         req = (bluetooth_mesh_key_configure_t*)req_info->user_data;
 850
 851                         if (!g_strcmp0(req->net_uuid, event->net_uuid) &&
 852                                 req->primary_unicast == event->primary_unicast &&
 853                                 req->is_netkey == event->is_netkey) {
 854                                 /* Send Event */
 855                                 __bt_mesh_send_node_key_configuration_event(result, event);
 856
 857                                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
 858                                 g_array_append_vals(out_param, event, sizeof(bluetooth_mesh_key_configure_t));
 859
 860                                 /* Return DBUS Invocation*/
 861                                 _bt_service_method_return(req_info->context, out_param, result);
 862                                 _bt_free_info_from_invocation_list(req_info);
 863                                 g_array_free(out_param, TRUE);
 864                         }
 865                         break;
 866                 }
 867                 case BT_MESH_NODE_TTL_EXECUTE: {
 868                         bluetooth_mesh_node_ttl_info_t *event;
 869                         bluetooth_mesh_node_ttl_info_t *req;
 870
 871                         event = (bluetooth_mesh_node_ttl_info_t*) param;
 872                         req = (bluetooth_mesh_node_ttl_info_t*)req_info->user_data;
 873                         req->ttl = event->ttl;
 874
 875                         if (!g_strcmp0(req->net_uuid, event->net_uuid) &&
 876                                 req->unicast == event->unicast) {
 877                                 /* Send Event */
 878                                 __bt_mesh_send_node_ttl_configuration_event(result, req);
 879
 880                                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
 881                                 g_array_append_vals(out_param, req, sizeof(bluetooth_mesh_node_ttl_info_t));
 882
 883                                 /* Return DBUS Invocation*/
 884                                 _bt_service_method_return(req_info->context, out_param, result);
 885                                 _bt_free_info_from_invocation_list(req_info);
 886                                 g_array_free(out_param, TRUE);
 887                         }
 888                         break;
 889                 }
 890                 case BT_MESH_MODEL_CONFIGURE_APPKEY: {
 891                         bluetooth_mesh_model_configure_t *event;
 892                         bluetooth_mesh_model_configure_t *req;
 893
 894                         event = (bluetooth_mesh_model_configure_t*) param;
 895                         req = (bluetooth_mesh_model_configure_t*)req_info->user_data;
 896
 897                         if (!g_strcmp0(req->net_uuid, event->net_uuid) &&
 898                                 req->primary_unicast == event->primary_unicast) {
 899                                 /* Send Event */
 900                                 __bt_mesh_send_model_configure_appkey_event(result, req);
 901
 902                                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
 903                                 g_array_append_vals(out_param, req, sizeof(bluetooth_mesh_model_configure_t));
 904
 905                                 /* Return DBUS Invocation*/
 906                                 _bt_service_method_return(req_info->context, out_param, result);
 907                                 _bt_free_info_from_invocation_list(req_info);
 908                                 g_array_free(out_param, TRUE);
 909                         }
 910
 911                         break;
 912                 }
 913                 case BT_MESH_MODEL_GET_APPKEY_LIST: {
 914                         bluetooth_mesh_model_configure_t *event;
 915                         bluetooth_mesh_model_configure_t *req;
 916
 917                         event = (bluetooth_mesh_model_configure_t*) param;
 918                         req = (bluetooth_mesh_model_configure_t*)req_info->user_data;
 919
 920                         if (!g_strcmp0(req->net_uuid, event->net_uuid) &&
 921                                 req->primary_unicast == event->primary_unicast) {
 922                                 /* Send Event */
 923                                 __bt_mesh_send_model_get_appkey_list_event(result, event);
 924
 925                                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
 926                                 g_array_append_vals(out_param, req, sizeof(bluetooth_mesh_model_configure_t));
 927
 928                                 /* Return DBUS Invocation*/
 929                                 _bt_service_method_return(req_info->context, out_param, result);
 930                                 _bt_free_info_from_invocation_list(req_info);
 931                                 g_array_free(out_param, TRUE);
 932                         }
 933                         break;
 934                 }
 935                 case BT_MESH_MODEL_GET_SUBSCRIPTION_LIST: {
 936                         bluetooth_mesh_model_configure_t *event;
 937                         bluetooth_mesh_model_configure_t *req;
 938
 939                         BT_INFO("Mesh: Handle event for BT_MESH_MODEL_GET_SUBSCRIPTION_LIST");
 940                         event = (bluetooth_mesh_model_configure_t*) param;
 941                         req = (bluetooth_mesh_model_configure_t*)req_info->user_data;
 942
 943                         if (!g_strcmp0(req->net_uuid, event->net_uuid) &&
 944                                 req->primary_unicast == event->primary_unicast) {
 945                                 /* Send Event */
 946                                 __bt_mesh_send_model_get_subscription_list_event(result, event);
 947
 948                                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
 949                                 g_array_append_vals(out_param, req, sizeof(bluetooth_mesh_model_configure_t));
 950
 951                                 /* Return DBUS Invocation*/
 952                                 _bt_service_method_return(req_info->context, out_param, result);
 953                                 _bt_free_info_from_invocation_list(req_info);
 954                                 g_array_free(out_param, TRUE);
 955                         }
 956                         break;
 957                 }
 958                 case BT_MESH_MODEL_CONFIG_GROUP_SUB: {
 959                         bluetooth_mesh_model_configure_t *event;
 960                         bluetooth_mesh_model_configure_t *req;
 961
 962                         event = (bluetooth_mesh_model_configure_t*) param;
 963                         req = (bluetooth_mesh_model_configure_t*)req_info->user_data;
 964                         BT_INFO("Mesh: Event Network [%s] Req Network [%s]",
 965                                 event->net_uuid, req->net_uuid);
 966
 967                         BT_INFO("Mesh: Event Unicast [0x%4.4x] Req Unicast [0x%4.4x]",
 968                                 event->primary_unicast, req->primary_unicast);
 969
 970                         if (!g_strcmp0(req->net_uuid, event->net_uuid) &&
 971                                 req->primary_unicast == event->primary_unicast) {
 972
 973                                 req->sub_addr = event->sub_addr;
 974                                 BT_INFO("Mesh: Send event for Model Subscription");
 975                                 /* Send Event */
 976                                 __bt_mesh_send_model_subscription_configure_event(
 977                                         BLUETOOTH_EVENT_MESH_MODEL_SUBSCRIPTION_CONFGURED,
 978                                                 result, req);
 979
 980                                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
 981                                 g_array_append_vals(out_param, req, sizeof(bluetooth_mesh_model_configure_t));
 982
 983                                 /* Return DBUS Invocation*/
 984                                 _bt_service_method_return(req_info->context, out_param, result);
 985                                 _bt_free_info_from_invocation_list(req_info);
 986                                 g_array_free(out_param, TRUE);
 987                         }
 988                         break;
 989                 }
 990                 case BT_MESH_MODEL_CONFIG_VIRTUAL_GROUP_SUB: {
 991                         bluetooth_mesh_model_configure_t *event;
 992                         bluetooth_mesh_model_configure_t *req;
 993
 994                         event = (bluetooth_mesh_model_configure_t*) param;
 995                         req = (bluetooth_mesh_model_configure_t*)req_info->user_data;
 996                         BT_INFO("Mesh: Event Network [%s] Req Network [%s]",
 997                                 event->net_uuid, req->net_uuid);
 998
 999                         BT_INFO("Mesh: Event Unicast [0x%4.4x] Req Unicast [0x%4.4x]",
1000                                 event->primary_unicast, req->primary_unicast);
1001                         if (!g_strcmp0(req->net_uuid, event->net_uuid) &&
1002                                 req->primary_unicast == event->primary_unicast) {
1003                                 /* Send Event */
1004                                 __bt_mesh_send_model_subscription_configure_event( \
1005                                         BLUETOOTH_EVENT_MESH_MODEL_VIRTUAL_SUBSCRIPTION_CONFGURED, \
1006                                                 result, req);
1007
1008                                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
1009                                 g_array_append_vals(out_param, req, sizeof(bluetooth_mesh_model_configure_t));
1010
1011                                 /* Return DBUS Invocation*/
1012                                 _bt_service_method_return(req_info->context, out_param, result);
1013                                 _bt_free_info_from_invocation_list(req_info);
1014                                 g_array_free(out_param, TRUE);
1015
1016                         }
1017                         break;
1018                 }
1019                 case BT_MESH_MODEL_GET_PUBLICATION: {
1020                         BT_INFO("Mesh: Event for Model Get Publication Request");
1021                         bluetooth_mesh_model_configure_t *event;
1022                         bluetooth_mesh_model_configure_t *req;
1023
1024                         event = (bluetooth_mesh_model_configure_t*) param;
1025                         req = (bluetooth_mesh_model_configure_t*)req_info->user_data;
1026
1027                         if (!g_strcmp0(req->net_uuid, event->net_uuid) &&
1028                                         req->primary_unicast == event->primary_unicast) {
1029                                 /* Send Event */
1030                                 BT_INFO("Mesh: Send Model Publication status for Get Request");
1031                                 __bt_mesh_send_model_publication_status_event( \
1032                                                 BLUETOOTH_EVENT_MESH_MODEL_PUBLICATION_STATUS, \
1033                                                 result, event);
1034
1035                                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
1036                                 g_array_append_vals(out_param, req, sizeof(bluetooth_mesh_model_configure_t));
1037
1038                                 /* Return DBUS Invocation*/
1039                                 _bt_service_method_return(req_info->context, out_param, result);
1040                                 _bt_free_info_from_invocation_list(req_info);
1041                                 g_array_free(out_param, TRUE);
1042                         }
1043                         break;
1044                 }
1045                 case BT_MESH_MODEL_SET_PUBLICATION: {
1046                         BT_INFO("Mesh: Event for Model Set Publication Request");
1047                         bluetooth_mesh_model_configure_t *event;
1048                         bluetooth_mesh_model_configure_t *req;
1049
1050                         event = (bluetooth_mesh_model_configure_t*) param;
1051                         req = (bluetooth_mesh_model_configure_t*)req_info->user_data;
1052
1053                         if (!g_strcmp0(req->net_uuid, event->net_uuid) &&
1054                                 req->primary_unicast == event->primary_unicast) {
1055                                 /* Send Event */
1056                                 BT_INFO("Mesh: Send Model Publication status for Set Request");
1057                                 __bt_mesh_send_model_publication_status_event( \
1058                                         BLUETOOTH_EVENT_MESH_MODEL_PUBLICATION_STATUS, \
1059                                                 result, req);
1060
1061                                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
1062                                 g_array_append_vals(out_param, req, sizeof(bluetooth_mesh_model_configure_t));
1063
1064                                 /* Return DBUS Invocation*/
1065                                 _bt_service_method_return(req_info->context, out_param, result);
1066                                 _bt_free_info_from_invocation_list(req_info);
1067                                 g_array_free(out_param, TRUE);
1068                         }
1069                         break;
1070                 }
1071                 default:
1072                         BT_DBG("Unknown function(%d)", service_function);
1073                         break;
1074                 }
1075         }
1076 }
1077
1078 const char *__mesh_status_to_string(uint8_t err)
1079 {
1080         switch (err) {
1081         case MESH_STATUS_SUCCESS: return "Success";
1082         case MESH_STATUS_INVALID_ADDRESS: return "Invalid Address";
1083         case MESH_STATUS_INVALID_MODEL: return "Invalid Model";
1084         case MESH_STATUS_INVALID_APPKEY: return "Invalid AppKey";
1085         case MESH_STATUS_INVALID_NETKEY: return "Invalid NetKey";
1086         case MESH_STATUS_INSUFF_RESOURCES: return "Insufficient Resources";
1087         case MESH_STATUS_IDX_ALREADY_STORED: return "Key Idx Already Stored";
1088         case MESH_STATUS_INVALID_PUB_PARAM: return "Invalid Publish Parameters";
1089         case MESH_STATUS_NOT_SUB_MOD: return "Not a Subscribe Model";
1090         case MESH_STATUS_STORAGE_FAIL: return "Storage Failure";
1091         case MESH_STATUS_FEATURE_NO_SUPPORT: return "Feature Not Supported";
1092         case MESH_STATUS_CANNOT_UPDATE: return "Cannot Update";
1093         case MESH_STATUS_CANNOT_REMOVE: return "Cannot Remove";
1094         case MESH_STATUS_CANNOT_BIND: return "Cannot bind";
1095         case MESH_STATUS_UNABLE_CHANGE_STATE: return "Unable to change state";
1096         case MESH_STATUS_CANNOT_SET: return "Cannot set";
1097         case MESH_STATUS_UNSPECIFIED_ERROR: return "Unspecified error";
1098         case MESH_STATUS_INVALID_BINDING: return "Invalid Binding";
1099
1100         default: return "Unknown";
1101         }
1102 }
1103
1104 static void __mesh_handle_model_subscription_event(int result,
1105                 bluetooth_mesh_model_configure_t *param,
1106                         const struct mesh_config_cmd *cmd)
1107 {
1108         BT_INFO("Mesh: Model Subscription Event: Request [%d]", cmd->opcode);
1109         switch (cmd->opcode) {
1110         /* Fall through */
1111         case MESH_OPCODE_CONFIG_MODEL_SUB_ADD:
1112         case MESH_OPCODE_CONFIG_MODEL_SUB_DELETE:
1113         case MESH_OPCODE_CONFIG_MODEL_SUB_OVERWRITE:
1114                 /* Model Bind/UnBind Event */
1115         BT_INFO("Mesh: Handle Event for Request: BT_MESH_MODEL_CONFIG_GROUP_SUB");
1116         __bt_mesh_handle_pending_dev_config_request_info(result,
1117                         BT_MESH_MODEL_CONFIG_GROUP_SUB, param,
1118                                 sizeof(bluetooth_mesh_model_configure_t));
1119                 break;
1120         case MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_ADD:
1121         case MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_DELETE:
1122         case MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_OVERWRITE:
1123         BT_INFO("Mesh: Handle Event for Request: BT_MESH_MODEL_CONFIG_VIRTUAL_GROUP_SUB");
1124         __bt_mesh_handle_pending_dev_config_request_info(result,
1125                         BT_MESH_MODEL_CONFIG_VIRTUAL_GROUP_SUB, param,
1126                                 sizeof(bluetooth_mesh_model_configure_t));
1127                 break;
1128         case MESH_OPCODE_CONFIG_MODEL_SUB_DELETE_ALL:
1129         BT_INFO("Mesh: Handle Event for Request: MESH_OPCODE_CONFIG_MODEL_SUB_DELETE_ALL");
1130         __bt_mesh_handle_pending_dev_config_request_info(result,
1131                         BT_MESH_MODEL_CONFIG_GROUP_SUB, param,
1132                                 sizeof(bluetooth_mesh_model_configure_t));
1133         __bt_mesh_handle_pending_dev_config_request_info(result,
1134                         BT_MESH_MODEL_CONFIG_VIRTUAL_GROUP_SUB, param,
1135                                 sizeof(bluetooth_mesh_model_configure_t));
1136                 break;
1137         default:
1138                 break;
1139         }
1140 }
1141
1142 void _bt_mesh_config_client_devkey_msg_handler(
1143                 event_mesh_devkey_message_t *event)
1144 {
1145         uint32_t opcode;
1146         const struct mesh_config_cmd *cmd;
1147         uint16_t data_len = event->data_len;
1148         uint8_t *data = event->data;
1149         int result = BLUETOOTH_ERROR_NONE;
1150         uint16_t app_idx;
1151         uint16_t addr;
1152         uint16_t net_idx;
1153         uint16_t elem_addr;
1154         uint16_t ele_addr;
1155         uint32_t mod_id;
1156         int n;
1157         struct mesh_pending_request *req;
1158
1159         if (_bt_mesh_util_opcode_get(data, data_len, &opcode, &n) == false)
1160                 return;
1161
1162         BT_INFO("Mesh: Opcode of response data [0x%2.2x], actual data len [%d]", opcode, n);
1163         data_len -= n;
1164         data += n;
1165
1166         BT_INFO("Mesh: Received %s (len %u) opcode [0x%2.2x]",
1167                 __mesh_get_opcode_string(opcode), data_len, opcode);
1168
1169         req = __bt_mesh_get_request_by_response(event->source,
1170                 event->net_uuid.uuid, (opcode & ~MESH_OPCODE_UNRELIABLE));
1171         if (req) {
1172                 BT_INFO("Mesh: Got Config Request");
1173                 cmd = req->cmd;
1174                 l_queue_remove(pending_requests, req);
1175                 __mesh_request_remove(req);
1176         } else {
1177                 cmd = NULL;
1178         }
1179
1180
1181         switch (opcode & ~MESH_OPCODE_UNRELIABLE) {
1182         default:
1183                 return;
1184         case MESH_OPCODE_CONFIG_MODEL_PUB_STATUS: {
1185                 if (data_len != 12 && data_len != 14)
1186                         break;
1187                 bluetooth_mesh_model_configure_t param;
1188                 memset(&param, 0x00, sizeof(bluetooth_mesh_model_configure_t));
1189
1190                 _bt_mesh_util_convert_hex_to_string((uint8_t *) event->net_uuid.uuid, 16, param.net_uuid,
1191                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
1192
1193                 BT_INFO("\nNode %4.4x Model Publication status %s\n",
1194                                 event->source, __mesh_status_to_string(data[0]));
1195
1196                 if (data[0] != MESH_STATUS_SUCCESS)
1197                         result = BLUETOOTH_ERROR_INTERNAL;
1198
1199                 /* Extract Element Address */
1200                 ele_addr = l_get_le16(data + 1);
1201
1202                 /* Extract Model ID */
1203                 if (data_len == 14) {
1204                         /* vendor Model */
1205                         mod_id = l_get_le16(data + 10 + 2);
1206                         mod_id = l_get_le16(data) << 16 | mod_id;
1207                 } else {
1208                         /* BT SIG Model */
1209                         mod_id = l_get_le16(data + 10);
1210                         mod_id = MESH_VENDOR_ID_MASK | mod_id;
1211                 }
1212
1213                 param.model = mod_id;
1214                 BT_INFO("Model ID\t%4.4x\n", mod_id);
1215
1216                 param.primary_unicast = event->source;
1217                 param.elem_index = ele_addr - event->source;
1218                 /* Extract Publish Address */
1219                 param.pub_addr = l_get_le16(data + 3);
1220                 BT_INFO("Mesh: Pub Address [0x%2.2x]", param.pub_addr);
1221
1222                 /* Extract Appkey Index */
1223                 param.appkey_idx =  l_get_le16(data + 5);
1224                 BT_INFO("Mesh: AppKey Idx [0x%2.2x]", param.appkey_idx);
1225
1226                 /* Extract TTL */
1227                 param.ttl = data[6];
1228                 BT_INFO("Mesh: TTL [0x%x]", param.ttl);
1229
1230                 /* Extract Period */
1231                 param.period = data[7];
1232                 if (!cmd)
1233                         break;
1234
1235                 if (cmd->opcode == MESH_OPCODE_CONFIG_MODEL_PUB_GET)
1236                         __bt_mesh_handle_pending_dev_config_request_info(result,
1237                                 BT_MESH_MODEL_GET_PUBLICATION, &param,
1238                                 sizeof(bluetooth_mesh_model_configure_t));
1239                 else
1240                         __bt_mesh_handle_pending_dev_config_request_info(result,
1241                                 BT_MESH_MODEL_SET_PUBLICATION, &param,
1242                                 sizeof(bluetooth_mesh_model_configure_t));
1243                 break;
1244         }
1245         case MESH_OPCODE_CONFIG_MODEL_SUB_STATUS: {
1246                 if (data_len != 7 && data_len != 9)
1247                         break;
1248                 bluetooth_mesh_model_configure_t param;
1249                 memset(&param, 0x00, sizeof(bluetooth_mesh_model_configure_t));
1250
1251                 _bt_mesh_util_convert_hex_to_string(
1252                         (uint8_t *) event->net_uuid.uuid, 16, param.net_uuid,
1253                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
1254
1255                 BT_INFO("\nNode %4.4x Subscription status %s\n",
1256                                 event->source, __mesh_status_to_string(data[0]));
1257
1258                 if (data[0] != MESH_STATUS_SUCCESS)
1259                         result = BLUETOOTH_ERROR_INTERNAL;
1260
1261                 if (!cmd) {
1262                         BT_INFO("Mesh: Command not found!!");
1263                         break;
1264                 }
1265
1266                 ele_addr = l_get_le16(data + 1);
1267                 addr = l_get_le16(data + 3);
1268                 BT_INFO("Element Addr\t%4.4x\n", ele_addr);
1269                 BT_INFO("Message Source Addr\t%4.4x\n", event->source);
1270
1271                 if (data_len == 9) {
1272                         /* vendor Model */
1273                         mod_id = l_get_le16(data + 5 + 2);
1274                         mod_id = l_get_le16(data) << 16 | mod_id;
1275                 } else {
1276                         /* BT SIG Model */
1277                         mod_id = l_get_le16(data + 5);
1278                         mod_id = MESH_VENDOR_ID_MASK | mod_id;
1279                 }
1280
1281                 param.primary_unicast = event->source;
1282                 param.elem_index = ele_addr - event->source;
1283                 /* Subscription address, unassigned address in case of Delete All command */
1284                 param.sub_addr = addr;
1285                 param.model = mod_id;
1286                 BT_INFO("Subscr Addr\t%4.4x\n", addr);
1287                 BT_INFO("Model ID\t%4.4x\n", mod_id);
1288
1289                 if (data[0] == MESH_STATUS_SUCCESS) {
1290                         BT_INFO("_bt_mesh_network_add_model_subscription called or not");
1291                         /* Update cdb */
1292                         switch (cmd->opcode) {
1293                         case MESH_OPCODE_CONFIG_MODEL_SUB_ADD:
1294                         case MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_ADD:
1295                                 if (!_bt_mesh_network_add_model_subscription(
1296                                         event->net_uuid.uuid, event->source,
1297                                         ele_addr - event->source, mod_id, addr)) {
1298                                         BT_INFO("Failed to add model subscription!");
1299                                 }
1300                                 BT_INFO("_bt_mesh_network_add_model_subscription called or not");
1301                         break;
1302                         case MESH_OPCODE_CONFIG_MODEL_SUB_DELETE:
1303                         case MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_DELETE:
1304                                 if (!_bt_mesh_network_delete_model_subscription(
1305                                         event->net_uuid.uuid, event->source,
1306                                         ele_addr - event->source, mod_id, addr)) {
1307                                         BT_INFO("Failed to delete model subscription!");
1308                                 }
1309                         break;
1310                         case MESH_OPCODE_CONFIG_MODEL_SUB_DELETE_ALL:
1311                                 if (!_bt_mesh_network_delete_all_model_subscription(
1312                                         event->net_uuid.uuid, event->source,
1313                                         ele_addr - event->source, mod_id)) {
1314                                         BT_INFO("Failed to delete all model subscription!");
1315                                 }
1316                         break;
1317                         case MESH_OPCODE_CONFIG_MODEL_SUB_OVERWRITE:
1318                         case MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_OVERWRITE:
1319                                 if (!_bt_mesh_network_overwrite_model_subscription(
1320                                         event->net_uuid.uuid, event->source,
1321                                         ele_addr - event->source, mod_id, addr)) {
1322                                         BT_INFO("Failed to overwrite model subscription!");
1323                                 }
1324                         break;
1325                         }
1326                 }
1327
1328                 if (cmd)
1329                         __mesh_handle_model_subscription_event(result, &param, cmd);
1330
1331                 break;
1332         }
1333         case MESH_OPCODE_CONFIG_DEFAULT_TTL_STATUS: {
1334                 if (data_len != 1)
1335                         break;
1336                 bluetooth_mesh_node_ttl_info_t param;
1337                 memset(&param, 0x00, sizeof(bluetooth_mesh_node_ttl_info_t));
1338
1339                 BT_INFO("Node %4.4x Default TTL %d", event->source, data[0]);
1340                  _bt_mesh_util_convert_hex_to_string(
1341                         (uint8_t *) event->net_uuid.uuid, 16, param.net_uuid,
1342                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
1343                 param.unicast = event->source;
1344                 param.ttl = data[0];
1345
1346                 if (!_bt_mesh_network_save_remote_node_ttl(event->net_uuid.uuid,
1347                                 event->source,  data[0])) {
1348                         result = BLUETOOTH_ERROR_INTERNAL;
1349                         BT_INFO("Failed to save node TTL");
1350                 }
1351
1352                 /* Remote Node TTL event */
1353                 __bt_mesh_handle_pending_dev_config_request_info(result,
1354                         BT_MESH_NODE_TTL_EXECUTE, &param,
1355                                 sizeof(bluetooth_mesh_node_ttl_info_t));
1356                 break;
1357         }
1358         case MESH_OPCODE_MODEL_APP_STATUS: {
1359                 if (data_len != 7 && data_len != 9)
1360                         break;
1361                 bluetooth_mesh_model_configure_t param;
1362                 memset(&param, 0x00, sizeof(bluetooth_mesh_model_configure_t));
1363
1364                  _bt_mesh_util_convert_hex_to_string(
1365                         (uint8_t *) event->net_uuid.uuid, 16, param.net_uuid,
1366                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
1367                 BT_INFO("Node %4.4x: Model App status %s\n", event->source,
1368                         __mesh_status_to_string(data[0]));
1369
1370                 if (data[0] != MESH_STATUS_SUCCESS)
1371                         result = BLUETOOTH_ERROR_INTERNAL;
1372
1373                 elem_addr = l_get_le16(data + 1);
1374                 app_idx = l_get_le16(data + 3);
1375
1376                 BT_INFO("Element Addr\t%4.4x", elem_addr);
1377                 if (data_len == 9) {
1378                         /* vendor Model */
1379                         mod_id = l_get_le16(data + 5 + 2);
1380                         mod_id = l_get_le16(data) << 16 | mod_id;
1381                 } else {
1382                         /* BT SIG Model */
1383                         mod_id = l_get_le16(data + 5);
1384                         mod_id = MESH_VENDOR_ID_MASK | mod_id;
1385                 }
1386
1387                 param.primary_unicast = event->source;
1388                 param.elem_index = elem_addr - event->source;
1389                 param.appkey_idx = app_idx;
1390                 param.model = mod_id;
1391                 BT_INFO("AppIdx\t\t%u (0x%3.3x)\n ", app_idx, app_idx);
1392
1393                 /* Model Bind/UnBind Event */
1394                 __bt_mesh_handle_pending_dev_config_request_info(result,
1395                         BT_MESH_MODEL_CONFIGURE_APPKEY, &param,
1396                                 sizeof(bluetooth_mesh_model_configure_t));
1397                 break;
1398         }
1399         case MESH_OPCODE_MODEL_APP_LIST: {
1400                 if (data_len < 5)
1401                         break;
1402                 GArray *garray;
1403                 int total = 0;
1404                 bluetooth_mesh_model_configure_t param;
1405                 memset(&param, 0x00, sizeof(bluetooth_mesh_model_configure_t));
1406
1407                 _bt_mesh_util_convert_hex_to_string(
1408                         (uint8_t *) event->net_uuid.uuid, 16, param.net_uuid,
1409                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
1410
1411                 garray = g_array_new(FALSE, FALSE, sizeof(gchar));
1412
1413                 BT_INFO("\nNode %4.4x Model AppIdx status %s\n",
1414                                 event->source, __mesh_status_to_string(data[0]));
1415
1416                 BT_INFO("Element Addr\t%4.4x\n", l_get_le16(data + 1));
1417                 BT_INFO("Model ID\t%4.4x\n", l_get_le16(data + 3));
1418
1419                 elem_addr = l_get_le16(data + 1);
1420                 /* BT SIG Model */
1421                 mod_id = l_get_le16(data + 3);
1422                 mod_id = MESH_VENDOR_ID_MASK | mod_id;
1423
1424                 param.primary_unicast = event->source;
1425                 param.elem_index = elem_addr - event->source;
1426                 param.model = mod_id;
1427
1428                 data += 5;
1429                 data_len -= 5;
1430
1431                 while (data_len >= 3) {
1432                         app_idx = l_get_le16(data) & 0xfff;
1433                         g_array_append_vals(garray, &app_idx, sizeof(uint16_t));
1434                         BT_INFO("\t%u (0x%3.3x)\n", app_idx, app_idx);
1435
1436                         app_idx = l_get_le16(data + 1) >> 4;
1437                         g_array_append_vals(garray, &app_idx, sizeof(uint16_t));
1438                         BT_INFO("\t%u (0x%3.3x)\n", app_idx, app_idx);
1439                         data += 3;
1440                         data_len -= 3;
1441                 }
1442
1443                 if (data_len == 2) {
1444                         app_idx = l_get_le16(data) & 0xfff;
1445                         g_array_append_vals(garray, &app_idx, sizeof(uint16_t));
1446                         BT_INFO("\t %u (0x%3.3x)\n", app_idx, app_idx);
1447                 }
1448                 total = garray->len / sizeof(uint16_t);
1449                 param.appkey_list = (uint16_t **)g_malloc0(sizeof(uint16_t*) * garray->len);
1450                 param.appkeylist_count = total;
1451                 for (int i = 0; i < total; i++) {
1452                         param.appkey_list[i] = g_malloc(sizeof(uint16_t));
1453                         *param.appkey_list[i] = g_array_index(garray, uint16_t, i);
1454                 }
1455                 g_array_free(garray, TRUE);
1456
1457                 __bt_mesh_handle_pending_dev_config_request_info(result,
1458                         BT_MESH_MODEL_GET_APPKEY_LIST, &param,
1459                                 sizeof(bluetooth_mesh_model_configure_t));
1460                 break;
1461         }
1462         case MESH_OPCODE_CONFIG_MODEL_SUB_LIST: {
1463                 if (data_len < 5)
1464                         break;
1465                 int total = 0;
1466                 int i = 0;
1467                 bluetooth_mesh_model_configure_t param;
1468                 memset(&param, 0x00, sizeof(bluetooth_mesh_model_configure_t));
1469
1470                 _bt_mesh_util_convert_hex_to_string((uint8_t *) event->net_uuid.uuid, 16, param.net_uuid,
1471                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
1472
1473                 BT_INFO("\nNode %4.4x BT SIG Model Subscription List status %s\n",
1474                                 event->source, __mesh_status_to_string(data[0]));
1475
1476                 BT_INFO("Element Addr\t%4.4x\n", l_get_le16(data + 1));
1477                 elem_addr = l_get_le16(data + 1);
1478
1479                 /* BT SIG Model */
1480                 mod_id = l_get_le16(data + 3);
1481                 mod_id = MESH_VENDOR_ID_MASK | mod_id;
1482                 BT_INFO("Model ID\t%4.4x\n", mod_id);
1483
1484                 param.primary_unicast = event->source;
1485                 param.elem_index = elem_addr - event->source;
1486                 param.model = mod_id;
1487                 BT_INFO("Mesh: Data length of All Models Together [%d]", data_len - 5);
1488                 total = (data_len -  5)/2;
1489                 param.sublist_count = total;
1490                 BT_INFO("Mesh: Total Number of subscriptions [%d]", total);
1491                 if (total) {
1492                         param.sub_list = (uint16_t **)g_malloc0(sizeof(uint16_t*) * total);
1493
1494                         i = 5;
1495                         for (int k = 0; i < data_len; k++, i += 2) {
1496                                 BT_INFO("Mesh: Subscription Addr \t\t%4.4x\n ", l_get_le16(data + i));
1497                                 param.sub_list[k] = g_malloc(sizeof(uint16_t));
1498                                 *param.sub_list[k] = l_get_le16(data + i);
1499                         }
1500                 }
1501
1502                 /* <TO-DO> Update model sub in cdb */
1503
1504                 __bt_mesh_handle_pending_dev_config_request_info(result,
1505                         BT_MESH_MODEL_GET_SUBSCRIPTION_LIST, &param,
1506                                 sizeof(bluetooth_mesh_model_configure_t));
1507                 break;
1508         }
1509         case MESH_OPCODE_CONFIG_VEND_MODEL_SUB_LIST: {
1510                 if (data_len < 7)
1511                         break;
1512                 int total = 0;
1513                 int i = 0;
1514                 bluetooth_mesh_model_configure_t param;
1515                 memset(&param, 0x00, sizeof(bluetooth_mesh_model_configure_t));
1516
1517                 _bt_mesh_util_convert_hex_to_string(
1518                         (uint8_t *) event->net_uuid.uuid, 16, param.net_uuid,
1519                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
1520
1521                 BT_INFO("\nNode %4.4x Vendor Model Subscription List status %s\n",
1522                                 event->source, __mesh_status_to_string(data[0]));
1523
1524                 BT_INFO("Element Addr\t%4.4x\n", l_get_le16(data + 1));
1525                 elem_addr = l_get_le16(data + 1);
1526
1527                 /* VENDOR Model */
1528                 mod_id = l_get_le16(data + 5);
1529                 mod_id = l_get_le16(data + 3) << 16 | mod_id;
1530
1531                 BT_INFO("Model ID\t%4.4x\n", mod_id);
1532
1533                 param.primary_unicast = event->source;
1534                 param.elem_index = elem_addr - event->source;
1535                 param.model = mod_id;
1536
1537                 BT_INFO("Mesh: Data length of All Models Together [%d]", data_len - 7);
1538                 total = (data_len -  7)/2;
1539                 param.sublist_count = total;
1540
1541                 BT_INFO("Mesh: Total Number of subscriptions [%d]", total);
1542                 if (total) {
1543                         param.sub_list = (uint16_t **)g_malloc0(sizeof(uint16_t*) * total);
1544
1545                         i = 7;
1546                         for (int k = 0; i < data_len; k++, i += 2) {
1547                                 BT_INFO("Mesh: Subscription Addr \t\t%4.4x\n ", l_get_le16(data + i));
1548                                 param.sub_list[k] = g_malloc(sizeof(uint16_t));
1549                                 *param.sub_list[k] = l_get_le16(data + i);
1550                         }
1551                 }
1552                 __bt_mesh_handle_pending_dev_config_request_info(result,
1553                         BT_MESH_MODEL_GET_SUBSCRIPTION_LIST, &param,
1554                                 sizeof(bluetooth_mesh_model_configure_t));
1555                 break;
1556         }
1557         case MESH_OPCODE_DEV_COMP_STATUS: {
1558                 if (data_len < MESH_MINIMUM_COMPOSITION_LEN)
1559                         break;
1560                 bluetooth_mesh_node_features_t features;
1561                 memset(&features, 0x00, sizeof(bluetooth_mesh_node_features_t));
1562                 BT_INFO("Mesh: Got Response for Device Composition Data");
1563                 __bt_mesh_print_device_composition_data(data, data_len);
1564
1565                 if (!_bt_mesh_network_save_remote_node_composition(
1566                         event->net_uuid.uuid, event->source, data, data_len)) {
1567                         result = BLUETOOTH_ERROR_INTERNAL;
1568                         BT_INFO("Failed to save node composition!");
1569                 }
1570                 /* Browse Remote Node event */
1571                 __bt_mesh_handle_pending_dev_config_request_info(result,
1572                         BT_MESH_NODE_BROWSE, event, sizeof(event_mesh_devkey_message_t));
1573
1574                 /* Vendor Features Discover event */
1575                 _bt_mesh_util_convert_hex_to_string(
1576                         (uint8_t *) event->net_uuid.uuid, 16, features.net_uuid,
1577                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
1578                 features.unicast = event->source;
1579                 BT_INFO("Mesh: Net UUID [%s]", features.net_uuid);
1580
1581                 BT_INFO("Mesh: Composition status for node unicast [0x%2.2x]",
1582                         event->source);
1583                 if (!_bt_mesh_node_get_vendor_features(event->net_uuid.uuid,
1584                         event->source, &features)) {
1585                         BT_ERR("Mesh: Failed to get Vendor Specific Infor for [0x%2.2x]",
1586                                 event->source);
1587                         result = BLUETOOTH_ERROR_INTERNAL;
1588                 } else {
1589                         BT_INFO("Mesh: Got Feature informations for [0x%2.2x]",
1590                                 event->source);
1591                 }
1592                 __bt_mesh_handle_pending_dev_config_request_info(result,
1593                         BT_MESH_NODE_GET_VENDOR_FEATURES, &features,
1594                                 sizeof(bluetooth_mesh_node_features_t));
1595                 break;
1596         }
1597         case MESH_OPCODE_NETKEY_STATUS: {
1598                 if (data_len != 3)
1599                         break;
1600
1601                 bluetooth_mesh_key_configure_t param;
1602                 memset(&param, 0x00, sizeof(bluetooth_mesh_key_configure_t));
1603
1604                 BT_INFO("Mesh: Node %4.4x NetKey status %s",
1605                         event->source,  __mesh_status_to_string(data[0]));
1606                 net_idx = l_get_le16(data + 1) & 0xfff;
1607
1608                 BT_INFO("\tNetKey %u (0x%3.3x)", net_idx, net_idx);
1609
1610                 if (data[0] != 0)
1611                         result = BLUETOOTH_ERROR_INTERNAL;
1612
1613                 if (!cmd)
1614                         break;
1615
1616                 _bt_mesh_util_convert_hex_to_string(
1617                         (uint8_t *) event->net_uuid.uuid, 16, param.net_uuid,
1618                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
1619                 param.primary_unicast = event->source;
1620                 param.netkey_idx = net_idx;
1621                 param.is_netkey = true;
1622
1623                 BT_INFO("Mesh: Resp recvd from node unicast [0x%4.4x]", event->source);
1624                 if (cmd->opcode == MESH_OPCODE_NETKEY_ADD) {
1625                         BT_INFO("Mesh: Resp recvd: MESH_OPCODE_NETKEY_ADD");
1626                         if (result == BLUETOOTH_ERROR_NONE) {
1627                                 if (!_bt_mesh_network_save_remote_node_netkey(
1628                                                         event->net_uuid.uuid, event->source, net_idx)) {
1629                                         result = BLUETOOTH_ERROR_INTERNAL;
1630                                         BT_INFO("Failed to save node Netkey!");
1631                                 }
1632                         }
1633                         param.op = BLUETOOTH_MESH_NODE_KEY_ADD;
1634                 } else if (cmd->opcode == MESH_OPCODE_NETKEY_DELETE) {
1635                         BT_INFO("Mesh: Resp recvd: MESH_OPCODE_NETKEY_DELETE");
1636                         if (result == BLUETOOTH_ERROR_NONE) {
1637                                 if (!_bt_mesh_network_delete_remote_node_netkey(
1638                                                         event->net_uuid.uuid, event->source, net_idx)) {
1639                                         result = BLUETOOTH_ERROR_INTERNAL;
1640                                         BT_INFO("Failed to delete node Netkey!");
1641                                 }
1642                         }
1643                         param.op = BLUETOOTH_MESH_NODE_KEY_DELETE;
1644                 } else if (cmd->opcode == MESH_OPCODE_NETKEY_UPDATE) {
1645                         BT_INFO("Mesh: Resp recvd: MESH_OPCODE_NETKEY_UPDATE");
1646                         param.op = BLUETOOTH_MESH_NODE_KEY_UPDATE;
1647                 }
1648                 /* Node Net Key Configure event */
1649                 __bt_mesh_handle_pending_dev_config_request_info(result,
1650                         BT_MESH_NODE_CONFIGURE_KEY,
1651                                 &param, sizeof(bluetooth_mesh_key_configure_t));
1652                 break;
1653         }
1654         case MESH_OPCODE_APPKEY_STATUS: {
1655                 if (data_len != 4)
1656                         break;
1657
1658                 bluetooth_mesh_key_configure_t param;
1659                 memset(&param, 0x00, sizeof(bluetooth_mesh_key_configure_t));
1660
1661                 BT_INFO("Mesh: Node %4.4x AppKey status %s\n", event->source,
1662                                 __mesh_status_to_string(data[0]));
1663                 net_idx = l_get_le16(data + 1) & 0xfff;
1664                 app_idx = l_get_le16(data + 2) >> 4;
1665
1666                 BT_INFO("NetKey\t%u (0x%3.3x)\n", net_idx, net_idx);
1667                 BT_INFO("AppKey\t%u (0x%3.3x)\n", app_idx, app_idx);
1668
1669                 if (data[0] != MESH_STATUS_SUCCESS)
1670                         result = BLUETOOTH_ERROR_INTERNAL;
1671
1672                 if (!cmd)
1673                         break;
1674
1675                 _bt_mesh_util_convert_hex_to_string(
1676                         (uint8_t *) event->net_uuid.uuid, 16, param.net_uuid,
1677                                 BLUETOOTH_MESH_NETWORK_UUID_STRING_LENGTH + 1);
1678
1679                 param.primary_unicast = event->source;
1680                 param.netkey_idx = net_idx;
1681                 param.appkey_idx = app_idx;
1682                 param.is_netkey = false;
1683
1684                 if (cmd->opcode == MESH_OPCODE_APPKEY_ADD) {
1685                         BT_INFO("Mesh: Resp recvd: MESH_OPCODE_APPKEY_ADD");
1686                         if (result == BLUETOOTH_ERROR_NONE) {
1687                                 if (!_bt_mesh_network_save_remote_node_appkey(
1688                                                 event->net_uuid.uuid, event->source,
1689                                                 net_idx, app_idx)) {
1690                                         result = BLUETOOTH_ERROR_INTERNAL;
1691                                         BT_INFO("Failed to save node Appkey!");
1692                                 }
1693                         }
1694                         param.op = BLUETOOTH_MESH_NODE_KEY_ADD;
1695                 } else if (cmd->opcode == MESH_OPCODE_APPKEY_DELETE) {
1696                         BT_INFO("Mesh: Resp recvd: MESH_OPCODE_APPKEY_DELETE");
1697                         if (result == BLUETOOTH_ERROR_NONE) {
1698                                 if (!_bt_mesh_network_delete_remote_node_appkey(
1699                                                 event->net_uuid.uuid, event->source,
1700                                                 net_idx, app_idx)) {
1701                                         result = BLUETOOTH_ERROR_INTERNAL;
1702                                         BT_INFO("Failed to delete node Appkey!");
1703                                 }
1704                         }
1705                         param.op = BLUETOOTH_MESH_NODE_KEY_DELETE;
1706                 } else if (cmd->opcode == MESH_OPCODE_APPKEY_UPDATE) {
1707                         BT_INFO("Mesh: Resp recvd: MESH_OPCODE_APPKEY_UPDATE");
1708                         param.op = BLUETOOTH_MESH_NODE_KEY_UPDATE;
1709                 }
1710
1711                 /* Node App Key Configure event */
1712                 __bt_mesh_handle_pending_dev_config_request_info(result,
1713                         BT_MESH_NODE_CONFIGURE_KEY,
1714                                 &param, sizeof(bluetooth_mesh_key_configure_t));
1715                 break;
1716         }
1717         }
1718 }
1719
1720 static gboolean __bt_mesh_vendor_feature_event_handler(gpointer data)
1721 {
1722         bluetooth_mesh_node_features_t *result = (bluetooth_mesh_node_features_t*) data;
1723         __bt_mesh_handle_pending_dev_config_request_info(
1724                 BLUETOOTH_ERROR_NONE,
1725                         BT_MESH_NODE_GET_VENDOR_FEATURES,
1726                                 result, sizeof(bluetooth_mesh_node_features_t));
1727         g_free(result);
1728         return FALSE;
1729 }
1730
1731 int _bt_mesh_node_discover_vendor_features(const char *app_cred, const char *sender,
1732                 bluetooth_mesh_node_features_t *req)
1733 {
1734         int ret = OAL_STATUS_SUCCESS;
1735         uint16_t dest;
1736         uint16_t netkey_idx;
1737         uint16_t data_len;
1738         oal_uuid_t net_uuid;
1739         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
1740
1741         BT_INFO("Mesh: Vendor features for Network UUID [%s]", req->net_uuid);
1742         _bt_mesh_util_convert_string_to_hex(req->net_uuid,
1743                         strlen(req->net_uuid), net_uuid.uuid, 16);
1744         /* Check if Node's vendor features are already svaed or not */
1745         if (_bt_mesh_node_get_vendor_features(net_uuid.uuid, req->unicast, req)) {
1746                 BT_INFO("Mesh: Vendor Features already available for Node: Unicast [0x%.2x]",
1747                                 req->unicast);
1748                 /* Schedule event ot Application */
1749                 bluetooth_mesh_node_features_t *event = \
1750                         g_memdup(req, sizeof(bluetooth_mesh_node_features_t));
1751                 g_idle_add(__bt_mesh_vendor_feature_event_handler, (gpointer) event);
1752                 return BLUETOOTH_ERROR_NONE;
1753         }
1754
1755         /* If Scanning is going on */
1756         if (_bt_mesh_is_provisioning() ||
1757                         _bt_mesh_is_scanning()) {
1758                 BT_ERR("Device is buzy..");
1759                 return BLUETOOTH_ERROR_DEVICE_BUSY;
1760         }
1761
1762         _bt_mesh_util_convert_string_to_hex(req->net_uuid,
1763                         strlen(req->net_uuid), net_uuid.uuid, 16);
1764
1765         dest = req->unicast;
1766         BT_INFO("Mesh: Get Vendor Features for Remote Node Unicast [0x%2.2x]", dest);
1767
1768         /* Check pending request */
1769         if (_bt_mesh_check_pending_request(MESH_OPCODE_DEV_COMP_GET,
1770                                 dest, net_uuid.uuid)) {
1771                 BT_ERR("Device is buzy..");
1772                 return BLUETOOTH_ERROR_DEVICE_BUSY;
1773         }
1774
1775         BT_INFO("Mesh: Browse Remote Node: Unicast [0x%2.2x]", dest);
1776         /* Get Subnet index of the rmeote node for TX encryption */
1777         netkey_idx = _bt_mesh_node_get_subnet_idx(net_uuid.uuid, dest);
1778         if (netkey_idx == MESH_NET_IDX_INVALID)
1779                 return BLUETOOTH_ERROR_INTERNAL;
1780
1781         data_len = _bt_mesh_util_opcode_set(MESH_OPCODE_DEV_COMP_GET,
1782                         buffer);
1783
1784         /* By default, use page 0 */
1785         buffer[data_len++] = 0;
1786         ret = mesh_conf_send_message(&net_uuid, dest, true,
1787                         netkey_idx, buffer, data_len);
1788
1789         if (ret != OAL_STATUS_SUCCESS) {
1790                 BT_ERR("ret: %d", ret);
1791                 return BLUETOOTH_ERROR_INTERNAL;
1792         }
1793
1794         /* Queue the request with timeout */
1795         __bt_mesh_add_request(MESH_OPCODE_DEV_COMP_GET,
1796                         dest, net_uuid.uuid, NULL);
1797         return BLUETOOTH_ERROR_NONE;
1798 }
1799
1800 int _bt_mesh_browse_remote_node(const char *app_cred,
1801         const char *sender,
1802                 bluetooth_mesh_node_discover_t *req)
1803 {
1804         int ret = OAL_STATUS_SUCCESS;
1805         uint16_t dest;
1806         uint16_t netkey_idx;
1807         uint16_t data_len;
1808         oal_uuid_t net_uuid;
1809         oal_uuid_t dev_uuid;
1810         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
1811
1812         /* If Scanning is going on */
1813         if (_bt_mesh_is_provisioning() ||
1814                         _bt_mesh_is_scanning()) {
1815                 BT_ERR("Device is buzy..");
1816                 return BLUETOOTH_ERROR_DEVICE_BUSY;
1817         }
1818
1819         _bt_mesh_util_convert_string_to_hex(req->net_uuid,
1820                 strlen(req->net_uuid), net_uuid.uuid, 16);
1821         _bt_mesh_util_convert_string_to_hex(req->dev_uuid,
1822                 strlen(req->dev_uuid), dev_uuid.uuid, 16);
1823
1824         BT_INFO("Mesh: Browse Node UUID [%s]", req->dev_uuid);
1825
1826         /* Get Remote Node unicast address from Dev UUID */
1827         if (!_bt_mesh_node_get_unicast_from_dev_uuid(net_uuid.uuid,
1828                         dev_uuid.uuid, &dest))
1829                 return BLUETOOTH_ERROR_INTERNAL;
1830
1831         BT_INFO("Mesh: Browse Remote Node: Unicast [0x%2.2x]", dest);
1832         /* Check pending request */
1833         if (_bt_mesh_check_pending_request(MESH_OPCODE_DEV_COMP_GET,
1834                         dest, net_uuid.uuid)) {
1835                 BT_ERR("Device is buzy..");
1836                 return BLUETOOTH_ERROR_DEVICE_BUSY;
1837         }
1838
1839         /* Get Subnet index of the rmeote node for TX encryption */
1840         netkey_idx = _bt_mesh_node_get_subnet_idx(net_uuid.uuid, dest);
1841         if (netkey_idx == MESH_NET_IDX_INVALID)
1842                 return BLUETOOTH_ERROR_INTERNAL;
1843
1844         data_len = _bt_mesh_util_opcode_set(MESH_OPCODE_DEV_COMP_GET, buffer);
1845
1846         /* By default, use page 0 */
1847         buffer[data_len++] = 0;
1848         ret = mesh_conf_send_message(&net_uuid, dest, true,
1849                         netkey_idx, buffer, data_len);
1850
1851         if (ret != OAL_STATUS_SUCCESS) {
1852                 BT_ERR("ret: %d", ret);
1853                 return BLUETOOTH_ERROR_INTERNAL;
1854         }
1855
1856         /* Queue the request with timeout */
1857         __bt_mesh_add_request(MESH_OPCODE_DEV_COMP_GET,
1858                         dest, net_uuid.uuid, NULL);
1859         return BLUETOOTH_ERROR_NONE;
1860 }
1861
1862 int _bt_mesh_model_configure_group_subscription(const char *app_cred,
1863                 const char *sender, bluetooth_mesh_model_configure_t *req)
1864 {
1865         int ret = OAL_STATUS_SUCCESS;
1866         uint16_t netkey_idx;
1867         oal_uuid_t net_uuid;
1868         uint16_t data_len;
1869         uint32_t opcode = 0;
1870         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
1871
1872         /* If Scanning is going on */
1873         if (_bt_mesh_is_provisioning() ||
1874                         _bt_mesh_is_scanning()) {
1875                 BT_ERR("Device is buzy..");
1876                 return BLUETOOTH_ERROR_DEVICE_BUSY;
1877         }
1878
1879         BT_INFO("Mesh: group Subscription Req: [%d]", req->op);
1880         if (req->op != BLUETOOTH_MESH_MODEL_SUB_DELETE_ALL) {
1881                 BT_INFO("Mesh: group Subscription Addr [0x%2.2x]", req->sub_addr);
1882
1883                 /* Subscriptio address sanity check */
1884                 if (!MESH_IS_GROUP(req->sub_addr) ||
1885                                 MESH_IS_VIRTUAL(req->sub_addr)) {
1886                         BT_ERR("Mesh: Bad subscription address [0x%2.2x\n]",
1887                                 req->sub_addr);
1888                         return BLUETOOTH_ERROR_INVALID_PARAM;
1889                 }
1890         } else
1891                 BT_INFO("Mesh: group Subscription Req: Delete All");
1892
1893         _bt_mesh_util_convert_string_to_hex(req->net_uuid,
1894                 strlen(req->net_uuid), net_uuid.uuid, 16);
1895         /* Get Subnet index of the remote node for TX encryption */
1896         netkey_idx = _bt_mesh_node_get_subnet_idx(net_uuid.uuid,
1897                                 req->primary_unicast);
1898         if (netkey_idx == MESH_NET_IDX_INVALID)
1899                 return BLUETOOTH_ERROR_INTERNAL;
1900
1901
1902         if (req->op == BLUETOOTH_MESH_MODEL_SUB_ADD)
1903                 opcode = MESH_OPCODE_CONFIG_MODEL_SUB_ADD;
1904         else if (req->op == BLUETOOTH_MESH_MODEL_SUB_DELETE)
1905                 opcode = MESH_OPCODE_CONFIG_MODEL_SUB_DELETE;
1906         else if (req->op == BLUETOOTH_MESH_MODEL_SUB_DELETE_ALL)
1907                 opcode = MESH_OPCODE_CONFIG_MODEL_SUB_DELETE_ALL;
1908         else if (req->op == BLUETOOTH_MESH_MODEL_SUB_OVERWRITE)
1909                 opcode = MESH_OPCODE_CONFIG_MODEL_SUB_OVERWRITE;
1910
1911         /* Check pending request */
1912         if (_bt_mesh_check_pending_request(opcode,
1913                                 req->primary_unicast, net_uuid.uuid)) {
1914                 BT_ERR("Device is buzy..");
1915                 return BLUETOOTH_ERROR_DEVICE_BUSY;
1916         }
1917
1918         data_len = _bt_mesh_util_opcode_set(opcode, buffer);
1919
1920         BT_INFO("Mesh: Group Subscription Primary unicast [0x%2.2x]",
1921                         req->primary_unicast);
1922         /* Element Address */
1923         l_put_le16((req->primary_unicast + req->elem_index),
1924                         buffer + data_len);
1925         data_len += 2;
1926
1927         /* Subscription address */
1928         if (req->op != BLUETOOTH_MESH_MODEL_SUB_DELETE_ALL) {
1929                 l_put_le16(req->sub_addr, buffer + data_len);
1930                 data_len += 2;
1931         }
1932
1933         BT_INFO("Mesh: Group Subscription Model ID [0x%4.4x]", req->model);
1934         /* Insert Model ID */
1935          if (req->model >= 0xFFFF0000) {
1936                 /* 1st 2 octet Company ID is 0xFFFF means, it is BT SIG Model*/
1937                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
1938                 data_len += 2;
1939         } else {
1940                 /* Vendor Model, 1st 2 octetes: Company ID, next 2 octets: Vendor Model ID */
1941                 l_put_le16(req->model & 0xFFFF0000, buffer + data_len);
1942                 data_len += 2;
1943                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
1944                 data_len += 2;
1945         }
1946
1947         ret = mesh_conf_send_message(&net_uuid, req->primary_unicast, true,
1948                         netkey_idx, buffer, data_len);
1949
1950         if (ret != OAL_STATUS_SUCCESS) {
1951                 BT_ERR("ret: %d", ret);
1952                 return BLUETOOTH_ERROR_INTERNAL;
1953         }
1954
1955         BT_INFO("Mesh: Group Subscription Command sent successfully");
1956         /* Queue the request with timeout */
1957         __bt_mesh_add_request(opcode, req->primary_unicast,
1958                 net_uuid.uuid,
1959                         g_memdup(req, sizeof(bluetooth_mesh_model_configure_t)));
1960
1961         return BLUETOOTH_ERROR_NONE;
1962 }
1963
1964 int _bt_mesh_model_configure_virtual_group_subscription(
1965                 const char *app_cred, const char *sender,
1966                         bluetooth_mesh_model_configure_t *req)
1967 {
1968         int ret = OAL_STATUS_SUCCESS;
1969         uint16_t netkey_idx;
1970         oal_uuid_t net_uuid;
1971         uint16_t data_len;
1972         uint32_t opcode = 0;
1973         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
1974
1975         /* If Scanning is going on */
1976         if (_bt_mesh_is_provisioning() ||
1977                         _bt_mesh_is_scanning()) {
1978                 BT_ERR("Device is buzy..");
1979                 return BLUETOOTH_ERROR_DEVICE_BUSY;
1980         }
1981
1982         _bt_mesh_util_convert_string_to_hex(req->net_uuid,
1983                 strlen(req->net_uuid), net_uuid.uuid, 16);
1984
1985         BT_INFO("Mesh: Virtual Group Subscription Req: [%d] Group Addr [0x%2.2x]",
1986                         req->op, req->sub_addr);
1987
1988         if (req->op != BLUETOOTH_MESH_MODEL_SUB_DELETE_ALL) {
1989                 /* Subscription address sanity check */
1990                 if (MESH_IS_GROUP(req->sub_addr) ||
1991                                 !(MESH_IS_VIRTUAL(req->sub_addr))) {
1992                         BT_ERR("Mesh: Bad Virtual Group subscription address [0x%2.2x\n]",
1993                                 req->sub_addr);
1994                         return BLUETOOTH_ERROR_INVALID_PARAM;
1995                 }
1996         } else
1997                 BT_INFO("Mesh: Virtual Group Subscription Req: Delete All");
1998
1999         /* Get Subnet index of the remote node for TX encryption */
2000         netkey_idx = _bt_mesh_node_get_subnet_idx(net_uuid.uuid,
2001                                 req->primary_unicast);
2002         if (netkey_idx == MESH_NET_IDX_INVALID)
2003                 return BLUETOOTH_ERROR_INTERNAL;
2004
2005         if (req->op == BLUETOOTH_MESH_MODEL_SUB_ADD)
2006                 opcode = MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_ADD;
2007         else if (req->op == BLUETOOTH_MESH_MODEL_SUB_DELETE)
2008                 opcode = MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_DELETE;
2009         else if (req->op == BLUETOOTH_MESH_MODEL_SUB_OVERWRITE)
2010                 opcode = MESH_OPCODE_CONFIG_MODEL_SUB_VIRT_OVERWRITE;
2011         else if (req->op == BLUETOOTH_MESH_MODEL_SUB_DELETE_ALL)
2012                 opcode = MESH_OPCODE_CONFIG_MODEL_SUB_DELETE_ALL;
2013
2014         /* Check pending request */
2015         if (_bt_mesh_check_pending_request(opcode,
2016                                 req->primary_unicast, net_uuid.uuid)) {
2017                 BT_ERR("Device is buzy..");
2018                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2019         }
2020
2021         data_len = _bt_mesh_util_opcode_set(opcode, buffer);
2022
2023         /* Element Address */
2024         l_put_le16((req->primary_unicast + req->elem_index), buffer + data_len);
2025         data_len += 2;
2026
2027         /* Subscription address */
2028         if (req->op != BLUETOOTH_MESH_MODEL_SUB_DELETE_ALL) {
2029                 uint8_t label_uuid[16];
2030                 if (!_bt_mesh_network_get_label_uuid_from_sub_addr(
2031                         net_uuid.uuid, req->sub_addr, label_uuid)) {
2032                         BT_ERR("Mesh: Virtual Group Label UUID Not found");
2033                         return BLUETOOTH_ERROR_INVALID_PARAM;
2034                 }
2035                 memcpy(buffer + data_len, label_uuid, 16);
2036                 data_len += 16;
2037         }
2038
2039         BT_INFO("Mesh: Virtual Group Subscription Model ID [0x%4.4x]", req->model);
2040         /* Insert Model ID */
2041          if (req->model >= 0xFFFF0000) {
2042                 /* 1st 2 octet Company ID is 0xFFFF means, it is BT SIG Model*/
2043                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2044                 data_len += 2;
2045         } else {
2046                 /* Vendor Model, 1st 2 octetes: Company ID, next 2 octets: Vendor Model ID */
2047                 l_put_le16(req->model & 0xFFFF0000, buffer + data_len);
2048                 data_len += 2;
2049                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2050                 data_len += 2;
2051         }
2052
2053         ret = mesh_conf_send_message(&net_uuid,
2054                         req->primary_unicast, true,
2055                                 netkey_idx, buffer, data_len);
2056
2057         if (ret != OAL_STATUS_SUCCESS) {
2058                 BT_ERR("ret: %d", ret);
2059                 return BLUETOOTH_ERROR_INTERNAL;
2060         }
2061
2062         BT_INFO("Mesh: Virtual Group Subscription Command sent successfully");
2063         /* Queue the request with timeout */
2064         __bt_mesh_add_request(opcode, req->primary_unicast,
2065                 net_uuid.uuid,
2066                         g_memdup(req, sizeof(bluetooth_mesh_model_configure_t)));
2067
2068         return BLUETOOTH_ERROR_NONE;
2069 }
2070
2071 int _bt_mesh_model_get_publication(const char *app_cred, const char *sender,
2072                 bluetooth_mesh_model_configure_t *req)
2073 {
2074         int ret = OAL_STATUS_SUCCESS;
2075         uint16_t netkey_idx;
2076         oal_uuid_t net_uuid;
2077         uint16_t data_len;
2078         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
2079
2080         /* If Scanning is going on */
2081         if (_bt_mesh_is_provisioning() ||
2082                         _bt_mesh_is_scanning()) {
2083                 BT_ERR("Device is buzy..");
2084                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2085         }
2086
2087         _bt_mesh_util_convert_string_to_hex(req->net_uuid,
2088                 strlen(req->net_uuid), net_uuid.uuid, 16);
2089
2090         /* Check pending request */
2091         if (_bt_mesh_check_pending_request(MESH_OPCODE_CONFIG_MODEL_PUB_GET,
2092                                 req->primary_unicast, net_uuid.uuid)) {
2093                 BT_ERR("Device is buzy..");
2094                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2095         }
2096
2097         /* Get Subnet index of the remote node for TX encryption */
2098         netkey_idx = _bt_mesh_node_get_subnet_idx(net_uuid.uuid, req->primary_unicast);
2099         if (netkey_idx == MESH_NET_IDX_INVALID)
2100                 return BLUETOOTH_ERROR_INTERNAL;
2101
2102         /* Set Opcode */
2103         data_len = _bt_mesh_util_opcode_set(MESH_OPCODE_CONFIG_MODEL_PUB_GET, buffer);
2104
2105         /* Element Address */
2106         l_put_le16((req->primary_unicast + req->elem_index), buffer + data_len);
2107         data_len += 2;
2108
2109         /* Insert Model ID */
2110         if (req->model >= 0xFFFF0000) {
2111                 /* 1st 2 octet Company ID is 0xFFFF means, it is BT SIG Model*/
2112                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2113                 data_len += 2;
2114         } else {
2115                 /* Vendor Model, 1st 2 octetes: Company ID, next 2 octets: Vendor Model ID */
2116                 l_put_le16(req->model & 0xFFFF0000, buffer + data_len);
2117                 data_len += 2;
2118                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2119                 data_len += 2;
2120         }
2121
2122         ret = mesh_conf_send_message(&net_uuid, req->primary_unicast, true, netkey_idx, buffer, data_len);
2123
2124         if (ret != OAL_STATUS_SUCCESS) {
2125                 BT_ERR("ret: %d", ret);
2126                 return BLUETOOTH_ERROR_INTERNAL;
2127         }
2128
2129         /* Queue the request with timeout */
2130         __bt_mesh_add_request(MESH_OPCODE_CONFIG_MODEL_PUB_GET, req->primary_unicast, net_uuid.uuid,
2131                         g_memdup(req, sizeof(bluetooth_mesh_model_configure_t)));
2132
2133         return BLUETOOTH_ERROR_NONE;
2134 }
2135
2136 int _bt_mesh_model_set_publication(const char *app_cred, const char *sender,
2137                 bluetooth_mesh_model_configure_t *req)
2138 {
2139         int ret = OAL_STATUS_SUCCESS;
2140         uint16_t netkey_idx;
2141         oal_uuid_t net_uuid;
2142         uint16_t data_len;
2143         uint32_t opcode = 0;
2144         uint8_t label_uuid[16];
2145         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
2146
2147         /* If Scanning is going on */
2148         if (_bt_mesh_is_provisioning() ||
2149                         _bt_mesh_is_scanning()) {
2150                 BT_ERR("Device is buzy..");
2151                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2152         }
2153
2154         _bt_mesh_util_convert_string_to_hex(req->net_uuid, strlen(req->net_uuid), net_uuid.uuid, 16);
2155
2156         if (req->pub_addr == MESH_ALL_NODES_ADDRESS)
2157                 BT_INFO("Mesh: Setting Publication to ALL Node Address");
2158
2159         if (!MESH_IS_GROUP(req->pub_addr) && !MESH_IS_VIRTUAL(req->pub_addr) &&
2160                         req->pub_addr != MESH_UNASSIGNED_ADDRESS) {
2161                 BT_ERR("Mesh: Bad Publication address %x\n", req->pub_addr);
2162                 return BLUETOOTH_ERROR_INVALID_PARAM;
2163         }
2164
2165         if (req->pub_addr != MESH_UNASSIGNED_ADDRESS) {
2166                 if (MESH_IS_VIRTUAL(req->pub_addr)) {
2167                         if (!_bt_mesh_network_get_label_uuid_from_sub_addr(
2168                                         net_uuid.uuid, req->pub_addr, label_uuid))
2169                                 return BLUETOOTH_ERROR_INVALID_PARAM;
2170                         opcode = MESH_OPCODE_CONFIG_MODEL_PUB_VIRT_SET;
2171
2172                 } else if (MESH_IS_GROUP(req->pub_addr))
2173                         opcode = MESH_OPCODE_CONFIG_MODEL_PUB_SET;
2174         }
2175
2176         /* Check pending request */
2177         if (_bt_mesh_check_pending_request(opcode,
2178                                 req->primary_unicast, net_uuid.uuid)) {
2179                 BT_ERR("Device is buzy..");
2180                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2181         }
2182
2183         /* Get Subnet index of the remote node for TX encryption */
2184         netkey_idx = _bt_mesh_node_get_subnet_idx(
2185                                 net_uuid.uuid, req->primary_unicast);
2186         if (netkey_idx == MESH_NET_IDX_INVALID)
2187                 return BLUETOOTH_ERROR_INTERNAL;
2188
2189         /* Set opcode */
2190         data_len = _bt_mesh_util_opcode_set(opcode, buffer);
2191
2192         /* Element Address */
2193         l_put_le16((req->primary_unicast + req->elem_index), buffer + data_len);
2194         data_len += 2;
2195
2196         /* Fill Publication Address */
2197         if (MESH_IS_VIRTUAL(req->pub_addr)) {
2198                 memcpy(buffer + data_len, label_uuid, 16);
2199                 data_len += 16;
2200         } else {
2201                 l_put_le16(req->pub_addr, buffer + data_len);
2202                 data_len += 2;
2203         }
2204
2205         /* AppKey index + credential (set to 0) */
2206         l_put_le16(req->appkey_idx, buffer + data_len);
2207         data_len += 2;
2208
2209         /* Fill TTL */
2210         buffer[data_len++] = req->ttl;
2211         /* Publish period  step count and step resolution */
2212         buffer[data_len++] = req->period;
2213         /* Publish retransmit count & interval steps */
2214         buffer[data_len++] = req->retransmit;
2215
2216         /* Insert Model ID */
2217         if (req->model >= 0xFFFF0000) {
2218                 /* 1st 2 octet Company ID is 0xFFFF means, it is BT SIG Model*/
2219                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2220                 data_len += 2;
2221         } else {
2222                 /* Vendor Model, 1st 2 octetes: Company ID, next 2 octets: Vendor Model ID */
2223                 l_put_le16(req->model & 0xFFFF0000, buffer + data_len);
2224                 data_len += 2;
2225                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2226                 data_len += 2;
2227         }
2228
2229         ret = mesh_conf_send_message(&net_uuid,
2230                         req->primary_unicast, true,
2231                                 netkey_idx, buffer, data_len);
2232
2233         if (ret != OAL_STATUS_SUCCESS) {
2234                 BT_ERR("ret: %d", ret);
2235                 return BLUETOOTH_ERROR_INTERNAL;
2236         }
2237
2238         /* Queue the request with timeout */
2239         __bt_mesh_add_request(opcode, req->primary_unicast, net_uuid.uuid,
2240                         g_memdup(req, sizeof(bluetooth_mesh_model_configure_t)));
2241
2242         return BLUETOOTH_ERROR_NONE;
2243 }
2244
2245 int _bt_mesh_node_model_get_subscription_list(const char *app_cred, const char *sender,
2246                 bluetooth_mesh_model_configure_t *req)
2247 {
2248         int ret = OAL_STATUS_SUCCESS;
2249         uint16_t netkey_idx;
2250         oal_uuid_t net_uuid;
2251         uint16_t data_len;
2252         uint32_t opcode = 0;
2253         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
2254
2255         /* If Scanning is going on */
2256         if (_bt_mesh_is_provisioning() ||
2257                         _bt_mesh_is_scanning()) {
2258                 BT_ERR("Device is buzy..");
2259                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2260         }
2261
2262         _bt_mesh_util_convert_string_to_hex(req->net_uuid, strlen(req->net_uuid), net_uuid.uuid, 16);
2263
2264         /* Insert Model ID */
2265         if (req->model >= 0xFFFF0000)
2266                 /* 1st 2 octet Company ID is 0xFFFF means, it is BT SIG Model*/
2267                 opcode = MESH_OPCODE_CONFIG_MODEL_SUB_GET;
2268         else
2269                 /* Vendor Model, 1st 2 octetes: Company ID, next 2 octets: Vendor Model ID */
2270                 opcode = MESH_OPCODE_CONFIG_VEND_MODEL_SUB_GET;
2271
2272         /* Check pending request */
2273         if (_bt_mesh_check_pending_request(opcode,
2274                                 req->primary_unicast, net_uuid.uuid)) {
2275                 BT_ERR("Device is buzy..");
2276                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2277         }
2278         /* Get Subnet index of the remote node for TX encryption */
2279         netkey_idx = _bt_mesh_node_get_subnet_idx(net_uuid.uuid, req->primary_unicast);
2280         if (netkey_idx == MESH_NET_IDX_INVALID)
2281                 return BLUETOOTH_ERROR_INTERNAL;
2282
2283         data_len = _bt_mesh_util_opcode_set(opcode, buffer);
2284         /* Element Address */
2285         l_put_le16((req->primary_unicast + req->elem_index), buffer + data_len);
2286         data_len += 2;
2287
2288         /* Insert Model ID */
2289         if (opcode == MESH_OPCODE_CONFIG_MODEL_SUB_GET) {
2290                 BT_INFO("Mesh: Get Subscription List for BT SIG Model");
2291                 /* 1st 2 octet Company ID is 0xFFFF means, it is BT SIG Model*/
2292                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2293                 data_len += 2;
2294         } else {
2295                 BT_INFO("Mesh: Get Subscription List for Vendor Model");
2296                 /* Vendor Model, 1st 2 octetes: Company ID, next 2 octets: Vendor Model ID */
2297                 l_put_le16(req->model & 0xFFFF0000, buffer + data_len);
2298                 data_len += 2;
2299                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2300                 data_len += 2;
2301         }
2302
2303         ret = mesh_conf_send_message(&net_uuid,
2304                 req->primary_unicast, true, netkey_idx, buffer, data_len);
2305
2306         if (ret != OAL_STATUS_SUCCESS) {
2307                 BT_ERR("ret: %d", ret);
2308                 return BLUETOOTH_ERROR_INTERNAL;
2309         }
2310
2311         /* Queue the request with timeout */
2312         __bt_mesh_add_request(opcode, req->primary_unicast, net_uuid.uuid,
2313                         g_memdup(req, sizeof(bluetooth_mesh_model_configure_t)));
2314
2315         return BLUETOOTH_ERROR_NONE;
2316 }
2317
2318 int _bt_mesh_node_model_get_appkey_list(const char *app_cred, const char *sender,
2319                 bluetooth_mesh_model_configure_t *req)
2320 {
2321         int ret = OAL_STATUS_SUCCESS;
2322         uint16_t netkey_idx;
2323         oal_uuid_t net_uuid;
2324         uint16_t data_len;
2325         uint32_t opcode = 0;
2326         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
2327
2328         /* If Scanning is going on */
2329         if (_bt_mesh_is_provisioning() ||
2330                         _bt_mesh_is_scanning()) {
2331                 BT_ERR("Device is buzy..");
2332                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2333         }
2334
2335         _bt_mesh_util_convert_string_to_hex(req->net_uuid,
2336                 strlen(req->net_uuid), net_uuid.uuid, 16);
2337
2338         /* Insert Model ID */
2339         if (req->model >= 0xFFFF0000)
2340                 /* 1st 2 octet Company ID is 0xFFFF means, it is BT SIG Model*/
2341                 opcode = MESH_OPCODE_MODEL_APP_GET;
2342         else
2343                 /* Vendor Model, 1st 2 octetes: Company ID, next 2 octets: Vendor Model ID */
2344                 opcode = MESH_OPCODE_VENDOR_MODEL_APP_GET;
2345
2346         /* Check pending request */
2347         if (_bt_mesh_check_pending_request(opcode,
2348                                 req->primary_unicast, net_uuid.uuid)) {
2349                 BT_ERR("Device is buzy..");
2350                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2351         }
2352         /* Get Subnet index of the remote node for TX encryption */
2353         netkey_idx = _bt_mesh_node_get_subnet_idx(net_uuid.uuid, req->primary_unicast);
2354         if (netkey_idx == MESH_NET_IDX_INVALID)
2355                 return BLUETOOTH_ERROR_INTERNAL;
2356
2357         data_len = _bt_mesh_util_opcode_set(opcode, buffer);
2358         /* Element Address */
2359         l_put_le16((req->primary_unicast + req->elem_index), buffer + data_len);
2360         data_len += 2;
2361
2362
2363         /* Insert Model ID */
2364         if (opcode == MESH_OPCODE_MODEL_APP_GET) {
2365                 /* 1st 2 octet Company ID is 0xFFFF means, it is BT SIG Model*/
2366                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2367                 data_len += 2;
2368         } else {
2369                 /* Vendor Model, 1st 2 octetes: Company ID, next 2 octets: Vendor Model ID */
2370                 l_put_le16(req->model & 0xFFFF0000, buffer + data_len);
2371                 data_len += 2;
2372                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2373                 data_len += 2;
2374         }
2375
2376         ret = mesh_conf_send_message(&net_uuid, req->primary_unicast, true, netkey_idx, buffer, data_len);
2377
2378         if (ret != OAL_STATUS_SUCCESS) {
2379                 BT_ERR("ret: %d", ret);
2380                 return BLUETOOTH_ERROR_INTERNAL;
2381         }
2382
2383         /* Queue the request with timeout */
2384         __bt_mesh_add_request(opcode, req->primary_unicast, net_uuid.uuid,
2385                         g_memdup(req, sizeof(bluetooth_mesh_model_configure_t)));
2386
2387         return BLUETOOTH_ERROR_NONE;
2388 }
2389
2390 int _bt_mesh_network_reset_node(const char *app_cred, const char *sender,
2391                 bluetooth_mesh_node_info_t *node)
2392 {
2393         int ret = OAL_STATUS_SUCCESS;
2394         uint16_t netkey_idx;
2395         oal_uuid_t net_uuid;
2396         uint16_t data_len;
2397         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
2398
2399         /* If Scanning is going on */
2400         if (_bt_mesh_is_provisioning() ||
2401                         _bt_mesh_is_scanning()) {
2402                 BT_ERR("Device is buzy..");
2403                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2404         }
2405
2406         _bt_mesh_util_convert_string_to_hex(node->net_uuid,
2407                         strlen(node->net_uuid), net_uuid.uuid, 16);
2408
2409         /* Check pending request */
2410         if (_bt_mesh_check_pending_request(MESH_OPCODE_NODE_RESET,
2411                                 node->primary_unicast, net_uuid.uuid)) {
2412                 BT_ERR("Device is buzy..");
2413                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2414         }
2415         BT_INFO("Mesh: Reset a remote Node [0x%2.2x] Elem Cnt [0x%2.2x]",
2416                         node->primary_unicast, node->num_elements);
2417         /* Get Subnet index of the remote node for TX encryption */
2418         netkey_idx = _bt_mesh_node_get_subnet_idx(net_uuid.uuid, node->primary_unicast);
2419         if (netkey_idx == MESH_NET_IDX_INVALID)
2420                 return BLUETOOTH_ERROR_INTERNAL;
2421
2422         data_len = _bt_mesh_util_opcode_set(MESH_OPCODE_NODE_RESET, buffer);
2423
2424         /* Send Node Reset command 5 times to ensure reliability */
2425         for (int i = 0; i < 5; i++)
2426                 ret = mesh_conf_send_message(&net_uuid, node->primary_unicast,
2427                                 true, netkey_idx, buffer, data_len);
2428
2429         if (ret != OAL_STATUS_SUCCESS) {
2430                 BT_ERR("Mesh: Node Reset Failed!: %d", ret);
2431                 return BLUETOOTH_ERROR_INTERNAL;
2432         }
2433
2434         BT_INFO("Mesh: Node reset Done, Send Delete req: Unicast[0x%2.2x]",
2435                         node->primary_unicast);
2436
2437         ret = mesh_delete_remote_node(&net_uuid, node->primary_unicast,
2438                         node->num_elements);
2439         if (ret != OAL_STATUS_SUCCESS) {
2440                 BT_ERR("Mesh: Remote Node Deletion Failed!: %d", ret);
2441                 return BLUETOOTH_ERROR_INTERNAL;
2442         }
2443
2444         return _bt_mesh_network_remove_node_configuration(node);
2445 }
2446
2447 int _bt_mesh_node_model_appkey_execute(const char *app_cred, const char *sender,
2448                 bluetooth_mesh_model_configure_t *req)
2449 {
2450         int ret = OAL_STATUS_SUCCESS;
2451         uint16_t netkey_idx;
2452         oal_uuid_t net_uuid;
2453         uint16_t data_len;
2454         uint32_t opcode = 0;
2455         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
2456
2457         /* If Scanning is going on */
2458         if (_bt_mesh_is_provisioning() ||
2459                         _bt_mesh_is_scanning()) {
2460                 BT_ERR("Device is buzy..");
2461                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2462         }
2463
2464         _bt_mesh_util_convert_string_to_hex(req->net_uuid, strlen(req->net_uuid), net_uuid.uuid, 16);
2465
2466         /* Check pending request */
2467         if (_bt_mesh_check_pending_request(req->is_bind ? MESH_OPCODE_MODEL_APP_BIND : MESH_OPCODE_MODEL_APP_UNBIND,
2468                                 req->primary_unicast, net_uuid.uuid)) {
2469                 BT_ERR("Device is buzy..");
2470                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2471         }
2472         /* Get Subnet index of the remote node for TX encryption */
2473         netkey_idx = _bt_mesh_node_get_subnet_idx(net_uuid.uuid, req->primary_unicast);
2474         if (netkey_idx == MESH_NET_IDX_INVALID)
2475                 return BLUETOOTH_ERROR_INTERNAL;
2476
2477         if (req->is_bind)
2478                 opcode = MESH_OPCODE_MODEL_APP_BIND;
2479         else
2480                 opcode = MESH_OPCODE_MODEL_APP_UNBIND;
2481
2482         data_len = _bt_mesh_util_opcode_set(opcode, buffer);
2483         /* Element Address */
2484         l_put_le16((req->primary_unicast + req->elem_index), buffer + data_len);
2485         data_len += 2;
2486
2487         /* AppKey Index  */
2488         l_put_le16(req->appkey_idx, buffer + data_len);
2489         data_len += 2;
2490
2491         /* Insert Model ID */
2492         if (req->model >= 0xFFFF0000) {
2493                 /* 1st 2 octet Company ID is 0xFFFF means, it is BT SIG Model*/
2494                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2495                 data_len += 2;
2496         } else {
2497                 /* Vendor Model, 1st 2 octetes: Company ID, next 2 octets: Vendor Model ID */
2498                 l_put_le16(req->model & 0xFFFF0000, buffer + data_len);
2499                 data_len += 2;
2500                 l_put_le16(req->model & 0x0000FFFF, buffer + data_len);
2501                 data_len += 2;
2502         }
2503
2504         ret = mesh_conf_send_message(&net_uuid, req->primary_unicast, true, netkey_idx, buffer, data_len);
2505
2506         if (ret != OAL_STATUS_SUCCESS) {
2507                 BT_ERR("ret: %d", ret);
2508                 return BLUETOOTH_ERROR_INTERNAL;
2509         }
2510
2511         /* Queue the request with timeout */
2512         __bt_mesh_add_request(opcode, req->primary_unicast, net_uuid.uuid,
2513                         g_memdup(req, sizeof(bluetooth_mesh_model_configure_t)));
2514
2515         return BLUETOOTH_ERROR_NONE;
2516 }
2517
2518 int _bt_mesh_ttl_execute_remote_node(const char *app_cred, const char *sender,
2519                 bluetooth_mesh_node_ttl_info_t *req)
2520 {
2521         int ret = OAL_STATUS_SUCCESS;
2522         uint16_t netkey_idx;
2523         uint16_t data_len;
2524         oal_uuid_t net_uuid;
2525         uint32_t opcode = 0;
2526         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
2527
2528         /* If Scanning is going on */
2529         if (_bt_mesh_is_provisioning() ||
2530                         _bt_mesh_is_scanning()) {
2531                 BT_ERR("Device is buzy..");
2532                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2533         }
2534
2535         _bt_mesh_util_convert_string_to_hex(req->net_uuid, strlen(req->net_uuid), net_uuid.uuid, 16);
2536
2537         /* Check pending request */
2538         if (_bt_mesh_check_pending_request(req->is_set ? MESH_OPCODE_CONFIG_DEFAULT_TTL_SET : MESH_OPCODE_CONFIG_DEFAULT_TTL_GET,
2539                                 req->unicast, net_uuid.uuid)) {
2540                 BT_ERR("Device is buzy..");
2541                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2542         }
2543
2544         /* Get Subnet index of the rmeote node for TX encryption */
2545         netkey_idx = _bt_mesh_node_get_subnet_idx(net_uuid.uuid, req->unicast);
2546         if (netkey_idx == MESH_NET_IDX_INVALID)
2547                 return BLUETOOTH_ERROR_INTERNAL;
2548
2549         if (req->is_set) {
2550                 opcode = MESH_OPCODE_CONFIG_DEFAULT_TTL_SET;
2551                 data_len = _bt_mesh_util_opcode_set(MESH_OPCODE_CONFIG_DEFAULT_TTL_SET, buffer);
2552                 buffer[data_len++] = req->ttl;
2553         } else {
2554                 opcode = MESH_OPCODE_CONFIG_DEFAULT_TTL_GET;
2555                 data_len = _bt_mesh_util_opcode_set(MESH_OPCODE_CONFIG_DEFAULT_TTL_GET, buffer);
2556         }
2557
2558         ret = mesh_conf_send_message(&net_uuid, req->unicast, true, netkey_idx, buffer, data_len);
2559
2560         if (ret != OAL_STATUS_SUCCESS) {
2561                 BT_ERR("ret: %d", ret);
2562                 return BLUETOOTH_ERROR_INTERNAL;
2563         }
2564
2565         /* Queue the request with timeout */
2566         __bt_mesh_add_request(opcode, req->unicast, net_uuid.uuid,
2567                         g_memdup(req, sizeof(bluetooth_mesh_node_ttl_info_t)));
2568         return BLUETOOTH_ERROR_NONE;
2569 }
2570
2571 static bool __bt_mesh_check_pending_key_cmd(uint16_t dest, bool is_netkey,
2572                 bluetooth_mesh_node_key_conf_e op,  uint8_t net_uuid[], uint32_t *opcode)
2573 {
2574         const struct mesh_config_cmd *cmd;
2575
2576         if (is_netkey) {
2577                 switch (op) {
2578                 case BLUETOOTH_MESH_NODE_KEY_ADD:
2579                         cmd = __mesh_get_command(MESH_OPCODE_NETKEY_ADD);
2580                         if (!cmd)
2581                                 return false;
2582                         if (__bt_mesh_get_request_by_response(dest, net_uuid, cmd->response)) {
2583                                 BT_ERR("Mesh:Another Key Configuration command is pending\n");
2584                                 return true;
2585                         }
2586                         *opcode = MESH_OPCODE_NETKEY_ADD;
2587                         return false;
2588                 case BLUETOOTH_MESH_NODE_KEY_DELETE:
2589                         cmd = __mesh_get_command(MESH_OPCODE_NETKEY_DELETE);
2590                         if (!cmd)
2591                                 return false;
2592                         if (__bt_mesh_get_request_by_response(dest, net_uuid, cmd->response)) {
2593                                 BT_ERR("Mesh:Another Key Configuration command is pending\n");
2594                                 return true;
2595                         }
2596                         *opcode = MESH_OPCODE_NETKEY_DELETE;
2597                         return false;
2598                 case BLUETOOTH_MESH_NODE_KEY_UPDATE:
2599                         cmd = __mesh_get_command(MESH_OPCODE_NETKEY_UPDATE);
2600                         if (!cmd)
2601                                 return false;
2602                         if (__bt_mesh_get_request_by_response(dest, net_uuid, cmd->response)) {
2603                                 BT_ERR("Mesh:Another Key Configuration command is pending\n");
2604                                 return true;
2605                         }
2606                         *opcode = MESH_OPCODE_NETKEY_UPDATE;
2607                         return false;
2608                 }
2609         } else {
2610                 switch (op) {
2611                 case BLUETOOTH_MESH_NODE_KEY_ADD:
2612                         cmd = __mesh_get_command(MESH_OPCODE_APPKEY_ADD);
2613                         if (!cmd)
2614                                 return false;
2615                         if (__bt_mesh_get_request_by_response(dest, net_uuid, cmd->response)) {
2616                                 BT_ERR("Mesh:Another Key Configuration command is pending\n");
2617                                 return true;
2618                         }
2619                         *opcode = MESH_OPCODE_APPKEY_ADD;
2620                         return false;
2621                 case BLUETOOTH_MESH_NODE_KEY_DELETE:
2622                         cmd = __mesh_get_command(MESH_OPCODE_APPKEY_DELETE);
2623                         if (!cmd)
2624                                 return false;
2625                         if (__bt_mesh_get_request_by_response(dest, net_uuid, cmd->response)) {
2626                                 BT_ERR("Mesh:Another Key Configuration command is pending\n");
2627                                 return true;
2628                         }
2629                         *opcode = MESH_OPCODE_APPKEY_DELETE;
2630                         return false;
2631                 case BLUETOOTH_MESH_NODE_KEY_UPDATE:
2632                         cmd = __mesh_get_command(MESH_OPCODE_APPKEY_UPDATE);
2633                         if (!cmd)
2634                                 return false;
2635                         if (__bt_mesh_get_request_by_response(dest, net_uuid, cmd->response)) {
2636                                 BT_ERR("Mesh:Another Key Configuration command is pending\n");
2637                                 return true;
2638                         }
2639                         *opcode = MESH_OPCODE_APPKEY_UPDATE;
2640                         return false;
2641                 }
2642         }
2643         return false;
2644 }
2645
2646 int _bt_mesh_node_configure_key(const char *app_cred, const char *sender,
2647                 bluetooth_mesh_key_configure_t *req)
2648 {
2649         int ret = OAL_STATUS_SUCCESS;
2650         uint16_t netkey_idx;
2651         uint16_t bound_netkey_idx = 0x0000;
2652         oal_uuid_t net_uuid;
2653         uint32_t opcode = 0;
2654         bool update;
2655         uint16_t data_len;
2656         uint8_t buffer[MESH_CONFIG_BUFFER_MAX_LEN];
2657
2658         /* If Scanning is going on */
2659         if (_bt_mesh_is_provisioning() ||
2660                         _bt_mesh_is_scanning()) {
2661                 BT_ERR("Device is buzy..");
2662                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2663         }
2664
2665         _bt_mesh_util_convert_string_to_hex(req->net_uuid, strlen(req->net_uuid), net_uuid.uuid, 16);
2666
2667         if (req->is_netkey && !_bt_mesh_keys_subnet_exists(net_uuid.uuid, req->netkey_idx)) {
2668                 BT_ERR("Local Subnet not found..");
2669                 return BLUETOOTH_ERROR_INVALID_PARAM;
2670         }
2671
2672         /* For Appkey Configuration, check for available bound netkey */
2673         if (!req->is_netkey) {
2674                 bound_netkey_idx = _bt_mesh_keys_get_bound_key(net_uuid.uuid, req->appkey_idx);
2675                 if (bound_netkey_idx == MESH_NET_IDX_INVALID) {
2676                         BT_ERR("Local AppKey not found..");
2677                         return BLUETOOTH_ERROR_INVALID_PARAM;
2678                 }
2679         }
2680
2681         /* Check pending request */
2682         if (__bt_mesh_check_pending_key_cmd(req->primary_unicast,
2683                                 req->is_netkey, req->op, net_uuid.uuid, &opcode)) {
2684                 BT_ERR("Device is buzy..");
2685                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2686         }
2687
2688         /* Get Subnet index of the rmeote node for TX encryption */
2689         netkey_idx = _bt_mesh_node_get_subnet_idx(net_uuid.uuid, req->primary_unicast);
2690         if (netkey_idx == MESH_NET_IDX_INVALID)
2691                 return BLUETOOTH_ERROR_INTERNAL;
2692
2693         /* Handle Key (App/Net) Delete Commands: Configuration Message  */
2694         if (opcode == MESH_OPCODE_NETKEY_DELETE || opcode == MESH_OPCODE_APPKEY_DELETE) {
2695                 data_len = _bt_mesh_util_opcode_set(opcode, buffer);
2696                 if (req->is_netkey) {
2697                         l_put_le16(req->netkey_idx, buffer + data_len);
2698                         data_len += 2;
2699                 } else {
2700                         buffer[data_len] = bound_netkey_idx;
2701                         buffer[data_len + 1] = ((bound_netkey_idx >> 8) & 0xf) | ((req->appkey_idx << 4) & 0xf0);
2702                         buffer[data_len + 2] = req->appkey_idx >> 4;
2703
2704                         data_len += 3;
2705                 }
2706                 ret = mesh_conf_send_message(&net_uuid, req->primary_unicast, true, netkey_idx, buffer, data_len);
2707         } else {
2708                 /* Handle Key (App/Net) Update & Add Commands: Key Config message  */
2709                 update = (opcode == MESH_OPCODE_NETKEY_UPDATE || opcode == MESH_OPCODE_APPKEY_UPDATE);
2710                 ret = mesh_conf_send_key_message(&net_uuid, req->primary_unicast, req->is_netkey,
2711                                 update, req->is_netkey ? req->netkey_idx : req->appkey_idx, netkey_idx);
2712         }
2713         if (ret != OAL_STATUS_SUCCESS) {
2714                 BT_ERR("ret: %d", ret);
2715                 return BLUETOOTH_ERROR_INTERNAL;
2716         }
2717
2718         /* Queue the request with timeout */
2719         __bt_mesh_add_request(opcode, req->primary_unicast,  net_uuid.uuid,
2720                 g_memdup(req, sizeof(bluetooth_mesh_key_configure_t)));
2721         return BLUETOOTH_ERROR_NONE;
2722 }