zigbee-daemon/zigbee-lib/src/zblib_request.c

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Contact: Suresh Kumar N (suresh.n@samsung.com)
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include <zblib.h>
  20 #include <zblib_request.h>
  21 #include <zblib_service.h>
  22 #include <zblib_service_interface.h>
  23
  24 #include <zblib_driver.h>
  25 #include <zblib_driver_custom.h>
  26 #include <zblib_driver_mfglib_control.h>
  27 #include <zblib_driver_service.h>
  28 #include <zblib_driver_zcl_alarm.h>
  29 #include <zblib_driver_zcl_basic.h>
  30 #include <zblib_driver_zcl_color_control.h>
  31 #include <zblib_driver_zcl_door_lock.h>
  32 #include <zblib_driver_zcl_fan_control.h>
  33 #include <zblib_driver_zcl_global_control.h>
  34 #include <zblib_driver_zcl_group.h>
  35 #include <zblib_driver_zcl_ias_zone.h>
  36 #include <zblib_driver_zcl_identify.h>
  37 #include <zblib_driver_zcl_level_control.h>
  38 #include <zblib_driver_zcl_on_off.h>
  39 #include <zblib_driver_zcl_poll_control.h>
  40 #include <zblib_driver_zcl_scene.h>
  41 #include <zblib_driver_zcl_thermostat.h>
  42 #include <zblib_driver_zdo_bind.h>
  43 #include <zblib_driver_zdo_dev_control.h>
  44
  45 /**< ZigBee Request object */
  46 struct zblib_request_type {
  47         gint request_id; /**< Request ID */
  48         guint request_type; /**< Request type */
  49         guint ref_count; /* Reference count */
  50
  51         gpointer request_data; /**< Request data */
  52         gpointer resp_cb; /**< Response callback */
  53         gpointer resp_cb_data; /**< Response callback data */
  54
  55         ZigBeeServiceInterface *service_interface; /* Service interface */
  56 };
  57
  58 static ZblibDriverType_e __zblib_request_get_driver_type(guint request_type)
  59 {
  60         ZblibDriverType_e driver_type;
  61
  62         driver_type = ((request_type & 0xFF000000) >> 24);
  63
  64         return driver_type;
  65 }
  66
  67 static ZblibDriverType_e __zblib_request_get_ops_id(guint request_type)
  68 {
  69         guint ops_id;
  70
  71         ops_id = (request_type & 0x000000FF);
  72
  73         return ops_id;
  74 }
  75
  76 static ZigBeeRequest *__zblib_request_ref_request_by_by_request_id(ZigBeeService *service,
  77         guint request_id)
  78 {
  79         ZigBeeRequest *request = NULL;
  80         GHashTable *request_table = NULL;
  81
  82         /* Fetch request table from service */
  83         request_table = zblib_service_ref_request_hash_table(service);
  84         if (NULL == request_table) {
  85                 Z_LOGE("zblib_service_ref_request_hash_table failed!");
  86                 return NULL;
  87         }
  88
  89         /* Look-up requets_id in request hash table */
  90         request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id);
  91         if (NULL == request) {
  92                 Z_LOGE("No request available for request_id: [%d]", request_id);
  93                 return NULL;
  94         }
  95
  96         return request;
  97 }
  98
  99 static gint __zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
 100         guint request_id)
 101 {
 102         ZigBeeRequest *request = NULL;
 103
 104         /* Fetch request based on request_id */
 105         request = __zblib_request_ref_request_by_by_request_id(service, request_id);
 106         if (NULL == request) {
 107                 Z_LOGE("No request available for request_id: [%d]", request_id);
 108                 return -1;
 109         }
 110
 111         return (gint)(request->request_type);
 112 }
 113
 114 static ZigBeeRequest *__zblib_request_ref_request_by_request_id(ZigBeeService *service,
 115         guint request_id)
 116 {
 117         ZigBeeRequest *request = NULL;
 118         GHashTable *request_table = NULL;
 119
 120         /* Fetch request table from service */
 121         request_table = zblib_service_ref_request_hash_table(service);
 122         if (NULL == request_table) {
 123                 Z_LOGE("zblib_service_ref_request_hash_table failed!");
 124                 return NULL;
 125         }
 126
 127         /* Look-up requets_id in request hash table */
 128         request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id);
 129         if (NULL == request_table) {
 130                 Z_LOGE("No request available for request_id: [%d]", request_id);
 131                 return NULL;
 132         }
 133
 134         return request;
 135 }
 136
 137 static gpointer __zblib_request_create_zcl_alarm_request_data(guint request_type,
 138         gpointer request_data, guint request_data_len)
 139 {
 140         gpointer alarm_request_data = NULL;
 141         guint ops_id;
 142
 143         NOT_USED(request_data_len);
 144
 145         /* Fetch ops ID */
 146         ops_id = __zblib_request_get_ops_id(request_type);
 147         switch (ops_id) {
 148         case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: {
 149                 ZigbeeZclAlarmGetAlarmCount_t *in_req;
 150                 ZigbeeZclAlarmGetAlarmCount_t *req = NULL;
 151
 152                 in_req = (ZigbeeZclAlarmGetAlarmCount_t *)request_data;
 153                 if (NULL != in_req) {
 154                         /* Allocate memory */
 155                         req = (ZigbeeZclAlarmGetAlarmCount_t *)
 156                                 g_malloc0(sizeof(ZigbeeZclAlarmGetAlarmCount_t));
 157
 158                         /* Copy data */
 159                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 160                         req->endpoint = in_req->endpoint;
 161                 }
 162
 163                 alarm_request_data = (gpointer)req;
 164         }
 165         break;
 166
 167         case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
 168                 ZigbeeZclAlarmResetAlarm_t *in_req;
 169                 ZigbeeZclAlarmResetAlarm_t *req = NULL;
 170
 171                 in_req = (ZigbeeZclAlarmResetAlarm_t *)request_data;
 172                 if (NULL != in_req) {
 173                         /* Allocate memory */
 174                         req = (ZigbeeZclAlarmResetAlarm_t *)
 175                                 g_malloc0(sizeof(ZigbeeZclAlarmResetAlarm_t));
 176
 177                         /* Copy data */
 178                         req->node_id = in_req->node_id;
 179                         req->endpoint = in_req->endpoint;
 180                         req->alarm_code = in_req->alarm_code;
 181                         req->cluster_id = in_req->cluster_id;
 182                 }
 183
 184                 alarm_request_data = (gpointer)req;
 185         }
 186         break;
 187
 188         case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
 189                 ZigbeeZclAlarmResetAllAlarm_t *in_req;
 190                 ZigbeeZclAlarmResetAllAlarm_t *req = NULL;
 191
 192                 in_req = (ZigbeeZclAlarmResetAllAlarm_t *)request_data;
 193                 if (in_req) {
 194                         /* Allocate memory */
 195                         req = (ZigbeeZclAlarmResetAllAlarm_t *)
 196                                 g_malloc0(sizeof(ZigbeeZclAlarmResetAllAlarm_t));
 197
 198                         /* Copy data */
 199                         req->node_id = in_req->node_id;
 200                         req->endpoint = in_req->endpoint;
 201                 }
 202
 203                 alarm_request_data = (gpointer)req;
 204         }
 205         break;
 206
 207         case ZBLIB_ZCL_ALARM_OPS_ALARM: {
 208                 ZigbeeZclAlarmAlarm_t *in_req;
 209                 ZigbeeZclAlarmAlarm_t *req = NULL;
 210
 211                 in_req = (ZigbeeZclAlarmAlarm_t *)request_data;
 212                 if (in_req) {
 213                         /* Allocate memory */
 214                         req = (ZigbeeZclAlarmAlarm_t *)
 215                                 g_malloc0(sizeof(ZigbeeZclAlarmAlarm_t));
 216
 217                         /* Copy data */
 218                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 219                         req->endpoint = in_req->endpoint;
 220                         req->alarm_code = in_req->alarm_code;
 221                         req->cluster_id = in_req->cluster_id;
 222                 }
 223
 224                 alarm_request_data = (gpointer)req;
 225         }
 226         break;
 227
 228         case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
 229                 ZigbeeZclAlarmResetAlarmLogs_t *in_req;
 230                 ZigbeeZclAlarmResetAlarmLogs_t *req = NULL;
 231
 232                 in_req = (ZigbeeZclAlarmResetAlarmLogs_t *)request_data;
 233                 if (in_req) {
 234                         /* Allocate memory */
 235                         req = (ZigbeeZclAlarmResetAlarmLogs_t *)
 236                                 g_malloc0(sizeof(ZigbeeZclAlarmResetAlarmLogs_t));
 237
 238                         /* Copy data */
 239                         req->node_id = in_req->node_id;
 240                         req->endpoint = in_req->endpoint;
 241                 }
 242
 243                 alarm_request_data = (gpointer)req;
 244         }
 245         break;
 246
 247         case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
 248                 ZigbeeZclAlarmGetAlarm_t *in_req;
 249                 ZigbeeZclAlarmGetAlarm_t *req = NULL;
 250
 251                 in_req = (ZigbeeZclAlarmGetAlarm_t *)request_data;
 252                 if (in_req) {
 253                         /* Allocate memory */
 254                         req = (ZigbeeZclAlarmGetAlarm_t *)
 255                                 g_malloc0(sizeof(ZigbeeZclAlarmGetAlarm_t));
 256
 257                         /* Copy data */
 258                         req->node_id = in_req->node_id;
 259                         req->endpoint = in_req->endpoint;
 260                 }
 261
 262                 alarm_request_data = (gpointer)req;
 263         }
 264         break;
 265
 266         default:
 267         break;
 268         }
 269
 270         return alarm_request_data;
 271 }
 272
 273 static gpointer __zblib_request_create_custom_request_data(guint request_type,
 274         gpointer request_data, guint request_data_len)
 275 {
 276         gpointer custom_request_data = NULL;
 277         guint ops_id;
 278
 279         NOT_USED(request_data_len);
 280
 281         /* Fetch ops ID */
 282         ops_id = __zblib_request_get_ops_id(request_type);
 283         switch (ops_id) {
 284         case ZBLIB_CUSTOM_OPS_APS_SEND: {
 285                 ZigbeeCustomApsSend_t *in_req;
 286                 ZigbeeCustomApsSend_t *req = NULL;
 287
 288                 in_req = (ZigbeeCustomApsSend_t *)request_data;
 289                 if (in_req) {
 290                         /* Allocate memory */
 291                         req = (ZigbeeCustomApsSend_t *)
 292                                 g_malloc0(sizeof(ZigbeeCustomApsSend_t));
 293
 294                         /* Copy data */
 295                         req->node_id = in_req->node_id;
 296                         req->aps_frame_ctrl = in_req->aps_frame_ctrl;
 297                         req->src_ep = in_req->src_ep;
 298                         req->dest_ep = in_req->dest_ep;
 299                         req->cluster_id = in_req->cluster_id;
 300                         req->profile_id = in_req->profile_id;
 301                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
 302                         req->mfg_code = in_req->mfg_code;
 303                         memcpy(req->payload,
 304                                 in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
 305                 }
 306
 307                 custom_request_data = (gpointer)req;
 308         }
 309         break;
 310
 311         case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
 312                 ZigbeeCustomZclSend_t *in_req;
 313                 ZigbeeCustomZclSend_t *req = NULL;
 314
 315                 in_req = (ZigbeeCustomZclSend_t *)request_data;
 316                 if (in_req) {
 317                         /* Allocate memory */
 318                         req = (ZigbeeCustomZclSend_t *)
 319                                 g_malloc0(sizeof(ZigbeeCustomZclSend_t));
 320
 321                         /* Copy data */
 322                         req->node_id = in_req->node_id;
 323                         req->src_ep = in_req->src_ep;
 324                         req->dest_ep = in_req->dest_ep;
 325                         req->cluster_id = in_req->cluster_id;
 326                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
 327                         req->cmd_id = in_req->cmd_id;
 328                         memcpy(req->payload,
 329                                 in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
 330                 }
 331
 332                 custom_request_data = (gpointer)req;
 333         }
 334         break;
 335
 336         case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
 337                 ZigbeeCustomSendToLocal_t *in_req;
 338                 ZigbeeCustomSendToLocal_t *req = NULL;
 339
 340                 in_req = (ZigbeeCustomSendToLocal_t *)request_data;
 341                 if (in_req) {
 342                         /* Allocate memory */
 343                         req = (ZigbeeCustomSendToLocal_t *)
 344                                 g_malloc0(sizeof(ZigbeeCustomSendToLocal_t));
 345
 346                         /* Copy data */
 347                         memcpy(req->data,
 348                                 in_req->data, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
 349                 }
 350
 351                 custom_request_data = (gpointer)req;
 352         }
 353         break;
 354
 355         default:
 356         break;
 357         }
 358
 359         return custom_request_data;
 360 }
 361
 362 static gpointer __zblib_request_create_zcl_door_lock_request_data(guint request_type,
 363         gpointer request_data, guint request_data_len)
 364 {
 365         gpointer door_lock_request_data = NULL;
 366         guint ops_id;
 367
 368         NOT_USED(request_data_len);
 369
 370         /* Fetch ops ID */
 371         ops_id = __zblib_request_get_ops_id(request_type);
 372         switch (ops_id) {
 373         case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
 374                 ZigbeeZclDoorLockSubscriberLockEvent_t *in_req;
 375                 ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
 376
 377                 in_req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request_data;
 378                 if (in_req) {
 379                         /* Allocate memory */
 380                         req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)
 381                                 g_malloc0(sizeof(ZigbeeZclDoorLockSubscriberLockEvent_t));
 382
 383                         /* Copy data */
 384                         memcpy(req->eui64,
 385                                 in_req->eui64, ZIGBEE_EUI64_SIZE);
 386                         req->endpoint = in_req->endpoint;
 387                 }
 388
 389                 door_lock_request_data = (gpointer)req;
 390         }
 391         break;
 392
 393         case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
 394                 ZigbeeZclDoorLockSetDoorLockPin_t *in_req;
 395                 ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
 396
 397                 in_req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request_data;
 398                 if (in_req) {
 399                         /* Allocate memory */
 400                         req = (ZigbeeZclDoorLockSetDoorLockPin_t *)
 401                                 g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLockPin_t));
 402
 403                         /* Copy data */
 404                         req->uid = in_req->uid;
 405                         req->ustatus = in_req->ustatus;
 406                         req->utype = in_req->utype;
 407                         memcpy(req->eui64,
 408                                 in_req->eui64, ZIGBEE_EUI64_SIZE);
 409                         req->endpoint = in_req->endpoint;
 410                         memcpy(req->pin,
 411                                 in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN);
 412                 }
 413
 414                 door_lock_request_data = (gpointer)req;
 415         }
 416         break;
 417
 418         case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
 419                 ZigbeeZclDoorLockSetDoorLock_t *in_req;
 420                 ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
 421
 422                 in_req = (ZigbeeZclDoorLockSetDoorLock_t *)request_data;
 423                 if (in_req) {
 424                         /* Allocate memory */
 425                         req = (ZigbeeZclDoorLockSetDoorLock_t *)
 426                                 g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLock_t));
 427
 428                         /* Copy data */
 429                         memcpy(req->eui64,
 430                                 in_req->eui64, ZIGBEE_EUI64_SIZE);
 431                         req->endpoint = in_req->endpoint;
 432                         memcpy(req->pin,
 433                                 in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN);
 434                         req->lock_unlock_type = in_req->lock_unlock_type;
 435                 }
 436
 437                 door_lock_request_data = (gpointer)req;
 438         }
 439         break;
 440
 441         case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
 442                 ZigbeeZclDoorLockGetDoorLock_t *in_req;
 443                 ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
 444
 445                 in_req = (ZigbeeZclDoorLockGetDoorLock_t *)request_data;
 446                 if (in_req) {
 447                         /* Allocate memory */
 448                         req = (ZigbeeZclDoorLockGetDoorLock_t *)
 449                                 g_malloc0(sizeof(ZigbeeZclDoorLockGetDoorLock_t));
 450
 451                         /* Copy data */
 452                         memcpy(req->eui64,
 453                                 in_req->eui64, ZIGBEE_EUI64_SIZE);
 454                         req->endpoint = in_req->endpoint;
 455                 }
 456
 457                 door_lock_request_data = (gpointer)req;
 458         }
 459         break;
 460
 461         default:
 462         break;
 463         }
 464
 465         return door_lock_request_data;
 466 }
 467
 468 static gpointer __zblib_request_create_zcl_fan_control_request_data(guint request_type,
 469         gpointer request_data, guint request_data_len)
 470 {
 471         gpointer fan_control_request_data = NULL;
 472         guint ops_id;
 473
 474         NOT_USED(request_data_len);
 475
 476         /* Fetch ops ID */
 477         ops_id = __zblib_request_get_ops_id(request_type);
 478         switch (ops_id) {
 479         case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
 480                 ZigbeeZclFanControlSetFanMode_t *in_req;
 481                 ZigbeeZclFanControlSetFanMode_t *req = NULL;
 482
 483                 in_req = (ZigbeeZclFanControlSetFanMode_t *)request_data;
 484                 if (in_req) {
 485                         /* Allocate memory */
 486                         req = (ZigbeeZclFanControlSetFanMode_t *)
 487                                 g_malloc0(sizeof(ZigbeeZclFanControlSetFanMode_t));
 488
 489                         /* Copy data */
 490                         memcpy(req->eui64,
 491                                 in_req->eui64, ZIGBEE_EUI64_SIZE);
 492                         req->endpoint = in_req->endpoint;
 493                 }
 494
 495                 fan_control_request_data = (gpointer)req;
 496         }
 497         break;
 498
 499         case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
 500                 ZigbeeZclFanControlGetFanMode_t *in_req;
 501                 ZigbeeZclFanControlGetFanMode_t *req = NULL;
 502
 503                 in_req = (ZigbeeZclFanControlGetFanMode_t *)request_data;
 504                 if (in_req) {
 505                         /* Allocate memory */
 506                         req = (ZigbeeZclFanControlGetFanMode_t *)
 507                                 g_malloc0(sizeof(ZigbeeZclFanControlGetFanMode_t));
 508
 509                         /* Copy data */
 510                         memcpy(req->eui64,
 511                                 in_req->eui64, ZIGBEE_EUI64_SIZE);
 512                         req->endpoint = in_req->endpoint;
 513                 }
 514
 515                 fan_control_request_data = (gpointer)req;
 516         }
 517         break;
 518
 519         case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
 520                 ZigbeeZclFanControlSetFanModeSequence_t *in_req;
 521                 ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
 522
 523                 in_req = (ZigbeeZclFanControlSetFanModeSequence_t *)request_data;
 524                 if (in_req) {
 525                         /* Allocate memory */
 526                         req = (ZigbeeZclFanControlSetFanModeSequence_t *)
 527                                 g_malloc0(sizeof(ZigbeeZclFanControlSetFanModeSequence_t));
 528
 529                         /* Copy data */
 530                         memcpy(req->eui64,
 531                                 in_req->eui64, ZIGBEE_EUI64_SIZE);
 532                         req->endpoint = in_req->endpoint;
 533                 }
 534
 535                 fan_control_request_data = (gpointer)req;
 536         }
 537         break;
 538
 539         case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
 540                 ZigbeeZclFanControlGetFanModeSequence_t *in_req;
 541                 ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
 542
 543                 in_req = (ZigbeeZclFanControlGetFanModeSequence_t *)request_data;
 544                 if (in_req) {
 545                         /* Allocate memory */
 546                         req = (ZigbeeZclFanControlGetFanModeSequence_t *)
 547                                 g_malloc0(sizeof(ZigbeeZclFanControlGetFanModeSequence_t));
 548
 549                         /* Copy data */
 550                         memcpy(req->eui64,
 551                                 in_req->eui64, ZIGBEE_EUI64_SIZE);
 552                         req->endpoint = in_req->endpoint;
 553                 }
 554
 555                 fan_control_request_data = (gpointer)req;
 556         }
 557         break;
 558
 559         default:
 560         break;
 561         }
 562
 563         return fan_control_request_data;
 564 }
 565
 566 static gpointer __zblib_request_create_zcl_level_control_request_data(guint request_type,
 567         gpointer request_data, guint request_data_len)
 568 {
 569         gpointer level_control_request_data = NULL;
 570         guint ops_id;
 571
 572         NOT_USED(request_data_len);
 573
 574         /* Fetch ops ID */
 575         ops_id = __zblib_request_get_ops_id(request_type);
 576         switch (ops_id) {
 577         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
 578                 ZigbeeZclLevelControlMoveToLevel_t *in_req;
 579                 ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
 580
 581                 in_req = (ZigbeeZclLevelControlMoveToLevel_t *)request_data;
 582                 if (in_req) {
 583                         /* Allocate memory */
 584                         req = (ZigbeeZclLevelControlMoveToLevel_t *)
 585                                 g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevel_t));
 586
 587                         /* Copy data */
 588                         req->node_id = in_req->node_id;
 589                         req->endpoint = in_req->endpoint;
 590                         req->level = in_req->level;
 591                         req->transition = in_req->transition;
 592                 }
 593
 594                 level_control_request_data = (gpointer)req;
 595         }
 596         break;
 597
 598         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
 599                 ZigbeeZclLevelControlMove_t *in_req;
 600                 ZigbeeZclLevelControlMove_t *req = NULL;
 601
 602                 in_req = (ZigbeeZclLevelControlMove_t *)request_data;
 603                 if (in_req) {
 604                         /* Allocate memory */
 605                         req = (ZigbeeZclLevelControlMove_t *)
 606                                 g_malloc0(sizeof(ZigbeeZclLevelControlMove_t));
 607
 608                         /* Copy data */
 609                         req->node_id = in_req->node_id;
 610                         req->endpoint = in_req->endpoint;
 611                         req->move_mode = in_req->move_mode;
 612                         req->rate = in_req->rate;
 613                 }
 614
 615                 level_control_request_data = (gpointer)req;
 616         }
 617         break;
 618
 619         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
 620                 ZigbeeZclLevelControlStep_t *in_req;
 621                 ZigbeeZclLevelControlStep_t *req = NULL;
 622
 623                 in_req = (ZigbeeZclLevelControlStep_t *)request_data;
 624                 if (in_req) {
 625                         /* Allocate memory */
 626                         req = (ZigbeeZclLevelControlStep_t *)
 627                                 g_malloc0(sizeof(ZigbeeZclLevelControlStep_t));
 628
 629                         /* Copy data */
 630                         req->node_id = in_req->node_id;
 631                         req->endpoint = in_req->endpoint;
 632                         req->step_mode = in_req->step_mode;
 633                         req->step_size = in_req->step_size;
 634                         req->transition_time = in_req->transition_time;
 635                 }
 636
 637                 level_control_request_data = (gpointer)req;
 638         }
 639         break;
 640
 641         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
 642                 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *in_req;
 643                 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
 644
 645                 in_req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request_data;
 646                 if (in_req) {
 647                         /* Allocate memory */
 648                         req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)
 649                                 g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevelWithOnOff_t));
 650
 651                         /* Copy data */
 652                         req->node_id = in_req->node_id;
 653                         req->endpoint = in_req->endpoint;
 654                         req->level = in_req->level;
 655                         req->transition = in_req->transition;
 656                 }
 657
 658                 level_control_request_data = (gpointer)req;
 659         }
 660         break;
 661
 662         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
 663                 ZigbeeZclLevelControlMoveWithOnOff_t *in_req;
 664                 ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
 665
 666                 in_req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request_data;
 667                 if (in_req) {
 668                         /* Allocate memory */
 669                         req = (ZigbeeZclLevelControlMoveWithOnOff_t *)
 670                                 g_malloc0(sizeof(ZigbeeZclLevelControlMoveWithOnOff_t));
 671
 672                         /* Copy data */
 673                         req->node_id = in_req->node_id;
 674                         req->endpoint = in_req->endpoint;
 675                         req->move_mode = in_req->move_mode;
 676                         req->rate = in_req->rate;
 677                 }
 678
 679                 level_control_request_data = (gpointer)req;
 680         }
 681         break;
 682
 683         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
 684                 ZigbeeZclLevelControlStepWithOnOff_t *in_req;
 685                 ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
 686
 687                 in_req = (ZigbeeZclLevelControlStepWithOnOff_t *)request_data;
 688                 if (in_req) {
 689                         /* Allocate memory */
 690                         req = (ZigbeeZclLevelControlStepWithOnOff_t *)
 691                                 g_malloc0(sizeof(ZigbeeZclLevelControlStepWithOnOff_t));
 692
 693                         /* Copy data */
 694                         req->node_id = in_req->node_id;
 695                         req->endpoint = in_req->endpoint;
 696                         req->step_mode = in_req->step_mode;
 697                         req->step_size = in_req->step_size;
 698                         req->transition_time = in_req->transition_time;
 699                 }
 700
 701                 level_control_request_data = (gpointer)req;
 702         }
 703         break;
 704
 705         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
 706                 ZigbeeZclLevelControlStop_t *in_req;
 707                 ZigbeeZclLevelControlStop_t *req = NULL;
 708
 709                 in_req = (ZigbeeZclLevelControlStop_t *)request_data;
 710                 if (in_req) {
 711                         /* Allocate memory */
 712                         req = (ZigbeeZclLevelControlStop_t *)
 713                                 g_malloc0(sizeof(ZigbeeZclLevelControlStop_t));
 714
 715                         /* Copy data */
 716                         req->node_id = in_req->node_id;
 717                         req->endpoint = in_req->endpoint;
 718                 }
 719
 720                 level_control_request_data = (gpointer)req;
 721         }
 722         break;
 723
 724         default:
 725         break;
 726         }
 727
 728         return level_control_request_data;
 729 }
 730
 731 static gpointer __zblib_request_create_mfglib_control_request_data(guint request_type,
 732         gpointer request_data, guint request_data_len)
 733 {
 734         gpointer mfglib_control_request_data = NULL;
 735         guint ops_id;
 736
 737         NOT_USED(request_data_len);
 738
 739         /* Fetch ops ID */
 740         ops_id = __zblib_request_get_ops_id(request_type);
 741         switch (ops_id) {
 742         case ZBLIB_MFGLIB_CONTROL_OPS_START: {
 743                 ZigbeeMfglibControlStart_t *in_req;
 744                 ZigbeeMfglibControlStart_t *req = NULL;
 745
 746                 in_req = (ZigbeeMfglibControlStart_t *)request_data;
 747                 if (NULL != in_req) {
 748                         /* Allocate memory */
 749                         req = (ZigbeeMfglibControlStart_t *)
 750                                 g_malloc0(sizeof(ZigbeeMfglibControlStart_t));
 751
 752                         /* Copy data */
 753                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 754                         req->mfglib_start = in_req->mfglib_start;
 755                 }
 756
 757                 mfglib_control_request_data = (gpointer)req;
 758         }
 759         break;
 760
 761         case ZBLIB_MFGLIB_CONTROL_OPS_END: {
 762                 ZigbeeMfglibControlEnd_t *in_req;
 763                 ZigbeeMfglibControlEnd_t *req = NULL;
 764
 765                 in_req = (ZigbeeMfglibControlEnd_t *)request_data;
 766                 if (NULL != in_req) {
 767                         /* Allocate memory */
 768                         req = (ZigbeeMfglibControlEnd_t *)
 769                                 g_malloc0(sizeof(ZigbeeMfglibControlEnd_t));
 770
 771                         /* Copy data */
 772                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 773                 }
 774
 775                 mfglib_control_request_data = (gpointer)req;
 776         }
 777         break;
 778
 779         case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
 780                 ZigbeeMfglibControlStartTone_t *in_req;
 781                 ZigbeeMfglibControlStartTone_t *req = NULL;
 782
 783                 in_req = (ZigbeeMfglibControlStartTone_t *)request_data;
 784                 if (NULL != in_req) {
 785                         /* Allocate memory */
 786                         req = (ZigbeeMfglibControlStartTone_t *)
 787                                 g_malloc0(sizeof(ZigbeeMfglibControlStartTone_t));
 788
 789                         /* Copy data */
 790                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 791                 }
 792
 793                 mfglib_control_request_data = (gpointer)req;
 794         }
 795         break;
 796
 797         case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
 798                 ZigbeeMfglibControlStopTone_t *in_req;
 799                 ZigbeeMfglibControlStopTone_t *req = NULL;
 800
 801                 in_req = (ZigbeeMfglibControlStopTone_t *)request_data;
 802                 if (NULL != in_req) {
 803                         /* Allocate memory */
 804                         req = (ZigbeeMfglibControlStopTone_t *)
 805                                 g_malloc0(sizeof(ZigbeeMfglibControlStopTone_t));
 806
 807                         /* Copy data */
 808                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 809                 }
 810
 811                 mfglib_control_request_data = (gpointer)req;
 812         }
 813         break;
 814
 815         case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
 816                 ZigbeeMfglibControlStartStream_t *in_req;
 817                 ZigbeeMfglibControlStartStream_t *req = NULL;
 818
 819                 in_req = (ZigbeeMfglibControlStartStream_t *)request_data;
 820                 if (NULL != in_req) {
 821                         /* Allocate memory */
 822                         req = (ZigbeeMfglibControlStartStream_t *)
 823                                 g_malloc0(sizeof(ZigbeeMfglibControlStartStream_t));
 824
 825                         /* Copy data */
 826                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 827                 }
 828
 829                 mfglib_control_request_data = (gpointer)req;
 830         }
 831         break;
 832
 833         case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
 834                 ZigbeeMfglibControlStopStream_t *in_req;
 835                 ZigbeeMfglibControlStopStream_t *req = NULL;
 836
 837                 in_req = (ZigbeeMfglibControlStopStream_t *)request_data;
 838                 if (NULL != in_req) {
 839                         /* Allocate memory */
 840                         req = (ZigbeeMfglibControlStopStream_t *)
 841                                 g_malloc0(sizeof(ZigbeeMfglibControlStopStream_t));
 842
 843                         /* Copy data */
 844                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 845                 }
 846
 847                 mfglib_control_request_data = (gpointer)req;
 848         }
 849         break;
 850
 851         case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
 852                 ZigbeeMfglibControlSendPacket_t *in_req;
 853                 ZigbeeMfglibControlSendPacket_t *req = NULL;
 854
 855                 in_req = (ZigbeeMfglibControlSendPacket_t *)request_data;
 856                 if (NULL != in_req) {
 857                         /* Allocate memory */
 858                         req = (ZigbeeMfglibControlSendPacket_t *)
 859                                 g_malloc0(sizeof(ZigbeeMfglibControlSendPacket_t));
 860
 861                         /* Copy data */
 862                         memcpy(req->packet_content,
 863                                 in_req->packet_content,
 864                                 ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN);
 865                         req->packet_length = in_req->packet_length;
 866                 }
 867
 868                 mfglib_control_request_data = (gpointer)req;
 869         }
 870         break;
 871
 872         case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
 873                 ZigbeeMfglibControlSetChannel_t *in_req;
 874                 ZigbeeMfglibControlSetChannel_t *req = NULL;
 875
 876                 in_req = (ZigbeeMfglibControlSetChannel_t *)request_data;
 877                 if (NULL != in_req) {
 878                         /* Allocate memory */
 879                         req = (ZigbeeMfglibControlSetChannel_t *)
 880                                 g_malloc0(sizeof(ZigbeeMfglibControlSetChannel_t));
 881
 882                         /* Copy data */
 883                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 884                         req->channel = in_req->channel;
 885                 }
 886
 887                 mfglib_control_request_data = (gpointer)req;
 888         }
 889         break;
 890
 891         case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
 892                 ZigbeeMfglibControlGetChannel_t *in_req;
 893                 ZigbeeMfglibControlGetChannel_t *req = NULL;
 894
 895                 in_req = (ZigbeeMfglibControlGetChannel_t *)request_data;
 896                 if (NULL != in_req) {
 897                         /* Allocate memory */
 898                         req = (ZigbeeMfglibControlGetChannel_t *)
 899                                 g_malloc0(sizeof(ZigbeeMfglibControlGetChannel_t));
 900
 901                         /* Copy data */
 902                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 903                 }
 904
 905                 mfglib_control_request_data = (gpointer)req;
 906         }
 907         break;
 908
 909         case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
 910                 ZigbeeMfglibControlSetPower_t *in_req;
 911                 ZigbeeMfglibControlSetPower_t *req = NULL;
 912
 913                 in_req = (ZigbeeMfglibControlSetPower_t *)request_data;
 914                 if (NULL != in_req) {
 915                         /* Allocate memory */
 916                         req = (ZigbeeMfglibControlSetPower_t *)
 917                                 g_malloc0(sizeof(ZigbeeMfglibControlSetPower_t));
 918
 919                         /* Copy data */
 920                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 921                         req->tx_power_mode = in_req->tx_power_mode;
 922                         req->power = in_req->power;
 923                 }
 924
 925                 mfglib_control_request_data = (gpointer)req;
 926         }
 927         break;
 928
 929         case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
 930                 ZigbeeMfglibControlGetPower_t *in_req;
 931                 ZigbeeMfglibControlGetPower_t *req = NULL;
 932
 933                 in_req = (ZigbeeMfglibControlGetPower_t *)request_data;
 934                 if (NULL != in_req) {
 935                         /* Allocate memory */
 936                         req = (ZigbeeMfglibControlGetPower_t *)
 937                                 g_malloc0(sizeof(ZigbeeMfglibControlGetPower_t));
 938
 939                         /* Copy data */
 940                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 941                 }
 942
 943                 mfglib_control_request_data = (gpointer)req;
 944         }
 945         break;
 946
 947         case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
 948                 ZigbeeMfglibControlSetSynOffset_t *in_req;
 949                 ZigbeeMfglibControlSetSynOffset_t *req = NULL;
 950
 951                 in_req = (ZigbeeMfglibControlSetSynOffset_t *)request_data;
 952                 if (NULL != in_req) {
 953                         /* Allocate memory */
 954                         req = (ZigbeeMfglibControlSetSynOffset_t *)
 955                                 g_malloc0(sizeof(ZigbeeMfglibControlSetSynOffset_t));
 956
 957                         /* Copy data */
 958                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
 959                         req->channel = in_req->channel;
 960                 }
 961
 962                 mfglib_control_request_data = (gpointer)req;
 963         }
 964         break;
 965
 966         case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
 967                 ZigbeeMfglibControlGetSynOffset_t *in_req;
 968                 ZigbeeMfglibControlGetSynOffset_t *req = NULL;
 969
 970                 in_req = (ZigbeeMfglibControlGetSynOffset_t *)request_data;
 971                 if (NULL != in_req) {
 972                         /* Allocate memory */
 973                         req = (ZigbeeMfglibControlGetSynOffset_t *)
 974                                 g_malloc0(sizeof(ZigbeeMfglibControlGetSynOffset_t));
 975
 976                         /* Copy data */
 977                         memcpy(req->packet,
 978                                 in_req->packet,
 979                                 ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN);
 980                         req->packet_length = in_req->packet_length;
 981                         req->link_quality = in_req->link_quality;
 982                         req->rssi = in_req->rssi;
 983                 }
 984
 985                 mfglib_control_request_data = (gpointer)req;
 986         }
 987         break;
 988
 989         case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
 990                 ZigbeeMfglibControlRxStart_t *in_req;
 991                 ZigbeeMfglibControlRxStart_t *req = NULL;
 992
 993                 in_req = (ZigbeeMfglibControlRxStart_t *)request_data;
 994                 if (NULL != in_req) {
 995                         /* Allocate memory */
 996                         req = (ZigbeeMfglibControlRxStart_t *)
 997                                 g_malloc0(sizeof(ZigbeeMfglibControlRxStart_t));
 998
 999                         /* Copy data */
1000                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1001                 }
1002
1003                 mfglib_control_request_data = (gpointer)req;
1004         }
1005         break;
1006
1007         case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
1008                 ZigbeeMfglibControlRxStop_t *in_req;
1009                 ZigbeeMfglibControlRxStop_t *req = NULL;
1010
1011                 in_req = (ZigbeeMfglibControlRxStop_t *)request_data;
1012                 if (NULL != in_req) {
1013                         /* Allocate memory */
1014                         req = (ZigbeeMfglibControlRxStop_t *)
1015                                 g_malloc0(sizeof(ZigbeeMfglibControlRxStop_t));
1016
1017                         /* Copy data */
1018                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1019                 }
1020
1021                 mfglib_control_request_data = (gpointer)req;
1022         }
1023         break;
1024
1025         case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
1026                 ZigbeeMfglibControlRxVerify_t *in_req;
1027                 ZigbeeMfglibControlRxVerify_t *req = NULL;
1028
1029                 in_req = (ZigbeeMfglibControlRxVerify_t *)request_data;
1030                 if (NULL != in_req) {
1031                         /* Allocate memory */
1032                         req = (ZigbeeMfglibControlRxVerify_t *)
1033                                 g_malloc0(sizeof(ZigbeeMfglibControlRxVerify_t));
1034
1035                         /* Copy data */
1036                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1037                 }
1038
1039                 mfglib_control_request_data = (gpointer)req;
1040         }
1041         break;
1042
1043         case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
1044                 ZigbeeMfglibControlGetRssi_t *in_req;
1045                 ZigbeeMfglibControlGetRssi_t *req = NULL;
1046
1047                 in_req = (ZigbeeMfglibControlGetRssi_t *)request_data;
1048                 if (NULL != in_req) {
1049                         /* Allocate memory */
1050                         req = (ZigbeeMfglibControlGetRssi_t *)
1051                                 g_malloc0(sizeof(ZigbeeMfglibControlGetRssi_t));
1052
1053                         /* Copy data */
1054                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1055                 }
1056
1057                 mfglib_control_request_data = (gpointer)req;
1058         }
1059         break;
1060
1061         default:
1062         break;
1063         }
1064
1065         return mfglib_control_request_data;
1066 }
1067
1068 static gpointer __zblib_request_create_zcl_on_off_request_data(guint request_type,
1069         gpointer request_data, guint request_data_len)
1070 {
1071         gpointer on_off_request_data = NULL;
1072         guint ops_id;
1073
1074         NOT_USED(request_data_len);
1075
1076         /* Fetch ops ID */
1077         ops_id = __zblib_request_get_ops_id(request_type);
1078         switch (ops_id) {
1079         case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
1080                 ZigbeeZclOnOffSetOnOff_t *in_req;
1081                 ZigbeeZclOnOffSetOnOff_t *req = NULL;
1082
1083                 in_req = (ZigbeeZclOnOffSetOnOff_t *)request_data;
1084                 if (NULL != in_req) {
1085                         /* Allocate memory */
1086                         req = (ZigbeeZclOnOffSetOnOff_t *)
1087                                 g_malloc0(sizeof(ZigbeeZclOnOffSetOnOff_t));
1088
1089                         /* Copy data */
1090                         req->node_id = in_req->node_id;
1091                         req->endpoint = in_req->endpoint;
1092                         req->on_off_type = in_req->on_off_type;
1093                 }
1094
1095                 on_off_request_data = (gpointer)req;
1096         }
1097         break;
1098
1099         case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
1100                 ZigbeeZclOnOffGetOnOffState_t *in_req;
1101                 ZigbeeZclOnOffGetOnOffState_t *req = NULL;
1102
1103                 in_req = (ZigbeeZclOnOffGetOnOffState_t *)request_data;
1104                 if (NULL != in_req) {
1105                         /* Allocate memory */
1106                         req = (ZigbeeZclOnOffGetOnOffState_t *)
1107                                 g_malloc0(sizeof(ZigbeeZclOnOffGetOnOffState_t));
1108
1109                         /* Copy data */
1110                         req->node_id = in_req->node_id;
1111                         req->endpoint = in_req->endpoint;
1112                 }
1113
1114                 on_off_request_data = (gpointer)req;
1115         }
1116         break;
1117
1118         default:
1119         break;
1120         }
1121
1122         return on_off_request_data;
1123 }
1124
1125 static gpointer __zblib_request_create_service_request_data(guint request_type,
1126         gpointer request_data, guint request_data_len)
1127 {
1128         gpointer service_request_data = NULL;
1129         guint ops_id;
1130
1131         NOT_USED(request_data_len);
1132
1133         /* Fetch ops ID */
1134         ops_id = __zblib_request_get_ops_id(request_type);
1135         switch (ops_id) {
1136         case ZBLIB_SERVICE_OPS_ENABLE: {
1137                 service_request_data = NULL;
1138         }
1139         break;
1140
1141         case ZBLIB_SERVICE_OPS_DISABLE: {
1142                 service_request_data = NULL;
1143         }
1144         break;
1145
1146         case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
1147                 service_request_data = NULL;
1148         }
1149         break;
1150
1151         case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
1152                 service_request_data = NULL;
1153         }
1154         break;
1155
1156         case ZBLIB_SERVICE_OPS_COEX_START: {
1157                 ZigbeeServiceCoexStart_t *in_req;
1158                 ZigbeeServiceCoexStart_t *req = NULL;
1159
1160                 in_req = (ZigbeeServiceCoexStart_t *)request_data;
1161                 if (NULL != in_req) {
1162                         /* Allocate memory */
1163                         req = (ZigbeeServiceCoexStart_t *)
1164                                 g_malloc0(sizeof(ZigbeeServiceCoexStart_t));
1165
1166                         /* Copy data */
1167                         req->channel = in_req->channel;
1168                 }
1169
1170                 service_request_data = (gpointer)req;
1171         }
1172         break;
1173
1174         case ZBLIB_SERVICE_OPS_COEX_STOP: {
1175                 service_request_data = NULL;
1176         }
1177         break;
1178
1179         case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
1180                 service_request_data = NULL;
1181         }
1182         break;
1183
1184         case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
1185                 service_request_data = NULL;
1186         }
1187         break;
1188
1189         case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
1190                 ZigbeeServicePermitJoin_t *in_req;
1191                 ZigbeeServicePermitJoin_t *req = NULL;
1192
1193                 in_req = (ZigbeeServicePermitJoin_t *)request_data;
1194                 if (NULL != in_req) {
1195                         /* Allocate memory */
1196                         req = (ZigbeeServicePermitJoin_t *)
1197                                 g_malloc0(sizeof(ZigbeeServicePermitJoin_t));
1198
1199                         /* Copy data */
1200                         req->permit_join = in_req->permit_join;
1201                         req->duration = in_req->duration;
1202                 }
1203
1204                 service_request_data = (gpointer)req;
1205         }
1206         break;
1207
1208         case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
1209                 ZigbeeServiceLeaveRequest_t *in_req;
1210                 ZigbeeServiceLeaveRequest_t *req = NULL;
1211
1212                 in_req = (ZigbeeServiceLeaveRequest_t *)request_data;
1213                 if (NULL != in_req) {
1214                         /* Allocate memory */
1215                         req = (ZigbeeServiceLeaveRequest_t *)
1216                                 g_malloc0(sizeof(ZigbeeServiceLeaveRequest_t));
1217
1218                         /* Copy data */
1219                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1220                         req->remove_child = in_req->remove_child;
1221                         req->rejoin = in_req->rejoin;
1222                 }
1223
1224                 service_request_data = (gpointer)req;
1225         }
1226         break;
1227
1228         case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
1229                 service_request_data = NULL;
1230         }
1231         break;
1232
1233         case ZBLIB_SERVICE_OPS_GET_MAC: {
1234                 service_request_data = NULL;
1235         }
1236         break;
1237
1238         case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
1239                 service_request_data = NULL;
1240         }
1241         break;
1242
1243         case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
1244                 ZigbeeServiceGetEndpointList_t *in_req;
1245                 ZigbeeServiceGetEndpointList_t *req = NULL;
1246
1247                 in_req = (ZigbeeServiceGetEndpointList_t *)request_data;
1248                 if (NULL != in_req) {
1249                         /* Allocate memory */
1250                         req = (ZigbeeServiceGetEndpointList_t *)
1251                                 g_malloc0(sizeof(ZigbeeServiceGetEndpointList_t));
1252
1253                         /* Copy data */
1254                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1255                 }
1256
1257                 service_request_data = (gpointer)req;
1258         }
1259         break;
1260
1261         case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
1262                 ZigbeeServiceGetClusterList_t *in_req;
1263                 ZigbeeServiceGetClusterList_t *req = NULL;
1264
1265                 in_req = (ZigbeeServiceGetClusterList_t *)request_data;
1266                 if (NULL != in_req) {
1267                         /* Allocate memory */
1268                         req = (ZigbeeServiceGetClusterList_t *)
1269                                 g_malloc0(sizeof(ZigbeeServiceGetClusterList_t));
1270
1271                         /* Copy data */
1272                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1273                         req->endpoint = in_req->endpoint;
1274                 }
1275
1276                 service_request_data = (gpointer)req;
1277         }
1278         break;
1279
1280         case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
1281                 ZigbeeServiceGetNodeType_t *in_req;
1282                 ZigbeeServiceGetNodeType_t *req = NULL;
1283
1284                 in_req = (ZigbeeServiceGetNodeType_t *)request_data;
1285                 if (NULL != in_req) {
1286                         /* Allocate memory */
1287                         req = (ZigbeeServiceGetNodeType_t *)
1288                                 g_malloc0(sizeof(ZigbeeServiceGetNodeType_t));
1289
1290                         /* Copy data */
1291                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1292                 }
1293
1294                 service_request_data = (gpointer)req;
1295         }
1296         break;
1297
1298         default:
1299                 Z_LOGE("Unexpected operation [%x]", ops_id);
1300         break;
1301         }
1302
1303         return service_request_data;
1304 }
1305
1306 static gpointer __zblib_request_create_zcl_thermostat_request_data(guint request_type,
1307         gpointer request_data, guint request_data_len)
1308 {
1309         gpointer thermostat_request_data = NULL;
1310         guint ops_id;
1311
1312         NOT_USED(request_data_len);
1313
1314         /* Fetch ops ID */
1315         ops_id = __zblib_request_get_ops_id(request_type);
1316         switch (ops_id) {
1317         case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
1318                 ZigbeeZclThermostatGetLocalTemp_t *in_req;
1319                 ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
1320
1321                 in_req = (ZigbeeZclThermostatGetLocalTemp_t *)request_data;
1322                 if (NULL != in_req) {
1323                         /* Allocate memory */
1324                         req = (ZigbeeZclThermostatGetLocalTemp_t *)
1325                                 g_malloc0(sizeof(ZigbeeZclThermostatGetLocalTemp_t));
1326
1327                         /* Copy data */
1328                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1329                         req->endpoint = in_req->endpoint;
1330                 }
1331
1332                 thermostat_request_data = (gpointer)req;
1333         }
1334         break;
1335
1336         case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
1337                 ZigbeeZclThermostatGetWeeklySchedule_t *in_req;
1338                 ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
1339
1340                 in_req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request_data;
1341                 if (NULL != in_req) {
1342                         /* Allocate memory */
1343                         req = (ZigbeeZclThermostatGetWeeklySchedule_t *)
1344                                 g_malloc0(sizeof(ZigbeeZclThermostatGetWeeklySchedule_t));
1345
1346                         /* Copy data */
1347                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1348                         req->endpoint = in_req->endpoint;
1349                         req->num_of_days = in_req->num_of_days;
1350                         req->mode = in_req->mode;
1351                 }
1352
1353                 thermostat_request_data = (gpointer)req;
1354         }
1355         break;
1356
1357         case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
1358                 ZigbeeZclThermostatSetWeeklySchedule_t *in_req;
1359                 ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
1360
1361                 in_req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request_data;
1362                 if (NULL != in_req) {
1363                         /* Allocate memory */
1364                         req = (ZigbeeZclThermostatSetWeeklySchedule_t *)
1365                                 g_malloc0(sizeof(ZigbeeZclThermostatSetWeeklySchedule_t));
1366
1367                         /* Copy data */
1368                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1369                         req->endpoint = in_req->endpoint;
1370                         req->no_of_transitions = in_req->no_of_transitions;
1371                         req->num_of_days = in_req->num_of_days;
1372                         req->mode = in_req->mode;
1373                         memcpy(req->payload,
1374                                 in_req->payload, ZIGBEE_THERMSTAT_PAYLOAD_MAX_LEN);
1375                         req->payload_len = in_req->payload_len;
1376                 }
1377
1378                 thermostat_request_data = (gpointer)req;
1379         }
1380         break;
1381
1382         case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
1383                 ZigbeeZclThermostatClearWeeklySchedule_t *in_req;
1384                 ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
1385
1386                 in_req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request_data;
1387                 if (NULL != in_req) {
1388                         /* Allocate memory */
1389                         req = (ZigbeeZclThermostatClearWeeklySchedule_t *)
1390                                 g_malloc0(sizeof(ZigbeeZclThermostatClearWeeklySchedule_t));
1391
1392                         /* Copy data */
1393                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
1394                         req->endpoint = in_req->endpoint;
1395                 }
1396
1397                 thermostat_request_data = (gpointer)req;
1398         }
1399         break;
1400
1401         case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
1402                 ZigbeeZclThermostatSetpointRaiseLower_t *in_req;
1403                 ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
1404
1405                 in_req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request_data;
1406                 if (NULL != in_req) {
1407                         /* Allocate memory */
1408                         req = (ZigbeeZclThermostatSetpointRaiseLower_t *)
1409                                 g_malloc0(sizeof(ZigbeeZclThermostatSetpointRaiseLower_t));
1410
1411                         /* Copy data */
1412                         req->node_id = in_req->node_id;
1413                         req->endpoint = in_req->endpoint;
1414                         req->mode = in_req->mode;
1415                         req->amount = in_req->amount;
1416                 }
1417
1418                 thermostat_request_data = (gpointer)req;
1419         }
1420         break;
1421
1422         default:
1423         break;
1424         }
1425
1426         return thermostat_request_data;
1427 }
1428
1429 static gpointer __zblib_request_create_zcl_basic_request_data(guint request_type,
1430         gpointer request_data, guint request_data_len)
1431 {
1432         gpointer zclbasic_control_request_data = NULL;
1433         guint ops_id;
1434
1435         NOT_USED(request_data_len);
1436
1437         /* Fetch ops ID */
1438         ops_id = __zblib_request_get_ops_id(request_type);
1439         switch (ops_id) {
1440         case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
1441                 ZigbeeZclBasicResetFactoryDefault_t *in_req;
1442                 ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
1443
1444                 in_req = (ZigbeeZclBasicResetFactoryDefault_t *)request_data;
1445                 if (NULL != in_req) {
1446                         /* Allocate memory */
1447                         req = (ZigbeeZclBasicResetFactoryDefault_t *)
1448                                 g_malloc0(sizeof(ZigbeeZclBasicResetFactoryDefault_t));
1449
1450                         /* Copy data */
1451                         req->node_id = in_req->node_id;
1452                         req->dest_ep = in_req->dest_ep;
1453                 }
1454
1455                 zclbasic_control_request_data = (gpointer)req;
1456         }
1457         break;
1458
1459         default:
1460         break;
1461         }
1462
1463         return zclbasic_control_request_data;
1464 }
1465
1466 static gpointer __zblib_request_create_zcl_global_control_request_data(guint request_type,
1467         gpointer request_data, guint request_data_len)
1468 {
1469         gpointer zclglobal_control_request_data = NULL;
1470         guint ops_id;
1471
1472         NOT_USED(request_data_len);
1473
1474         /* Fetch ops ID */
1475         ops_id = __zblib_request_get_ops_id(request_type);
1476         switch (ops_id) {
1477         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
1478                 ZigbeeZclGlobalControlReadAttributesRequest_t *in_req;
1479                 ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
1480
1481                 in_req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request_data;
1482                 if (NULL != in_req) {
1483                         /* Allocate memory */
1484                         req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)
1485                                 g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
1486
1487                         /* Copy data */
1488                         req->attribute_id = g_strdup(in_req->attribute_id);
1489                         req->attribute_id_len = in_req->attribute_id_len;
1490                         req->node_id = in_req->node_id;
1491                         req->cluster_id = in_req->cluster_id;
1492                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1493                         req->dest_ep = in_req->dest_ep;
1494                 }
1495
1496                 zclglobal_control_request_data = (gpointer)req;
1497         }
1498         break;
1499
1500         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
1501                 ZigbeeZclGlobalControlWriteAttributesRequest_t *in_req;
1502                 ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
1503
1504                 in_req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request_data;
1505                 if (NULL != in_req) {
1506                         /* Allocate memory */
1507                         req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)
1508                                 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesRequest_t));
1509
1510                         /* Copy data */
1511                         req->write_records = g_strdup(in_req->write_records);
1512                         req->records_len = in_req->records_len;
1513                         req->node_id = in_req->node_id;
1514                         req->cluster_id = in_req->cluster_id;
1515                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1516                         req->src_ep = in_req->src_ep;
1517                         req->dest_ep = in_req->dest_ep;
1518                 }
1519
1520                 zclglobal_control_request_data = (gpointer)req;
1521         }
1522         break;
1523
1524         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
1525                 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *in_req;
1526                 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
1527
1528                 in_req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request_data;
1529                 if (NULL != in_req) {
1530                         /* Allocate memory */
1531                         req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)
1532                                 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t));
1533
1534                         /* Copy data */
1535                         req->write_records = g_strdup(in_req->write_records);
1536                         req->records_len = in_req->records_len;
1537                         req->node_id = in_req->node_id;
1538                         req->cluster_id = in_req->cluster_id;
1539                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1540                         req->src_ep = in_req->src_ep;
1541                         req->dest_ep = in_req->dest_ep;
1542                 }
1543
1544                 zclglobal_control_request_data = (gpointer)req;
1545         }
1546         break;
1547
1548         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
1549                 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *in_req;
1550                 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
1551
1552                 in_req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request_data;
1553                 if (NULL != in_req) {
1554                         /* Allocate memory */
1555                         req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)
1556                                 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t));
1557
1558                         /* Copy data */
1559                         req->write_records = g_strdup(in_req->write_records);
1560                         req->records_len = in_req->records_len;
1561                         req->node_id = in_req->node_id;
1562                         req->cluster_id = in_req->cluster_id;
1563                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1564                         req->src_ep = in_req->src_ep;
1565                         req->dest_ep = in_req->dest_ep;
1566                 }
1567
1568                 zclglobal_control_request_data = (gpointer)req;
1569         }
1570         break;
1571
1572         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
1573                 ZigbeeZclGlobalControlWriteAttributesStructed_t *in_req;
1574                 ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
1575
1576                 in_req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request_data;
1577                 if (NULL != in_req) {
1578                         /* Allocate memory */
1579                         req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)
1580                                 g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t));
1581
1582                         /* Copy data */
1583                         req->write_records = g_strdup(in_req->write_records);
1584                         req->records_len = in_req->records_len;
1585                         req->node_id = in_req->node_id;
1586                         req->cluster_id = in_req->cluster_id;
1587                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1588                         req->src_ep = in_req->src_ep;
1589                         req->dest_ep = in_req->dest_ep;
1590                 }
1591
1592                 zclglobal_control_request_data = (gpointer)req;
1593         }
1594         break;
1595
1596         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
1597                 ZigbeeZclGlobalControlReadAttributesStructed_t *in_req;
1598                 ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
1599
1600                 in_req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request_data;
1601                 if (NULL != in_req) {
1602                         /* Allocate memory */
1603                         req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)
1604                                 g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t));
1605
1606                         /* Copy data */
1607                         req->read_records = g_strdup(in_req->read_records);
1608                         req->records_len = in_req->records_len;
1609                         req->node_id = in_req->node_id;
1610                         req->cluster_id = in_req->cluster_id;
1611                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1612                         req->src_ep = in_req->src_ep;
1613                         req->dest_ep = in_req->dest_ep;
1614                 }
1615
1616                 zclglobal_control_request_data = (gpointer)req;
1617         }
1618         break;
1619
1620         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
1621                 ZigbeeZclGlobalControlConfigureReportingReq_t *in_req;
1622                 ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
1623
1624                 in_req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request_data;
1625                 if (NULL != in_req) {
1626                         /* Allocate memory */
1627                         req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)
1628                                 g_malloc0(sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t));
1629
1630                         /* Copy data */
1631                         req->read_records = g_strdup(in_req->read_records);
1632                         req->records_len = in_req->records_len;
1633                         req->node_id = in_req->node_id;
1634                         req->cluster_id = in_req->cluster_id;
1635                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1636                         req->src_ep = in_req->src_ep;
1637                         req->dest_ep = in_req->dest_ep;
1638                 }
1639
1640                 zclglobal_control_request_data = (gpointer)req;
1641         }
1642         break;
1643
1644         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
1645                 ZigbeeZclGlobalControlReadConfigureReporting_t *in_req;
1646                 ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
1647
1648                 in_req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request_data;
1649                 if (NULL != in_req) {
1650                         /* Allocate memory */
1651                         req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)
1652                                 g_malloc0(sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t));
1653
1654                         /* Copy data */
1655                         req->read_records = g_strdup(in_req->read_records);
1656                         req->records_len = in_req->records_len;
1657                         req->node_id = in_req->node_id;
1658                         req->cluster_id = in_req->cluster_id;
1659                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1660                         req->src_ep = in_req->src_ep;
1661                         req->dest_ep = in_req->dest_ep;
1662                 }
1663
1664                 zclglobal_control_request_data = (gpointer)req;
1665         }
1666         break;
1667
1668         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
1669                 ZigbeeZclGlobalControlDiscoverAttributes_t *in_req;
1670                 ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
1671
1672                 in_req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request_data;
1673                 if (NULL != in_req) {
1674                         /* Allocate memory */
1675                         req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)
1676                                 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributes_t));
1677
1678                         /* Copy data */
1679                         req->node_id = in_req->node_id;
1680                         req->dest_ep = in_req->dest_ep;
1681                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1682                         req->cluster_id = in_req->cluster_id;
1683                         req->start_attribute = in_req->start_attribute;
1684                         req->max = in_req->max;
1685                 }
1686
1687                 zclglobal_control_request_data = (gpointer)req;
1688         }
1689         break;
1690
1691         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
1692                 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *in_req;
1693                 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
1694
1695                 in_req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request_data;
1696                 if (NULL != in_req) {
1697                         /* Allocate memory */
1698                         req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)
1699                                 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributesExtended_t));
1700
1701                         /* Copy data */
1702                         req->node_id = in_req->node_id;
1703                         req->dest_ep = in_req->dest_ep;
1704                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1705                         req->cluster_id = in_req->cluster_id;
1706                         req->start_attribute = in_req->start_attribute;
1707                         req->max = in_req->max;
1708                 }
1709
1710                 zclglobal_control_request_data = (gpointer)req;
1711         }
1712         break;
1713
1714         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
1715                 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *in_req;
1716                 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
1717
1718                 in_req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request_data;
1719                 if (NULL != in_req) {
1720                         /* Allocate memory */
1721                         req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)
1722                                 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsReceived_t));
1723
1724                         /* Copy data */
1725                         req->node_id = in_req->node_id;
1726                         req->dest_ep = in_req->dest_ep;
1727                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1728                         req->cluster_id = in_req->cluster_id;
1729                         req->start_attribute = in_req->start_attribute;
1730                         req->max = in_req->max;
1731                 }
1732
1733                 zclglobal_control_request_data = (gpointer)req;
1734         }
1735         break;
1736
1737         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
1738                 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *in_req;
1739                 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
1740
1741                 in_req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request_data;
1742                 if (NULL != in_req) {
1743                         /* Allocate memory */
1744                         req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)
1745                                 g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsGenerated_t));
1746
1747                         /* Copy data */
1748                         req->node_id = in_req->node_id;
1749                         req->dest_ep = in_req->dest_ep;
1750                         req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
1751                         req->cluster_id = in_req->cluster_id;
1752                         req->start_attribute = in_req->start_attribute;
1753                         req->max = in_req->max;
1754                 }
1755
1756                 zclglobal_control_request_data = (gpointer)req;
1757         }
1758         break;
1759
1760         default:
1761         break;
1762         }
1763
1764         return zclglobal_control_request_data;
1765 }
1766
1767 static gpointer __zblib_request_create_zcl_ias_zone_request_data(guint request_type,
1768         gpointer request_data, guint request_data_len)
1769 {
1770         gpointer zclias_control_request_data = NULL;
1771         guint ops_id;
1772
1773         NOT_USED(request_data_len);
1774
1775         /* Fetch ops ID */
1776         ops_id = __zblib_request_get_ops_id(request_type);
1777         switch (ops_id) {
1778         case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
1779                 ZigbeeZclIasZoneEnrollResponse_t *in_req;
1780                 ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
1781
1782                 in_req = (ZigbeeZclIasZoneEnrollResponse_t *)request_data;
1783                 if (NULL != in_req) {
1784                         /* Allocate memory */
1785                         req = (ZigbeeZclIasZoneEnrollResponse_t *)
1786                                 g_malloc0(sizeof(ZigbeeZclIasZoneEnrollResponse_t));
1787
1788                         /* Copy data */
1789                         req->node_id = in_req->node_id;
1790                         req->dest_ep = in_req->dest_ep;
1791                         req->enroll_code = in_req->enroll_code;
1792                         req->zone_id = in_req->zone_id;
1793                 }
1794
1795                 zclias_control_request_data = (gpointer)req;
1796         }
1797         break;
1798
1799         default:
1800         break;
1801         }
1802
1803         return zclias_control_request_data;
1804 }
1805
1806 static gpointer __zblib_request_create_zcl_identify_request_data(guint request_type,
1807         gpointer request_data, guint request_data_len)
1808 {
1809         gpointer zclidentify_control_request_data = NULL;
1810         guint ops_id;
1811
1812         NOT_USED(request_data_len);
1813
1814         /* Fetch ops ID */
1815         ops_id = __zblib_request_get_ops_id(request_type);
1816         switch (ops_id) {
1817         case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
1818                 ZigbeeZclIdentifyIdentify_t *in_req;
1819                 ZigbeeZclIdentifyIdentify_t *req = NULL;
1820
1821                 in_req = (ZigbeeZclIdentifyIdentify_t *)request_data;
1822                 if (NULL != in_req) {
1823                         /* Allocate memory */
1824                         req = (ZigbeeZclIdentifyIdentify_t *)
1825                                 g_malloc0(sizeof(ZigbeeZclIdentifyIdentify_t));
1826
1827                         /* Copy data */
1828                         req->node_id = in_req->node_id;
1829                         req->dest_ep = in_req->dest_ep;
1830                         req->identify_time = in_req->identify_time;
1831                 }
1832
1833                 zclidentify_control_request_data = (gpointer)req;
1834         }
1835         break;
1836
1837         case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
1838                 ZigbeeZclIdentifyQuery_t *in_req;
1839                 ZigbeeZclIdentifyQuery_t *req = NULL;
1840
1841                 in_req = (ZigbeeZclIdentifyQuery_t *)request_data;
1842                 if (NULL != in_req) {
1843                         /* Allocate memory */
1844                         req = (ZigbeeZclIdentifyQuery_t *)
1845                                 g_malloc0(sizeof(ZigbeeZclIdentifyQuery_t));
1846
1847                         /* Copy data */
1848                         req->node_id = in_req->node_id;
1849                 }
1850
1851                 zclidentify_control_request_data = (gpointer)req;
1852         }
1853         break;
1854
1855         default:
1856         break;
1857         }
1858
1859         return zclidentify_control_request_data;
1860 }
1861
1862 static gpointer __zblib_request_create_zcl_color_control_request_data(guint request_type,
1863         gpointer request_data, guint request_data_len)
1864 {
1865         gpointer zcl_color_request_data = NULL;
1866         guint ops_id;
1867
1868         NOT_USED(request_data_len);
1869
1870         /* Fetch ops ID */
1871         ops_id = __zblib_request_get_ops_id(request_type);
1872         switch (ops_id) {
1873         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
1874                 ZigbeeZclColorControlMoveToHue_t *in_req;
1875                 ZigbeeZclColorControlMoveToHue_t *req = NULL;
1876
1877                 in_req = (ZigbeeZclColorControlMoveToHue_t *)request_data;
1878                 if (NULL != in_req) {
1879                         /* Allocate memory */
1880                         req = (ZigbeeZclColorControlMoveToHue_t *)
1881                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHue_t));
1882
1883                         /* Copy data */
1884                         req->node_id = in_req->node_id;
1885                         req->dest_ep = in_req->dest_ep;
1886                         req->hue = in_req->hue;
1887                         req->direction = in_req->direction;
1888                         req->transition_time = in_req->transition_time;
1889                 }
1890
1891                 zcl_color_request_data = (gpointer)req;
1892         }
1893         break;
1894
1895         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
1896                 ZigbeeZclColorControlMoveHue_t *in_req;
1897                 ZigbeeZclColorControlMoveHue_t *req = NULL;
1898
1899                 in_req = (ZigbeeZclColorControlMoveHue_t *)request_data;
1900                 if (NULL != in_req) {
1901                         /* Allocate memory */
1902                         req = (ZigbeeZclColorControlMoveHue_t *)
1903                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveHue_t));
1904
1905                         /* Copy data */
1906                         req->node_id = in_req->node_id;
1907                         req->dest_ep = in_req->dest_ep;
1908                         req->move_mode = in_req->move_mode;
1909                         req->rate = in_req->rate;
1910                 }
1911
1912                 zcl_color_request_data = (gpointer)req;
1913         }
1914         break;
1915
1916         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
1917                 ZigbeeZclColorControlStepHue_t *in_req;
1918                 ZigbeeZclColorControlStepHue_t *req = NULL;
1919
1920                 in_req = (ZigbeeZclColorControlStepHue_t *)request_data;
1921                 if (NULL != in_req) {
1922                         /* Allocate memory */
1923                         req = (ZigbeeZclColorControlStepHue_t *)
1924                                 g_malloc0(sizeof(ZigbeeZclColorControlStepHue_t));
1925
1926                         /* Copy data */
1927                         req->node_id = in_req->node_id;
1928                         req->dest_ep = in_req->dest_ep;
1929                         req->step_mode = in_req->step_mode;
1930                         req->step_size = in_req->step_size;
1931                         req->transition_time = in_req->transition_time;
1932                 }
1933
1934                 zcl_color_request_data = (gpointer)req;
1935         }
1936         break;
1937
1938         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
1939                 ZigbeeZclColorControlMoveToSaturation_t *in_req;
1940                 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
1941
1942                 in_req = (ZigbeeZclColorControlMoveToSaturation_t *)request_data;
1943                 if (NULL != in_req) {
1944                         /* Allocate memory */
1945                         req = (ZigbeeZclColorControlMoveToSaturation_t *)
1946                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveToSaturation_t));
1947
1948                         /* Copy data */
1949                         req->node_id = in_req->node_id;
1950                         req->dest_ep = in_req->dest_ep;
1951                         req->saturation = in_req->saturation;
1952                         req->transition_time = in_req->transition_time;
1953                 }
1954
1955                 zcl_color_request_data = (gpointer)req;
1956         }
1957         break;
1958
1959         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
1960                 ZigbeeZclColorControlMoveSaturation_t *in_req;
1961                 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
1962
1963                 in_req = (ZigbeeZclColorControlMoveSaturation_t *)request_data;
1964                 if (NULL != in_req) {
1965                         /* Allocate memory */
1966                         req = (ZigbeeZclColorControlMoveSaturation_t *)
1967                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveSaturation_t));
1968
1969                         /* Copy data */
1970                         req->node_id = in_req->node_id;
1971                         req->dest_ep = in_req->dest_ep;
1972                         req->move_mode = in_req->move_mode;
1973                         req->rate = in_req->rate;
1974                 }
1975
1976                 zcl_color_request_data = (gpointer)req;
1977         }
1978         break;
1979
1980         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
1981                 ZigbeeZclColorControlStepSaturation_t *in_req;
1982                 ZigbeeZclColorControlStepSaturation_t *req = NULL;
1983
1984                 in_req = (ZigbeeZclColorControlStepSaturation_t *)request_data;
1985                 if (NULL != in_req) {
1986                         /* Allocate memory */
1987                         req = (ZigbeeZclColorControlStepSaturation_t *)
1988                                 g_malloc0(sizeof(ZigbeeZclColorControlStepSaturation_t));
1989
1990                         /* Copy data */
1991                         req->node_id = in_req->node_id;
1992                         req->dest_ep = in_req->dest_ep;
1993                         req->step_mode = in_req->step_mode;
1994                         req->step_size = in_req->step_size;
1995                         req->transition_time = in_req->transition_time;
1996                 }
1997
1998                 zcl_color_request_data = (gpointer)req;
1999         }
2000         break;
2001
2002         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
2003                 ZigbeeZclColorControlMoveToHueAndSaturation_t *in_req;
2004                 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
2005
2006                 in_req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request_data;
2007                 if (NULL != in_req) {
2008                         /* Allocate memory */
2009                         req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)
2010                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHueAndSaturation_t));
2011
2012                         /* Copy data */
2013                         req->node_id = in_req->node_id;
2014                         req->dest_ep = in_req->dest_ep;
2015                         req->hue = in_req->hue;
2016                         req->saturation = in_req->saturation;
2017                         req->transition_time = in_req->transition_time;
2018                 }
2019
2020                 zcl_color_request_data = (gpointer)req;
2021         }
2022         break;
2023
2024         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
2025                 ZigbeeZclColorControlMoveToColor_t *in_req;
2026                 ZigbeeZclColorControlMoveToColor_t *req = NULL;
2027
2028                 in_req = (ZigbeeZclColorControlMoveToColor_t *)request_data;
2029                 if (NULL != in_req) {
2030                         /* Allocate memory */
2031                         req = (ZigbeeZclColorControlMoveToColor_t *)
2032                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveToColor_t));
2033
2034                         /* Copy data */
2035                         req->node_id = in_req->node_id;
2036                         req->dest_ep = in_req->dest_ep;
2037                         req->color_x = in_req->color_x;
2038                         req->color_y = in_req->color_y;
2039                         req->transition_time = in_req->transition_time;
2040                 }
2041
2042                 zcl_color_request_data = (gpointer)req;
2043         }
2044         break;
2045
2046         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
2047                 ZigbeeZclColorControlMoveColor_t *in_req;
2048                 ZigbeeZclColorControlMoveColor_t *req = NULL;
2049
2050                 in_req = (ZigbeeZclColorControlMoveColor_t *)request_data;
2051                 if (NULL != in_req) {
2052                         /* Allocate memory */
2053                         req = (ZigbeeZclColorControlMoveColor_t *)
2054                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveColor_t));
2055
2056                         /* Copy data */
2057                         req->node_id = in_req->node_id;
2058                         req->dest_ep = in_req->dest_ep;
2059                         req->rate_x = in_req->rate_x;
2060                         req->rate_y = in_req->rate_y;
2061                 }
2062
2063                 zcl_color_request_data = (gpointer)req;
2064         }
2065         break;
2066
2067         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
2068                 ZigbeeZclColorControlStepColor_t *in_req;
2069                 ZigbeeZclColorControlStepColor_t *req = NULL;
2070
2071                 in_req = (ZigbeeZclColorControlStepColor_t *)request_data;
2072                 if (NULL != in_req) {
2073                         /* Allocate memory */
2074                         req = (ZigbeeZclColorControlStepColor_t *)
2075                                 g_malloc0(sizeof(ZigbeeZclColorControlStepColor_t));
2076
2077                         /* Copy data */
2078                         req->node_id = in_req->node_id;
2079                         req->dest_ep = in_req->dest_ep;
2080                         req->step_x = in_req->step_x;
2081                         req->step_y = in_req->step_y;
2082                         req->transition_time = in_req->transition_time;
2083                 }
2084
2085                 zcl_color_request_data = (gpointer)req;
2086         }
2087         break;
2088
2089         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
2090                 ZigbeeZclColorControlMoveColorTemperature_t *in_req;
2091                 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
2092
2093                 in_req = (ZigbeeZclColorControlMoveColorTemperature_t *)request_data;
2094                 if (NULL != in_req) {
2095                         /* Allocate memory */
2096                         req = (ZigbeeZclColorControlMoveColorTemperature_t *)
2097                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveColorTemperature_t));
2098
2099                         /* Copy data */
2100                         req->node_id = in_req->node_id;
2101                         req->dest_ep = in_req->dest_ep;
2102                         req->color_temperature = in_req->color_temperature;
2103                         req->transition_time = in_req->transition_time;
2104                 }
2105
2106                 zcl_color_request_data = (gpointer)req;
2107         }
2108         break;
2109
2110         default:
2111         break;
2112         }
2113
2114         return zcl_color_request_data;
2115 }
2116
2117 static gpointer __zblib_request_create_zcl_group_request_data(guint request_type,
2118         gpointer request_data, guint request_data_len)
2119 {
2120         gpointer zcl_group_request_data = NULL;
2121         guint ops_id;
2122
2123         NOT_USED(request_data_len);
2124
2125         /* Fetch ops ID */
2126         ops_id = __zblib_request_get_ops_id(request_type);
2127         switch (ops_id) {
2128         case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
2129                 ZigbeeZclGroupAddGroup_t *in_req;
2130                 ZigbeeZclGroupAddGroup_t *req = NULL;
2131
2132                 in_req = (ZigbeeZclGroupAddGroup_t *)request_data;
2133                 if (NULL != in_req) {
2134                         /* Allocate memory */
2135                         req = (ZigbeeZclGroupAddGroup_t *)
2136                                 g_malloc0(sizeof(ZigbeeZclGroupAddGroup_t));
2137
2138                         /* Copy data */
2139                         req->node_id = in_req->node_id;
2140                         req->dest_ep = in_req->dest_ep;
2141                         req->group_id = in_req->group_id;
2142                         g_strlcpy(req->group_name,
2143                                 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2144                 }
2145
2146                 zcl_group_request_data = (gpointer)req;
2147         }
2148         break;
2149
2150         case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
2151                 ZigbeeZclGroupViewGroup_t *in_req;
2152                 ZigbeeZclGroupViewGroup_t *req = NULL;
2153
2154                 in_req = (ZigbeeZclGroupViewGroup_t *)request_data;
2155                 if (NULL != in_req) {
2156                         /* Allocate memory */
2157                         req = (ZigbeeZclGroupViewGroup_t *)
2158                                 g_malloc0(sizeof(ZigbeeZclGroupViewGroup_t));
2159
2160                         /* Copy data */
2161                         req->node_id = in_req->node_id;
2162                         req->dest_ep = in_req->dest_ep;
2163                 }
2164
2165                 zcl_group_request_data = (gpointer)req;
2166         }
2167         break;
2168
2169         case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
2170                 ZigbeeZclGroupGetGroupMembership_t *in_req;
2171                 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
2172
2173                 in_req = (ZigbeeZclGroupGetGroupMembership_t *)request_data;
2174                 if (NULL != in_req) {
2175                         /* Allocate memory */
2176                         req = (ZigbeeZclGroupGetGroupMembership_t *)
2177                                 g_malloc0(sizeof(ZigbeeZclGroupGetGroupMembership_t));
2178
2179                         /* Copy data */
2180                         req->node_id = in_req->node_id;
2181                         req->dest_ep = in_req->dest_ep;
2182                         req->group_count = in_req->group_count;
2183                         req->group_list = (gshort *)g_memdup(in_req->group_list,
2184                                 in_req->group_count);
2185                 }
2186
2187                 zcl_group_request_data = (gpointer)req;
2188         }
2189         break;
2190
2191         case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
2192                 ZigbeeZclGroupRemoveGroup_t *in_req;
2193                 ZigbeeZclGroupRemoveGroup_t *req = NULL;
2194
2195                 in_req = (ZigbeeZclGroupRemoveGroup_t *)request_data;
2196                 if (NULL != in_req) {
2197                         /* Allocate memory */
2198                         req = (ZigbeeZclGroupRemoveGroup_t *)
2199                                 g_malloc0(sizeof(ZigbeeZclGroupRemoveGroup_t));
2200
2201                         /* Copy data */
2202                         req->node_id = in_req->node_id;
2203                         req->dest_ep = in_req->dest_ep;
2204                         req->group_id = in_req->group_id;
2205                 }
2206
2207                 zcl_group_request_data = (gpointer)req;
2208         }
2209         break;
2210
2211         case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
2212                 ZigbeeZclGroupRemoveAllGroup_t *in_req;
2213                 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
2214
2215                 in_req = (ZigbeeZclGroupRemoveAllGroup_t *)request_data;
2216                 if (NULL != in_req) {
2217                         /* Allocate memory */
2218                         req = (ZigbeeZclGroupRemoveAllGroup_t *)
2219                                 g_malloc0(sizeof(ZigbeeZclGroupRemoveAllGroup_t));
2220
2221                         /* Copy data */
2222                         req->node_id = in_req->node_id;
2223                         req->dest_ep = in_req->dest_ep;
2224                 }
2225
2226                 zcl_group_request_data = (gpointer)req;
2227         }
2228         break;
2229
2230         case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
2231                 ZigbeeZclGroupAddGroupIfIdentifying_t *in_req;
2232                 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
2233
2234                 in_req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request_data;
2235                 if (NULL != in_req) {
2236                         /* Allocate memory */
2237                         req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)
2238                                 g_malloc0(sizeof(ZigbeeZclGroupAddGroupIfIdentifying_t));
2239
2240                         /* Copy data */
2241                         req->node_id = in_req->node_id;
2242                         req->dest_ep = in_req->dest_ep;
2243                         req->group_id = in_req->group_id;
2244                         g_strlcpy(req->group_name,
2245                                 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2246                 }
2247
2248                 zcl_group_request_data = (gpointer)req;
2249         }
2250         break;
2251
2252         default:
2253         break;
2254         }
2255
2256         return zcl_group_request_data;
2257 }
2258
2259 static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type,
2260         gpointer request_data, guint request_data_len)
2261 {
2262         gpointer zcl_poll_control_request_data = NULL;
2263         guint ops_id;
2264
2265         NOT_USED(request_data_len);
2266
2267         /* Fetch ops ID */
2268         ops_id = __zblib_request_get_ops_id(request_type);
2269         switch (ops_id) {
2270         case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
2271                 ZigbeeZclPollControlCheckInResponse_t *in_req;
2272                 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
2273
2274                 in_req = (ZigbeeZclPollControlCheckInResponse_t *)request_data;
2275                 if (NULL != in_req) {
2276                         /* Allocate memory */
2277                         req = (ZigbeeZclPollControlCheckInResponse_t *)
2278                                 g_malloc0(sizeof(ZigbeeZclPollControlCheckInResponse_t));
2279
2280                         /* Copy data */
2281                         req->node_id = in_req->node_id;
2282                         req->dest_ep = in_req->dest_ep;
2283                         req->start_fast_polling = in_req->start_fast_polling;
2284                         req->fast_poll_timeout = in_req->fast_poll_timeout;
2285                 }
2286
2287                 zcl_poll_control_request_data = (gpointer)req;
2288         }
2289         break;
2290
2291         case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
2292                 ZigbeeZclPollControlFastPollStop_t *in_req;
2293                 ZigbeeZclPollControlFastPollStop_t *req = NULL;
2294
2295                 in_req = (ZigbeeZclPollControlFastPollStop_t *)request_data;
2296                 if (NULL != in_req) {
2297                         /* Allocate memory */
2298                         req = (ZigbeeZclPollControlFastPollStop_t *)
2299                                 g_malloc0(sizeof(ZigbeeZclPollControlFastPollStop_t));
2300
2301                         /* Copy data */
2302                         req->node_id = in_req->node_id;
2303                         req->dest_ep = in_req->dest_ep;
2304                 }
2305
2306                 zcl_poll_control_request_data = (gpointer)req;
2307         }
2308         break;
2309
2310         case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
2311                 ZigbeeZclPollControlSetLongPollInterval_t *in_req;
2312                 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
2313
2314                 in_req = (ZigbeeZclPollControlSetLongPollInterval_t *)request_data;
2315                 if (NULL != in_req) {
2316                         /* Allocate memory */
2317                         req = (ZigbeeZclPollControlSetLongPollInterval_t *)
2318                                 g_malloc0(sizeof(ZigbeeZclPollControlSetLongPollInterval_t));
2319
2320                         /* Copy data */
2321                         req->node_id = in_req->node_id;
2322                         req->dest_ep = in_req->dest_ep;
2323                         req->new_long_poll_interval = in_req->new_long_poll_interval;
2324                 }
2325
2326                 zcl_poll_control_request_data = (gpointer)req;
2327         }
2328         break;
2329
2330         case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
2331                 ZigbeeZclPollControlSetShortPollInterval_t *in_req;
2332                 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
2333
2334                 in_req = (ZigbeeZclPollControlSetShortPollInterval_t *)request_data;
2335                 if (NULL != in_req) {
2336                         /* Allocate memory */
2337                         req = (ZigbeeZclPollControlSetShortPollInterval_t *)
2338                                 g_malloc0(sizeof(ZigbeeZclPollControlSetShortPollInterval_t));
2339
2340                         /* Copy data */
2341                         req->node_id = in_req->node_id;
2342                         req->dest_ep = in_req->dest_ep;
2343                         req->new_short_poll_interval = in_req->new_short_poll_interval;
2344                 }
2345
2346                 zcl_poll_control_request_data = (gpointer)req;
2347         }
2348         break;
2349
2350         default:
2351         break;
2352         }
2353
2354         return zcl_poll_control_request_data;
2355 }
2356
2357 static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type,
2358         gpointer request_data, guint request_data_len)
2359 {
2360         gpointer zcl_scene_request_data = NULL;
2361         guint ops_id;
2362
2363         NOT_USED(request_data_len);
2364
2365         /* Fetch ops ID */
2366         ops_id = __zblib_request_get_ops_id(request_type);
2367         switch (ops_id) {
2368         case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
2369                 ZigbeeZclSceneAddScene_t *in_req;
2370                 ZigbeeZclSceneAddScene_t *req = NULL;
2371
2372                 in_req = (ZigbeeZclSceneAddScene_t *)request_data;
2373                 if (NULL != in_req) {
2374                         /* Allocate memory */
2375                         req = (ZigbeeZclSceneAddScene_t *)
2376                                 g_malloc0(sizeof(ZigbeeZclSceneAddScene_t));
2377
2378                         /* Copy data */
2379                         req->node_id = in_req->node_id;
2380                         req->dest_ep = in_req->dest_ep;
2381                         req->group_id = in_req->group_id;
2382                         req->scene_id = in_req->scene_id;
2383                         req->transition_time = in_req->transition_time;
2384                         g_strlcpy(req->scene_name,
2385                                 in_req->scene_name, ZIGBEE_ZCL_SCENE_NAME_MAX_LEN + 1);
2386                         req->ext_field_set_len = in_req->ext_field_set_len;
2387                         req->ext_field_set = (char *)g_memdup(in_req->ext_field_set,
2388                                 in_req->ext_field_set_len);
2389                 }
2390
2391                 zcl_scene_request_data = (gpointer)req;
2392         }
2393         break;
2394
2395         case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
2396                 ZigbeeZclSceneViewScene_t *in_req;
2397                 ZigbeeZclSceneViewScene_t *req = NULL;
2398
2399                 in_req = (ZigbeeZclSceneViewScene_t *)request_data;
2400                 if (NULL != in_req) {
2401                         /* Allocate memory */
2402                         req = (ZigbeeZclSceneViewScene_t *)
2403                                 g_malloc0(sizeof(ZigbeeZclSceneViewScene_t));
2404
2405                         /* Copy data */
2406                         req->node_id = in_req->node_id;
2407                         req->dest_ep = in_req->dest_ep;
2408                         req->group_id = in_req->group_id;
2409                         req->scene_id = in_req->scene_id;
2410                 }
2411
2412                 zcl_scene_request_data = (gpointer)req;
2413         }
2414         break;
2415
2416         case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
2417                 ZigbeeZclSceneRemoveScene_t *in_req;
2418                 ZigbeeZclSceneRemoveScene_t *req = NULL;
2419
2420                 in_req = (ZigbeeZclSceneRemoveScene_t *)request_data;
2421                 if (NULL != in_req) {
2422                         /* Allocate memory */
2423                         req = (ZigbeeZclSceneRemoveScene_t *)
2424                                 g_malloc0(sizeof(ZigbeeZclSceneRemoveScene_t));
2425
2426                         /* Copy data */
2427                         req->node_id = in_req->node_id;
2428                         req->dest_ep = in_req->dest_ep;
2429                         req->group_id = in_req->group_id;
2430                         req->scene_id = in_req->scene_id;
2431                 }
2432
2433                 zcl_scene_request_data = (gpointer)req;
2434         }
2435         break;
2436
2437         case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
2438                 ZigbeeZclSceneStoreScene_t *in_req;
2439                 ZigbeeZclSceneStoreScene_t *req = NULL;
2440
2441                 in_req = (ZigbeeZclSceneStoreScene_t *)request_data;
2442                 if (NULL != in_req) {
2443                         /* Allocate memory */
2444                         req = (ZigbeeZclSceneStoreScene_t *)
2445                                 g_malloc0(sizeof(ZigbeeZclSceneStoreScene_t));
2446
2447                         /* Copy data */
2448                         req->node_id = in_req->node_id;
2449                         req->dest_ep = in_req->dest_ep;
2450                         req->group_id = in_req->group_id;
2451                         req->scene_id = in_req->scene_id;
2452                 }
2453
2454                 zcl_scene_request_data = (gpointer)req;
2455         }
2456         break;
2457
2458         case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
2459                 ZigbeeZclSceneRecallScene_t *in_req;
2460                 ZigbeeZclSceneRecallScene_t *req = NULL;
2461
2462                 in_req = (ZigbeeZclSceneRecallScene_t *)request_data;
2463                 if (NULL != in_req) {
2464                         /* Allocate memory */
2465                         req = (ZigbeeZclSceneRecallScene_t *)
2466                                 g_malloc0(sizeof(ZigbeeZclSceneRecallScene_t));
2467
2468                         /* Copy data */
2469                         req->node_id = in_req->node_id;
2470                         req->dest_ep = in_req->dest_ep;
2471                         req->group_id = in_req->group_id;
2472                         req->scene_id = in_req->scene_id;
2473                 }
2474
2475                 zcl_scene_request_data = (gpointer)req;
2476         }
2477         break;
2478
2479         case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
2480                 ZigbeeZclSceneRemoveAllScene_t *in_req;
2481                 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
2482
2483                 in_req = (ZigbeeZclSceneRemoveAllScene_t *)request_data;
2484                 if (NULL != in_req) {
2485                         /* Allocate memory */
2486                         req = (ZigbeeZclSceneRemoveAllScene_t *)
2487                                 g_malloc0(sizeof(ZigbeeZclSceneRemoveAllScene_t));
2488
2489                         /* Copy data */
2490                         req->node_id = in_req->node_id;
2491                         req->dest_ep = in_req->dest_ep;
2492                         req->group_id = in_req->group_id;
2493                 }
2494
2495                 zcl_scene_request_data = (gpointer)req;
2496         }
2497         break;
2498
2499         case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
2500                 ZigbeeZclSceneGetSceneMembership_t *in_req;
2501                 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
2502
2503                 in_req = (ZigbeeZclSceneGetSceneMembership_t *)request_data;
2504                 if (NULL != in_req) {
2505                         /* Allocate memory */
2506                         req = (ZigbeeZclSceneGetSceneMembership_t *)
2507                                 g_malloc0(sizeof(ZigbeeZclSceneGetSceneMembership_t));
2508
2509                         /* Copy data */
2510                         req->node_id = in_req->node_id;
2511                         req->dest_ep = in_req->dest_ep;
2512                         req->group_id = in_req->group_id;
2513                 }
2514
2515                 zcl_scene_request_data = (gpointer)req;
2516         }
2517         break;
2518
2519         default:
2520         break;
2521         }
2522
2523         return zcl_scene_request_data;
2524 }
2525
2526 static gpointer __zblib_request_create_zdo_dev_control_request_data(guint request_type,
2527         gpointer request_data, guint request_data_len)
2528 {
2529         gpointer zdodev_control_request_data = NULL;
2530         guint ops_id;
2531
2532         NOT_USED(request_data_len);
2533
2534         /* Fetch ops ID */
2535         ops_id = __zblib_request_get_ops_id(request_type);
2536         switch (ops_id) {
2537         case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
2538                 ZigbeeZdoDevControlNwkAddrReq_t *in_req;
2539                 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
2540
2541                 in_req = (ZigbeeZdoDevControlNwkAddrReq_t *)request_data;
2542                 if (NULL != in_req) {
2543                         /* Allocate memory */
2544                         req = (ZigbeeZdoDevControlNwkAddrReq_t *)
2545                                 g_malloc0(sizeof(ZigbeeZdoDevControlNwkAddrReq_t));
2546
2547                         /* Copy data */
2548                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
2549                         req->request_type = in_req->request_type;
2550                         req->start_index = in_req->start_index;
2551                 }
2552
2553                 zdodev_control_request_data = (gpointer)req;
2554         }
2555         break;
2556
2557         case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
2558                 ZigbeeZdoDevControlMatchedDescriptorReq_t *in_req;
2559                 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
2560
2561                 in_req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request_data;
2562                 if (NULL != in_req) {
2563                         /* Allocate memory */
2564                         req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)
2565                                 g_malloc0(sizeof(ZigbeeZdoDevControlMatchedDescriptorReq_t));
2566
2567                         /* Copy data */
2568                         req->node_id = in_req->node_id;
2569                         req->profile_id = in_req->profile_id;
2570                         req->num_in_cl = in_req->num_in_cl;
2571                         req->in_cl = g_strdup(in_req->in_cl);
2572                         req->num_out_cl = in_req->num_out_cl;
2573                         req->out_cl = g_strdup(in_req->out_cl);
2574                 }
2575
2576                 zdodev_control_request_data = (gpointer)req;
2577         }
2578         break;
2579
2580         case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
2581                 ZigbeeZdoDevControlIeeeAddrReq_t *in_req;
2582                 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
2583
2584                 in_req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request_data;
2585                 if (NULL != in_req) {
2586                         /* Allocate memory */
2587                         req = (ZigbeeZdoDevControlIeeeAddrReq_t *)
2588                                 g_malloc0(sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
2589
2590                         /* Copy data */
2591                         req->node_id = in_req->node_id;
2592                 }
2593
2594                 zdodev_control_request_data = (gpointer)req;
2595         }
2596         break;
2597
2598         case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
2599                 ZigbeeZdoDevControlActiveEpReq_t *in_req;
2600                 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
2601
2602                 in_req = (ZigbeeZdoDevControlActiveEpReq_t *)request_data;
2603                 if (NULL != in_req) {
2604                         /* Allocate memory */
2605                         req = (ZigbeeZdoDevControlActiveEpReq_t *)
2606                                 g_malloc0(sizeof(ZigbeeZdoDevControlActiveEpReq_t));
2607
2608                         /* Copy data */
2609                         req->node_id = in_req->node_id;
2610                 }
2611
2612                 zdodev_control_request_data = (gpointer)req;
2613         }
2614         break;
2615
2616         case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
2617                 ZigbeeZdoDevControlNodeDescriptorReq_t *in_req;
2618                 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
2619
2620                 in_req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request_data;
2621                 if (NULL != in_req) {
2622                         /* Allocate memory */
2623                         req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)
2624                                 g_malloc0(sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
2625
2626                         /* Copy data */
2627                         req->node_id = in_req->node_id;
2628                 }
2629
2630                 zdodev_control_request_data = (gpointer)req;
2631         }
2632         break;
2633
2634         case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
2635                 ZigbeeZdoDevControlPowerDescriptorReq_t *in_req;
2636                 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
2637
2638                 in_req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request_data;
2639                 if (NULL != in_req) {
2640                         /* Allocate memory */
2641                         req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)
2642                                 g_malloc0(sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
2643
2644                         /* Copy data */
2645                         req->node_id = in_req->node_id;
2646                 }
2647
2648                 zdodev_control_request_data = (gpointer)req;
2649         }
2650         break;
2651
2652         case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
2653                 ZigbeeZdoDevControlComplexDescriptorReq_t *in_req;
2654                 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
2655
2656                 in_req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request_data;
2657                 if (NULL != in_req) {
2658                         /* Allocate memory */
2659                         req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)
2660                                 g_malloc0(sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
2661
2662                         /* Copy data */
2663                         req->node_id = in_req->node_id;
2664                 }
2665
2666                 zdodev_control_request_data = (gpointer)req;
2667         }
2668         break;
2669
2670         case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
2671                 ZigbeeZdoDevControlUserDescriptorReq_t *in_req;
2672                 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
2673
2674                 in_req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request_data;
2675                 if (NULL != in_req) {
2676                         /* Allocate memory */
2677                         req = (ZigbeeZdoDevControlUserDescriptorReq_t *)
2678                                 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
2679
2680                         /* Copy data */
2681                         req->node_id = in_req->node_id;
2682                 }
2683
2684                 zdodev_control_request_data = (gpointer)req;
2685         }
2686         break;
2687
2688         case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
2689                 ZigbeeZdoDevControlUserDescriptorSetReq_t *in_req;
2690                 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
2691
2692                 in_req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request_data;
2693                 if (NULL != in_req) {
2694                         /* Allocate memory */
2695                         req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)
2696                                 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
2697
2698                         /* Copy data */
2699                         req->node_id = in_req->node_id;
2700                         req->user_descriptor_len = in_req->user_descriptor_len;
2701                         memcpy(req->user_descriptor,
2702                                 in_req->user_descriptor, in_req->user_descriptor_len);
2703                 }
2704
2705                 zdodev_control_request_data = (gpointer)req;
2706         }
2707         break;
2708
2709         case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
2710                 ZigbeeZdoDevControlDeviceAnnounce_t *in_req;
2711                 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
2712
2713                 in_req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request_data;
2714                 if (NULL != in_req) {
2715                         /* Allocate memory */
2716                         req = (ZigbeeZdoDevControlDeviceAnnounce_t *)
2717                                 g_malloc0(sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
2718
2719                         /* Copy data */
2720                         req->node_id = in_req->node_id;
2721                         memcpy(req->mac_addr, in_req->mac_addr, ZIGBEE_EUI64_SIZE);
2722                         req->capability = in_req->capability;
2723                 }
2724
2725                 zdodev_control_request_data = (gpointer)req;
2726         }
2727         break;
2728
2729         case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
2730                 ZigbeeZdoDevControlSimpleDescriptorReq_t *in_req;
2731                 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
2732
2733                 in_req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request_data;
2734                 if (NULL != in_req) {
2735                         /* Allocate memory */
2736                         req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)
2737                                 g_malloc0(sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
2738
2739                         /* Copy data */
2740                         req->node_id = in_req->node_id;
2741                         req->endpoint = in_req->endpoint;
2742                 }
2743
2744                 zdodev_control_request_data = (gpointer)req;
2745         }
2746         break;
2747
2748         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
2749                 ZigbeeZdoDevControlMgmtLqiReq_t *in_req;
2750                 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
2751
2752                 in_req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request_data;
2753                 if (NULL != in_req) {
2754                         /* Allocate memory */
2755                         req = (ZigbeeZdoDevControlMgmtLqiReq_t *)
2756                                 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
2757
2758                         /* Copy data */
2759                         req->node_id = in_req->node_id;
2760                         req->start_index = in_req->start_index;
2761                 }
2762
2763                 zdodev_control_request_data = (gpointer)req;
2764         }
2765         break;
2766
2767         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
2768                 ZigbeeZdoDevControlMgmtRtgReq_t *in_req;
2769                 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
2770
2771                 in_req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request_data;
2772                 if (NULL != in_req) {
2773                         /* Allocate memory */
2774                         req = (ZigbeeZdoDevControlMgmtRtgReq_t *)
2775                                 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtRtgReq_t));
2776
2777                         /* Copy data */
2778                         req->node_id = in_req->node_id;
2779                         req->start_index = in_req->start_index;
2780                 }
2781
2782                 zdodev_control_request_data = (gpointer)req;
2783         }
2784         break;
2785
2786         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
2787                 ZigbeeZdoDevControlMgmtBindReq_t *in_req;
2788                 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
2789
2790                 in_req = (ZigbeeZdoDevControlMgmtBindReq_t *)request_data;
2791                 if (NULL != in_req) {
2792                         /* Allocate memory */
2793                         req = (ZigbeeZdoDevControlMgmtBindReq_t *)
2794                                 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtBindReq_t));
2795
2796                         /* Copy data */
2797                         req->node_id = in_req->node_id;
2798                         req->start_index = in_req->start_index;
2799                 }
2800
2801                 zdodev_control_request_data = (gpointer)req;
2802         }
2803         break;
2804
2805         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
2806                 ZigbeeZdoDevControlMgmtPermitJoinReq_t *in_req;
2807                 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
2808
2809                 in_req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request_data;
2810                 if (NULL != in_req) {
2811                         /* Allocate memory */
2812                         req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)
2813                                 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
2814
2815                         /* Copy data */
2816                         req->addr = in_req->addr;
2817                         req->duration = in_req->duration;
2818                         req->tc_significance = in_req->tc_significance;
2819                 }
2820
2821                 zdodev_control_request_data = (gpointer)req;
2822         }
2823         break;
2824
2825         case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
2826                 ZigbeeZdoDevControlNwkUpdateReq_t *in_req;
2827                 ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
2828
2829                 in_req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request_data;
2830                 if (NULL != in_req) {
2831                         /* Allocate memory */
2832                         req = (ZigbeeZdoDevControlNwkUpdateReq_t *)
2833                                 g_malloc0(sizeof(ZigbeeZdoDevControlNwkUpdateReq_t));
2834
2835                         /* Copy data */
2836                         req->node_id = in_req->node_id;
2837                         req->scan_channel = in_req->scan_channel;
2838                         req->scan_duration = in_req->scan_duration;
2839                         req->scan_count = in_req->scan_count;
2840                         req->network_update_id = in_req->network_update_id;
2841                 }
2842
2843                 zdodev_control_request_data = (gpointer)req;
2844         }
2845         break;
2846
2847         case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
2848                 ZigbeeZdoDevControlNwkDescriptorReq_t *in_req;
2849                 ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
2850
2851                 in_req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request_data;
2852                 if (NULL != in_req) {
2853                         /* Allocate memory */
2854                         req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)
2855                                 g_malloc0(sizeof(ZigbeeZdoDevControlNwkDescriptorReq_t));
2856
2857                         /* Copy data */
2858                         req->node_id = in_req->node_id;
2859                         req->scan_channel = in_req->scan_channel;
2860                         req->scan_duration = in_req->scan_duration;
2861                         req->scan_count = in_req->scan_count;
2862                         req->start_index = in_req->start_index;
2863                 }
2864
2865                 zdodev_control_request_data = (gpointer)req;
2866         }
2867         break;
2868
2869         default:
2870         break;
2871         }
2872
2873         return zdodev_control_request_data;
2874 }
2875
2876 static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type,
2877         gpointer request_data, guint request_data_len)
2878 {
2879         gpointer zdo_bind_request_data = NULL;
2880         guint ops_id;
2881
2882         NOT_USED(request_data_len);
2883
2884         /* Fetch ops ID */
2885         ops_id = __zblib_request_get_ops_id(request_type);
2886         switch (ops_id) {
2887         case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
2888                 ZigbeeZdoBindBindReq_t *in_req;
2889                 ZigbeeZdoBindBindReq_t *req = NULL;
2890
2891                 in_req = (ZigbeeZdoBindBindReq_t *)request_data;
2892                 if (NULL != in_req) {
2893                         /* Allocate memory */
2894                         req = (ZigbeeZdoBindBindReq_t *)
2895                                 g_malloc0(sizeof(ZigbeeZdoBindBindReq_t));
2896
2897                         /* Copy data */
2898                         req->node_id = in_req->node_id;
2899                         g_strlcpy(req->src_addr,
2900                                 in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2901                         req->src_ep = in_req->src_ep;
2902                         req->cluster_id = in_req->cluster_id;
2903                         g_strlcpy(req->dst_addr,
2904                                 in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2905                         req->bind_type = in_req->bind_type;
2906                         req->group_addr = in_req->group_addr;
2907                         req->dst_ep = in_req->dst_ep;
2908                 }
2909
2910                 zdo_bind_request_data = (gpointer)req;
2911         }
2912         break;
2913
2914         case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
2915                 ZigbeeZdoBindUnbindReq_t *in_req;
2916                 ZigbeeZdoBindUnbindReq_t *req = NULL;
2917
2918                 in_req = (ZigbeeZdoBindUnbindReq_t *)request_data;
2919                 if (NULL != in_req) {
2920                         /* Allocate memory */
2921                         req = (ZigbeeZdoBindUnbindReq_t *)
2922                                 g_malloc0(sizeof(ZigbeeZdoBindUnbindReq_t));
2923
2924                         /* Copy data */
2925                         req->node_id = in_req->node_id;
2926                         g_strlcpy(req->src_addr,
2927                                 in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2928                         req->src_ep = in_req->src_ep;
2929                         req->cluster_id = in_req->cluster_id;
2930                         g_strlcpy(req->dst_addr,
2931                                 in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
2932                         req->bind_type = in_req->bind_type;
2933                         req->group_addr = in_req->group_addr;
2934                         req->dst_ep = in_req->dst_ep;
2935                 }
2936
2937                 zdo_bind_request_data = (gpointer)req;
2938         }
2939         break;
2940
2941         default:
2942         break;
2943         }
2944
2945         return zdo_bind_request_data;
2946 }
2947
2948
2949 static gpointer __zblib_request_create_request_data(guint request_type,
2950         gpointer request_data, guint request_data_len)
2951 {
2952         gpointer _request_data = NULL;
2953         ZblibDriverType_e driver_type;
2954
2955         /* Fetch driver type */
2956         driver_type = __zblib_request_get_driver_type(request_type);
2957         switch (driver_type) {
2958         case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
2959                 _request_data = __zblib_request_create_zcl_alarm_request_data(request_type,
2960                         request_data, request_data_len);
2961         }
2962         break;
2963
2964         case ZBLIB_DRIVER_TYPE_CUSTOM: {
2965                 _request_data = __zblib_request_create_custom_request_data(request_type,
2966                         request_data, request_data_len);
2967         }
2968         break;
2969
2970         case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
2971                 _request_data = __zblib_request_create_zcl_door_lock_request_data(request_type,
2972                         request_data, request_data_len);
2973         }
2974         break;
2975
2976         case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
2977                 _request_data = __zblib_request_create_zcl_fan_control_request_data(request_type,
2978                         request_data, request_data_len);
2979         }
2980         break;
2981
2982         case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
2983                 _request_data = __zblib_request_create_zcl_level_control_request_data(request_type,
2984                         request_data, request_data_len);
2985         }
2986         break;
2987
2988         case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
2989                 _request_data = __zblib_request_create_mfglib_control_request_data(request_type,
2990                         request_data, request_data_len);
2991         }
2992         break;
2993
2994         case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
2995                 _request_data = __zblib_request_create_zcl_on_off_request_data(request_type,
2996                         request_data, request_data_len);
2997         }
2998         break;
2999
3000         case ZBLIB_DRIVER_TYPE_SERVICE: {
3001                 _request_data = __zblib_request_create_service_request_data(request_type,
3002                         request_data, request_data_len);
3003         }
3004         break;
3005
3006         case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
3007                 _request_data = __zblib_request_create_zcl_thermostat_request_data(request_type,
3008                         request_data, request_data_len);
3009         }
3010         break;
3011
3012         case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
3013                 _request_data = __zblib_request_create_zcl_basic_request_data(request_type,
3014                         request_data, request_data_len);
3015         }
3016         break;
3017
3018         case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
3019                 _request_data = __zblib_request_create_zcl_global_control_request_data(request_type,
3020                         request_data, request_data_len);
3021         }
3022         break;
3023
3024         case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
3025                 _request_data = __zblib_request_create_zcl_ias_zone_request_data(request_type,
3026                         request_data, request_data_len);
3027         }
3028         break;
3029
3030         case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
3031                 _request_data = __zblib_request_create_zcl_identify_request_data(request_type,
3032                         request_data, request_data_len);
3033         }
3034         break;
3035
3036         case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
3037                 _request_data = __zblib_request_create_zcl_color_control_request_data(request_type,
3038                         request_data, request_data_len);
3039         }
3040         break;
3041
3042         case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
3043                 _request_data = __zblib_request_create_zcl_group_request_data(request_type,
3044                         request_data, request_data_len);
3045         }
3046         break;
3047
3048         case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
3049                 _request_data = __zblib_request_create_zcl_poll_control_request_data(request_type,
3050                         request_data, request_data_len);
3051         }
3052         break;
3053
3054         case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
3055                 _request_data = __zblib_request_create_zcl_scene_request_data(request_type,
3056                         request_data, request_data_len);
3057         }
3058         break;
3059
3060         case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
3061                 _request_data = __zblib_request_create_zdo_dev_control_request_data(request_type,
3062                         request_data, request_data_len);
3063         }
3064         break;
3065
3066         case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
3067                 _request_data = __zblib_request_create_zdo_bind_request_data(request_type,
3068                         request_data, request_data_len);
3069         }
3070         break;
3071
3072         case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
3073         default: {
3074                 Z_LOGE("Unhandled driver type: [%d]", driver_type);
3075         }
3076         break;
3077         }
3078
3079         return _request_data;
3080 }
3081
3082 static void __zblib_request_free_zcl_alarm_request_data(ZigBeeRequest *request,
3083         guint request_type)
3084 {
3085         guint ops_id;
3086
3087         /* Fetch ops ID */
3088         ops_id = __zblib_request_get_ops_id(request_type);
3089         switch (ops_id) {
3090         case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: {
3091                 ZigbeeZclAlarmGetAlarmCount_t *req = NULL;
3092
3093                 req = (ZigbeeZclAlarmGetAlarmCount_t *)request->request_data;
3094                 if (NULL != req) {
3095                         g_free(req);
3096                 }
3097         }
3098         break;
3099
3100         case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
3101                 ZigbeeZclAlarmResetAlarm_t *req = NULL;
3102
3103                 req = (ZigbeeZclAlarmResetAlarm_t *)request->request_data;
3104                 if (NULL != req) {
3105                         g_free(req);
3106                 }
3107         }
3108         break;
3109
3110         case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
3111                 ZigbeeZclAlarmResetAllAlarm_t *req = NULL;
3112
3113                 req = (ZigbeeZclAlarmResetAllAlarm_t *)request->request_data;
3114                 if (NULL != req) {
3115                         g_free(req);
3116                 }
3117         }
3118         break;
3119
3120         case ZBLIB_ZCL_ALARM_OPS_ALARM: {
3121                 ZigbeeZclAlarmAlarm_t *req = NULL;
3122
3123                 req = (ZigbeeZclAlarmAlarm_t *)request->request_data;
3124                 if (NULL != req) {
3125                         g_free(req);
3126                 }
3127         }
3128         break;
3129
3130         case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
3131                 ZigbeeZclAlarmResetAlarmLogs_t *req = NULL;
3132
3133                 req = (ZigbeeZclAlarmResetAlarmLogs_t *)request->request_data;
3134                 if (NULL != req) {
3135                         g_free(req);
3136                 }
3137         }
3138         break;
3139
3140         case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
3141         }
3142         break;
3143
3144         default:
3145         break;
3146         }
3147 }
3148
3149 static void __zblib_request_free_custom_request_data(ZigBeeRequest *request,
3150         guint request_type)
3151 {
3152         guint ops_id;
3153
3154         /* Fetch ops ID */
3155         ops_id = __zblib_request_get_ops_id(request_type);
3156         switch (ops_id) {
3157         case ZBLIB_CUSTOM_OPS_APS_SEND: {
3158                 ZigbeeCustomApsSend_t *req = NULL;
3159
3160                 req = (ZigbeeCustomApsSend_t *)request->request_data;
3161                 if (NULL != req) {
3162                         g_free(req);
3163                 }
3164         }
3165         break;
3166
3167         case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
3168                 ZigbeeCustomZclSend_t *req = NULL;
3169
3170                 req = (ZigbeeCustomZclSend_t *)request->request_data;
3171                 if (NULL != req) {
3172                         g_free(req);
3173                 }
3174         }
3175         break;
3176
3177         case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
3178                 ZigbeeCustomSendToLocal_t *req = NULL;
3179
3180                 req = (ZigbeeCustomSendToLocal_t *)request->request_data;
3181                 if (NULL != req) {
3182                         g_free(req);
3183                 }
3184         }
3185         break;
3186
3187         default:
3188         break;
3189         }
3190 }
3191
3192 static void __zblib_request_free_zcl_door_lock_request_data(ZigBeeRequest *request,
3193         guint request_type)
3194 {
3195         guint ops_id;
3196
3197         /* Fetch ops ID */
3198         ops_id = __zblib_request_get_ops_id(request_type);
3199         switch (ops_id) {
3200         case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
3201                 ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
3202
3203                 req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request->request_data;
3204                 if (NULL != req) {
3205                         g_free(req);
3206                 }
3207         }
3208         break;
3209
3210         case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
3211                 ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
3212
3213                 req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request->request_data;
3214                 if (NULL != req) {
3215                         g_free(req);
3216                 }
3217         }
3218         break;
3219
3220         case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
3221                 ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
3222
3223                 req = (ZigbeeZclDoorLockSetDoorLock_t *)request->request_data;
3224                 if (NULL != req) {
3225                         g_free(req);
3226                 }
3227         }
3228         break;
3229
3230         case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
3231                 ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
3232
3233                 req = (ZigbeeZclDoorLockGetDoorLock_t *)request->request_data;
3234                 if (NULL != req) {
3235                         g_free(req);
3236                 }
3237         }
3238         break;
3239
3240         default:
3241         break;
3242         }
3243 }
3244
3245 static void __zblib_request_free_zcl_fan_control_request_data(ZigBeeRequest *request,
3246         guint request_type)
3247 {
3248         guint ops_id;
3249
3250         /* Fetch ops ID */
3251         ops_id = __zblib_request_get_ops_id(request_type);
3252         switch (ops_id) {
3253         case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
3254                 ZigbeeZclFanControlSetFanMode_t *req = NULL;
3255
3256                 req = (ZigbeeZclFanControlSetFanMode_t *)request->request_data;
3257                 if (NULL != req) {
3258                         g_free(req);
3259                 }
3260         }
3261         break;
3262
3263         case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
3264                 ZigbeeZclFanControlGetFanMode_t *req = NULL;
3265
3266                 req = (ZigbeeZclFanControlGetFanMode_t *)request->request_data;
3267                 if (NULL != req) {
3268                         g_free(req);
3269                 }
3270         }
3271         break;
3272
3273         case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
3274                 ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
3275
3276                 req = (ZigbeeZclFanControlSetFanModeSequence_t *)request->request_data;
3277                 if (NULL != req) {
3278                         g_free(req);
3279                 }
3280         }
3281         break;
3282
3283         case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
3284                 ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
3285
3286                 req = (ZigbeeZclFanControlGetFanModeSequence_t *)request->request_data;
3287                 if (NULL != req) {
3288                         g_free(req);
3289                 }
3290         }
3291         break;
3292
3293         default:
3294         break;
3295         }
3296 }
3297
3298 static void __zblib_request_free_zcl_level_control_request_data(ZigBeeRequest *request,
3299         guint request_type)
3300 {
3301         guint ops_id;
3302
3303         /* Fetch ops ID */
3304         ops_id = __zblib_request_get_ops_id(request_type);
3305         switch (ops_id) {
3306         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
3307                 ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
3308
3309                 req = (ZigbeeZclLevelControlMoveToLevel_t *)request->request_data;
3310                 if (NULL != req) {
3311                         g_free(req);
3312                 }
3313         }
3314         break;
3315
3316         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
3317                 ZigbeeZclLevelControlMove_t *req = NULL;
3318
3319                 req = (ZigbeeZclLevelControlMove_t *)request->request_data;
3320                 if (NULL != req) {
3321                         g_free(req);
3322                 }
3323         }
3324         break;
3325
3326         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
3327                 ZigbeeZclLevelControlStep_t *req = NULL;
3328
3329                 req = (ZigbeeZclLevelControlStep_t *)request->request_data;
3330                 if (NULL != req) {
3331                         g_free(req);
3332                 }
3333         }
3334         break;
3335
3336         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
3337                 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
3338
3339                 req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request->request_data;
3340                 if (NULL != req) {
3341                         g_free(req);
3342                 }
3343         }
3344         break;
3345
3346         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
3347                 ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
3348
3349                 req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request->request_data;
3350                 if (NULL != req) {
3351                         g_free(req);
3352                 }
3353         }
3354         break;
3355
3356         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
3357                 ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
3358
3359                 req = (ZigbeeZclLevelControlStepWithOnOff_t *)request->request_data;
3360                 if (NULL != req) {
3361                         g_free(req);
3362                 }
3363         }
3364         break;
3365
3366         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
3367                 ZigbeeZclLevelControlStop_t *req = NULL;
3368
3369                 req = (ZigbeeZclLevelControlStop_t *)request->request_data;
3370                 if (NULL != req) {
3371                         g_free(req);
3372                 }
3373         }
3374         break;
3375
3376         default:
3377         break;
3378         }
3379 }
3380
3381 static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *request,
3382         guint request_type)
3383 {
3384         guint ops_id;
3385
3386         /* Fetch ops ID */
3387         ops_id = __zblib_request_get_ops_id(request_type);
3388         switch (ops_id) {
3389         case ZBLIB_MFGLIB_CONTROL_OPS_START: {
3390                 ZigbeeMfglibControlStart_t *req = NULL;
3391
3392                 req = (ZigbeeMfglibControlStart_t *)request->request_data;
3393                 if (NULL != req) {
3394                         g_free(req);
3395                 }
3396         }
3397         break;
3398
3399         case ZBLIB_MFGLIB_CONTROL_OPS_END: {
3400                 ZigbeeMfglibControlEnd_t *req = NULL;
3401
3402                 req = (ZigbeeMfglibControlEnd_t *)request->request_data;
3403                 if (NULL != req) {
3404                         g_free(req);
3405                 }
3406         }
3407         break;
3408
3409         case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
3410                 ZigbeeMfglibControlStartTone_t *req = NULL;
3411
3412                 req = (ZigbeeMfglibControlStartTone_t *)request->request_data;
3413                 if (NULL != req) {
3414                         g_free(req);
3415                 }
3416         }
3417         break;
3418
3419         case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
3420                 ZigbeeMfglibControlStopTone_t *req = NULL;
3421
3422                 req = (ZigbeeMfglibControlStopTone_t *)request->request_data;
3423                 if (NULL != req) {
3424                         g_free(req);
3425                 }
3426         }
3427         break;
3428
3429         case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
3430                 ZigbeeMfglibControlStartStream_t *req = NULL;
3431
3432                 req = (ZigbeeMfglibControlStartStream_t *)request->request_data;
3433                 if (NULL != req) {
3434                         g_free(req);
3435                 }
3436         }
3437         break;
3438
3439         case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
3440                 ZigbeeMfglibControlStopStream_t *req = NULL;
3441
3442                 req = (ZigbeeMfglibControlStopStream_t *)request->request_data;
3443                 if (NULL != req) {
3444                         g_free(req);
3445                 }
3446         }
3447         break;
3448
3449         case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
3450                 ZigbeeMfglibControlSendPacket_t *req = NULL;
3451
3452                 req = (ZigbeeMfglibControlSendPacket_t *)request->request_data;
3453                 if (NULL != req) {
3454                         g_free(req);
3455                 }
3456         }
3457         break;
3458
3459         case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
3460                 ZigbeeMfglibControlSetChannel_t *req = NULL;
3461
3462                 req = (ZigbeeMfglibControlSetChannel_t *)request->request_data;
3463                 if (NULL != req) {
3464                         g_free(req);
3465                 }
3466         }
3467         break;
3468
3469         case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
3470                 ZigbeeMfglibControlGetChannel_t *req = NULL;
3471
3472                 req = (ZigbeeMfglibControlGetChannel_t *)request->request_data;
3473                 if (NULL != req) {
3474                         g_free(req);
3475                 }
3476         }
3477         break;
3478
3479         case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
3480                 ZigbeeMfglibControlSetPower_t *req = NULL;
3481
3482                 req = (ZigbeeMfglibControlSetPower_t *)request->request_data;
3483                 if (NULL != req) {
3484                         g_free(req);
3485                 }
3486         }
3487         break;
3488
3489         case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
3490                 ZigbeeMfglibControlGetPower_t *req = NULL;
3491
3492                 req = (ZigbeeMfglibControlGetPower_t *)request->request_data;
3493                 if (NULL != req) {
3494                         g_free(req);
3495                 }
3496         }
3497         break;
3498
3499         case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
3500                 ZigbeeMfglibControlSetSynOffset_t *req = NULL;
3501
3502                 req = (ZigbeeMfglibControlSetSynOffset_t *)request->request_data;
3503                 if (NULL != req) {
3504                         g_free(req);
3505                 }
3506         }
3507         break;
3508
3509         case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
3510                 ZigbeeMfglibControlGetSynOffset_t *req = NULL;
3511
3512                 req = (ZigbeeMfglibControlGetSynOffset_t *)request->request_data;
3513                 if (NULL != req) {
3514                         g_free(req);
3515                 }
3516         }
3517         break;
3518
3519         case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
3520                 ZigbeeMfglibControlRxStart_t *req = NULL;
3521
3522                 req = (ZigbeeMfglibControlRxStart_t *)request->request_data;
3523                 if (NULL != req) {
3524                         g_free(req);
3525                 }
3526         }
3527         break;
3528
3529         case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
3530                 ZigbeeMfglibControlRxStop_t *req = NULL;
3531
3532                 req = (ZigbeeMfglibControlRxStop_t *)request->request_data;
3533                 if (NULL != req) {
3534                         g_free(req);
3535                 }
3536         }
3537         break;
3538
3539         case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
3540                 ZigbeeMfglibControlRxVerify_t *req = NULL;
3541
3542                 req = (ZigbeeMfglibControlRxVerify_t *)request->request_data;
3543                 if (NULL != req) {
3544                         g_free(req);
3545                 }
3546         }
3547         break;
3548
3549         case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
3550                 ZigbeeMfglibControlGetRssi_t *req = NULL;
3551
3552                 req = (ZigbeeMfglibControlGetRssi_t *)request->request_data;
3553                 if (NULL != req) {
3554                         g_free(req);
3555                 }
3556         }
3557         break;
3558
3559         default:
3560         break;
3561         }
3562 }
3563
3564 static void __zblib_request_free_zcl_on_off_request_data(ZigBeeRequest *request,
3565         guint request_type)
3566 {
3567         guint ops_id;
3568
3569         /* Fetch ops ID */
3570         ops_id = __zblib_request_get_ops_id(request_type);
3571         switch (ops_id) {
3572         case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
3573                 ZigbeeZclOnOffSetOnOff_t *req = NULL;
3574
3575                 req = (ZigbeeZclOnOffSetOnOff_t *)request->request_data;
3576                 if (NULL != req) {
3577                         g_free(req);
3578                 }
3579         }
3580         break;
3581
3582         case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
3583                 ZigbeeZclOnOffGetOnOffState_t *req = NULL;
3584
3585                 req = (ZigbeeZclOnOffGetOnOffState_t *)request->request_data;
3586                 if (NULL != req) {
3587                         g_free(req);
3588                 }
3589         }
3590         break;
3591
3592         default:
3593         break;
3594         }
3595 }
3596
3597 static void __zblib_request_free_service_request_data(ZigBeeRequest *request,
3598         guint request_type)
3599 {
3600         guint ops_id;
3601
3602         /* Fetch ops ID */
3603         ops_id = __zblib_request_get_ops_id(request_type);
3604         switch (ops_id) {
3605         case ZBLIB_SERVICE_OPS_ENABLE: {
3606         }
3607         break;
3608
3609         case ZBLIB_SERVICE_OPS_DISABLE: {
3610         }
3611         break;
3612
3613         case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
3614         }
3615         break;
3616
3617         case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
3618         }
3619         break;
3620
3621         case ZBLIB_SERVICE_OPS_COEX_START: {
3622                 ZigbeeServiceCoexStart_t *req = NULL;
3623
3624                 req = (ZigbeeServiceCoexStart_t *)request->request_data;
3625                 if (NULL != req) {
3626                         g_free(req);
3627                 }
3628         }
3629         break;
3630
3631         case ZBLIB_SERVICE_OPS_COEX_STOP: {
3632         }
3633         break;
3634
3635         case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
3636         }
3637         break;
3638
3639         case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
3640         }
3641         break;
3642
3643         case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
3644                 ZigbeeServicePermitJoin_t *req = NULL;
3645
3646                 req = (ZigbeeServicePermitJoin_t *)request->request_data;
3647                 if (NULL != req) {
3648                         g_free(req);
3649                 }
3650         }
3651         break;
3652
3653         case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
3654                 ZigbeeServiceLeaveRequest_t *req = NULL;
3655
3656                 req = (ZigbeeServiceLeaveRequest_t *)request->request_data;
3657                 if (NULL != req) {
3658                         g_free(req);
3659                 }
3660         }
3661         break;
3662
3663         case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
3664         }
3665         break;
3666
3667         case ZBLIB_SERVICE_OPS_GET_MAC: {
3668         }
3669         break;
3670
3671         case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
3672         }
3673         break;
3674
3675         case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
3676                 ZigbeeServiceGetEndpointList_t *req = NULL;
3677
3678                 req = (ZigbeeServiceGetEndpointList_t *)request->request_data;
3679                 if (NULL != req) {
3680                         g_free(req);
3681                 }
3682         }
3683         break;
3684
3685         case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
3686                 ZigbeeServiceGetClusterList_t *req = NULL;
3687
3688                 req = (ZigbeeServiceGetClusterList_t *)request->request_data;
3689                 if (NULL != req) {
3690                         g_free(req);
3691                 }
3692         }
3693         break;
3694
3695         case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
3696                 ZigbeeServiceGetNodeType_t *req = NULL;
3697
3698                 req = (ZigbeeServiceGetNodeType_t *)request->request_data;
3699                 if (NULL != req) {
3700                         g_free(req);
3701                 }
3702         }
3703         break;
3704
3705         default:
3706         break;
3707         }
3708 }
3709
3710 static void __zblib_request_free_zcl_thermostat_request_data(ZigBeeRequest *request,
3711         guint request_type)
3712 {
3713         guint ops_id;
3714
3715         /* Fetch ops ID */
3716         ops_id = __zblib_request_get_ops_id(request_type);
3717         switch (ops_id) {
3718         case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
3719                 ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
3720
3721                 req = (ZigbeeZclThermostatGetLocalTemp_t *)request->request_data;
3722                 if (NULL != req) {
3723                         g_free(req);
3724                 }
3725         }
3726         break;
3727
3728         case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
3729                 ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
3730
3731                 req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request->request_data;
3732                 if (NULL != req) {
3733                         g_free(req);
3734                 }
3735         }
3736         break;
3737
3738         case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
3739                 ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
3740
3741                 req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request->request_data;
3742                 if (NULL != req) {
3743                         g_free(req);
3744                 }
3745         }
3746         break;
3747
3748         case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
3749                 ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
3750
3751                 req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request->request_data;
3752                 if (NULL != req) {
3753                         g_free(req);
3754                 }
3755         }
3756         break;
3757
3758         case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
3759                 ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
3760
3761                 req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request->request_data;
3762                 if (NULL != req) {
3763                         g_free(req);
3764                 }
3765         }
3766         break;
3767
3768         default:
3769         break;
3770         }
3771 }
3772
3773 static void __zblib_request_free_zcl_basic_request_data(ZigBeeRequest *request,
3774         guint request_type)
3775 {
3776         guint ops_id;
3777
3778         /* Fetch ops ID */
3779         ops_id = __zblib_request_get_ops_id(request_type);
3780         switch (ops_id) {
3781         case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
3782                 ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
3783
3784                 req = (ZigbeeZclBasicResetFactoryDefault_t *)request->request_data;
3785                 if (NULL != req) {
3786                         g_free(req);
3787                 }
3788         }
3789         break;
3790
3791         default:
3792         break;
3793         }
3794 }
3795
3796 static void __zblib_request_free_zcl_global_control_request_data(ZigBeeRequest *request,
3797         guint request_type)
3798 {
3799         guint ops_id;
3800
3801         /* Fetch ops ID */
3802         ops_id = __zblib_request_get_ops_id(request_type);
3803         switch (ops_id) {
3804         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
3805                 ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
3806
3807                 req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request->request_data;
3808                 if (NULL != req) {
3809                         g_free(req->attribute_id);
3810                         g_free(req);
3811                 }
3812         }
3813         break;
3814
3815         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
3816                 ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
3817
3818                 req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request->request_data;
3819                 if (NULL != req) {
3820                         g_free(req->write_records);
3821                         g_free(req);
3822                 }
3823         }
3824         break;
3825
3826         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
3827                 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
3828
3829                 req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request->request_data;
3830                 if (NULL != req) {
3831                         g_free(req->write_records);
3832                         g_free(req);
3833                 }
3834         }
3835         break;
3836
3837         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
3838                 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
3839
3840                 req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request->request_data;
3841                 if (NULL != req) {
3842                         g_free(req->write_records);
3843                         g_free(req);
3844                 }
3845         }
3846         break;
3847
3848         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
3849                 ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
3850
3851                 req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request->request_data;
3852                 if (NULL != req) {
3853                         g_free(req->write_records);
3854                         g_free(req);
3855                 }
3856         }
3857         break;
3858
3859         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
3860                 ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
3861
3862                 req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request->request_data;
3863                 if (NULL != req) {
3864                         g_free(req->read_records);
3865                         g_free(req);
3866                 }
3867         }
3868         break;
3869
3870         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
3871                 ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
3872
3873                 req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request->request_data;
3874                 if (NULL != req) {
3875                         g_free(req->read_records);
3876                         g_free(req);
3877                 }
3878         }
3879         break;
3880
3881         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
3882                 ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
3883
3884                 req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request->request_data;
3885                 if (NULL != req) {
3886                         g_free(req->read_records);
3887                         g_free(req);
3888                 }
3889         }
3890         break;
3891
3892         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
3893                 ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
3894
3895                 req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request->request_data;
3896                 if (NULL != req) {
3897                         g_free(req);
3898                 }
3899         }
3900         break;
3901
3902         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
3903                 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
3904
3905                 req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request->request_data;
3906                 if (NULL != req) {
3907                         g_free(req);
3908                 }
3909         }
3910         break;
3911
3912         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
3913                 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
3914
3915                 req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request->request_data;
3916                 if (NULL != req) {
3917                         g_free(req);
3918                 }
3919         }
3920         break;
3921
3922         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
3923                 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
3924
3925                 req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request->request_data;
3926                 if (NULL != req) {
3927                         g_free(req);
3928                 }
3929         }
3930         break;
3931
3932         default:
3933         break;
3934         }
3935 }
3936
3937 static void __zblib_request_free_zcl_ias_zone_request_data(ZigBeeRequest *request,
3938         guint request_type)
3939 {
3940         guint ops_id;
3941
3942         /* Fetch ops ID */
3943         ops_id = __zblib_request_get_ops_id(request_type);
3944         switch (ops_id) {
3945         case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
3946                 ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
3947
3948                 req = (ZigbeeZclIasZoneEnrollResponse_t *)request->request_data;
3949                 if (NULL != req) {
3950                         g_free(req);
3951                 }
3952         }
3953         break;
3954
3955         default:
3956         break;
3957         }
3958 }
3959
3960 static void __zblib_request_free_zcl_identify_request_data(ZigBeeRequest *request,
3961         guint request_type)
3962 {
3963         guint ops_id;
3964
3965         /* Fetch ops ID */
3966         ops_id = __zblib_request_get_ops_id(request_type);
3967         switch (ops_id) {
3968         case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
3969                 ZigbeeZclIdentifyIdentify_t *req = NULL;
3970
3971                 req = (ZigbeeZclIdentifyIdentify_t *)request->request_data;
3972                 if (NULL != req) {
3973                         g_free(req);
3974                 }
3975         }
3976         break;
3977
3978         case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
3979                 ZigbeeZclIdentifyQuery_t *req = NULL;
3980
3981                 req = (ZigbeeZclIdentifyQuery_t *)request->request_data;
3982                 if (NULL != req) {
3983                         g_free(req);
3984                 }
3985         }
3986         break;
3987
3988         default:
3989         break;
3990         }
3991 }
3992
3993 static void __zblib_request_free_zcl_color_control_request_data(ZigBeeRequest *request,
3994         guint request_type)
3995 {
3996         guint ops_id;
3997
3998         /* Fetch ops ID */
3999         ops_id = __zblib_request_get_ops_id(request_type);
4000         switch (ops_id) {
4001         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
4002                 ZigbeeZclColorControlMoveToHue_t *req = NULL;
4003
4004                 req = (ZigbeeZclColorControlMoveToHue_t *)request->request_data;
4005                 if (NULL != req) {
4006                         g_free(req);
4007                 }
4008         }
4009         break;
4010
4011         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
4012                 ZigbeeZclColorControlMoveHue_t *req = NULL;
4013
4014                 req = (ZigbeeZclColorControlMoveHue_t *)request->request_data;
4015                 if (NULL != req) {
4016                         g_free(req);
4017                 }
4018         }
4019         break;
4020
4021         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
4022                 ZigbeeZclColorControlStepHue_t *req = NULL;
4023
4024                 req = (ZigbeeZclColorControlStepHue_t *)request->request_data;
4025                 if (NULL != req) {
4026                         g_free(req);
4027                 }
4028         }
4029         break;
4030
4031         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
4032                 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
4033
4034                 req = (ZigbeeZclColorControlMoveToSaturation_t *)request->request_data;
4035                 if (NULL != req) {
4036                         g_free(req);
4037                 }
4038         }
4039         break;
4040
4041         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
4042                 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
4043
4044                 req = (ZigbeeZclColorControlMoveSaturation_t *)request->request_data;
4045                 if (NULL != req) {
4046                         g_free(req);
4047                 }
4048         }
4049         break;
4050
4051         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
4052                 ZigbeeZclColorControlStepSaturation_t *req = NULL;
4053
4054                 req = (ZigbeeZclColorControlStepSaturation_t *)request->request_data;
4055                 if (NULL != req) {
4056                         g_free(req);
4057                 }
4058         }
4059         break;
4060
4061         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
4062                 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
4063
4064                 req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request->request_data;
4065                 if (NULL != req) {
4066                         g_free(req);
4067                 }
4068         }
4069         break;
4070
4071         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
4072                 ZigbeeZclColorControlMoveToColor_t *req = NULL;
4073
4074                 req = (ZigbeeZclColorControlMoveToColor_t *)request->request_data;
4075                 if (NULL != req) {
4076                         g_free(req);
4077                 }
4078         }
4079         break;
4080
4081         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
4082                 ZigbeeZclColorControlMoveColor_t *req = NULL;
4083
4084                 req = (ZigbeeZclColorControlMoveColor_t *)request->request_data;
4085                 if (NULL != req) {
4086                         g_free(req);
4087                 }
4088         }
4089         break;
4090
4091         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
4092                 ZigbeeZclColorControlStepColor_t *req = NULL;
4093
4094                 req = (ZigbeeZclColorControlStepColor_t *)request->request_data;
4095                 if (NULL != req) {
4096                         g_free(req);
4097                 }
4098         }
4099         break;
4100
4101         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
4102                 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
4103
4104                 req = (ZigbeeZclColorControlMoveColorTemperature_t *)request->request_data;
4105                 if (NULL != req) {
4106                         g_free(req);
4107                 }
4108         }
4109         break;
4110
4111         default:
4112         break;
4113         }
4114 }
4115
4116 static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request,
4117         guint request_type)
4118 {
4119         guint ops_id;
4120
4121         /* Fetch ops ID */
4122         ops_id = __zblib_request_get_ops_id(request_type);
4123         switch (ops_id) {
4124         case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
4125                 ZigbeeZclGroupAddGroup_t *req = NULL;
4126
4127                 req = (ZigbeeZclGroupAddGroup_t *)request->request_data;
4128                 if (NULL != req) {
4129                         g_free(req);
4130                 }
4131         }
4132         break;
4133
4134         case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
4135                 ZigbeeZclGroupViewGroup_t *req = NULL;
4136
4137                 req = (ZigbeeZclGroupViewGroup_t *)request->request_data;
4138                 if (NULL != req) {
4139                         g_free(req);
4140                 }
4141         }
4142         break;
4143
4144         case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
4145                 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
4146
4147                 req = (ZigbeeZclGroupGetGroupMembership_t *)request->request_data;
4148                 if (NULL != req) {
4149                         g_free(req->group_list);
4150                         g_free(req);
4151                 }
4152         }
4153         break;
4154
4155         case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
4156                 ZigbeeZclGroupRemoveGroup_t *req = NULL;
4157
4158                 req = (ZigbeeZclGroupRemoveGroup_t *)request->request_data;
4159                 if (NULL != req) {
4160                         g_free(req);
4161                 }
4162         }
4163         break;
4164
4165         case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
4166                 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
4167
4168                 req = (ZigbeeZclGroupRemoveAllGroup_t *)request->request_data;
4169                 if (NULL != req) {
4170                         g_free(req);
4171                 }
4172         }
4173         break;
4174
4175         case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
4176                 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
4177
4178                 req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request->request_data;
4179                 if (NULL != req) {
4180                         g_free(req);
4181                 }
4182         }
4183         break;
4184
4185         default:
4186         break;
4187         }
4188 }
4189
4190 static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *request,
4191         guint request_type)
4192 {
4193         guint ops_id;
4194
4195         /* Fetch ops ID */
4196         ops_id = __zblib_request_get_ops_id(request_type);
4197         switch (ops_id) {
4198         case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
4199                 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
4200
4201                 req = (ZigbeeZclPollControlCheckInResponse_t *)request->request_data;
4202                 if (NULL != req) {
4203                         g_free(req);
4204                 }
4205         }
4206         break;
4207
4208         case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
4209                 ZigbeeZclPollControlFastPollStop_t *req = NULL;
4210
4211                 req = (ZigbeeZclPollControlFastPollStop_t *)request->request_data;
4212                 if (NULL != req) {
4213                         g_free(req);
4214                 }
4215         }
4216         break;
4217
4218         case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
4219                 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
4220
4221                 req = (ZigbeeZclPollControlSetLongPollInterval_t *)request->request_data;
4222                 if (NULL != req) {
4223                         g_free(req);
4224                 }
4225         }
4226         break;
4227
4228         case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
4229                 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
4230
4231                 req = (ZigbeeZclPollControlSetShortPollInterval_t *)request->request_data;
4232                 if (NULL != req) {
4233                         g_free(req);
4234                 }
4235         }
4236         break;
4237
4238         default:
4239         break;
4240         }
4241 }
4242
4243 static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request,
4244         guint request_type)
4245 {
4246         guint ops_id;
4247
4248         /* Fetch ops ID */
4249         ops_id = __zblib_request_get_ops_id(request_type);
4250         switch (ops_id) {
4251         case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
4252                 ZigbeeZclSceneAddScene_t *req = NULL;
4253
4254                 req = (ZigbeeZclSceneAddScene_t *)request->request_data;
4255                 if (NULL != req) {
4256                         g_free(req->ext_field_set);
4257                         g_free(req);
4258                 }
4259         }
4260         break;
4261
4262         case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
4263                 ZigbeeZclSceneViewScene_t *req = NULL;
4264
4265                 req = (ZigbeeZclSceneViewScene_t *)request->request_data;
4266                 if (NULL != req) {
4267                         g_free(req);
4268                 }
4269         }
4270         break;
4271
4272         case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
4273                 ZigbeeZclSceneRemoveScene_t *req = NULL;
4274
4275                 req = (ZigbeeZclSceneRemoveScene_t *)request->request_data;
4276                 if (NULL != req) {
4277                         g_free(req);
4278                 }
4279         }
4280         break;
4281
4282         case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
4283                 ZigbeeZclSceneStoreScene_t *req = NULL;
4284
4285                 req = (ZigbeeZclSceneStoreScene_t *)request->request_data;
4286                 if (NULL != req) {
4287                         g_free(req);
4288                 }
4289         }
4290         break;
4291
4292         case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
4293                 ZigbeeZclSceneRecallScene_t *req = NULL;
4294
4295                 req = (ZigbeeZclSceneRecallScene_t *)request->request_data;
4296                 if (NULL != req) {
4297                         g_free(req);
4298                 }
4299         }
4300         break;
4301
4302         case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
4303                 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
4304
4305                 req = (ZigbeeZclSceneRemoveAllScene_t *)request->request_data;
4306                 if (NULL != req) {
4307                         g_free(req);
4308                 }
4309         }
4310         break;
4311
4312         case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
4313                 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
4314
4315                 req = (ZigbeeZclSceneGetSceneMembership_t *)request->request_data;
4316                 if (NULL != req) {
4317                         g_free(req);
4318                 }
4319         }
4320         break;
4321
4322         default:
4323         break;
4324         }
4325 }
4326
4327 static void __zblib_request_free_zdo_dev_control_request_data(ZigBeeRequest *request,
4328         guint request_type)
4329 {
4330         guint ops_id;
4331
4332         /* Fetch ops ID */
4333         ops_id = __zblib_request_get_ops_id(request_type);
4334         switch (ops_id) {
4335         case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
4336                 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
4337
4338                 req = (ZigbeeZdoDevControlNwkAddrReq_t *)request->request_data;
4339                 if (NULL != req) {
4340                         g_free(req);
4341                 }
4342         }
4343         break;
4344
4345         case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
4346                 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
4347
4348                 req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request->request_data;
4349                 if (NULL != req) {
4350                         g_free(req->in_cl);
4351                         g_free(req->out_cl);
4352                         g_free(req);
4353                 }
4354         }
4355         break;
4356
4357         case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
4358                 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
4359
4360                 req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request->request_data;
4361                 if (NULL != req) {
4362                         g_free(req);
4363                 }
4364         }
4365         break;
4366
4367         case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
4368                 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
4369
4370                 req = (ZigbeeZdoDevControlActiveEpReq_t *)request->request_data;
4371                 if (NULL != req) {
4372                         g_free(req);
4373                 }
4374         }
4375         break;
4376
4377         case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
4378                 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
4379
4380                 req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request->request_data;
4381                 if (NULL != req) {
4382                         g_free(req);
4383                 }
4384         }
4385         break;
4386
4387         case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
4388                 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
4389
4390                 req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request->request_data;
4391                 if (NULL != req) {
4392                         g_free(req);
4393                 }
4394         }
4395         break;
4396
4397         case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
4398                 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
4399
4400                 req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request->request_data;
4401                 if (NULL != req) {
4402                         g_free(req);
4403                 }
4404         }
4405         break;
4406
4407         case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
4408                 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
4409
4410                 req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request->request_data;
4411                 if (NULL != req) {
4412                         g_free(req);
4413                 }
4414         }
4415         break;
4416
4417         case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
4418                 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
4419
4420                 req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request->request_data;
4421                 if (NULL != req) {
4422                         g_free(req);
4423                 }
4424         }
4425         break;
4426
4427         case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
4428                 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
4429
4430                 req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request->request_data;
4431                 if (NULL != req) {
4432                         g_free(req);
4433                 }
4434         }
4435         break;
4436
4437         case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
4438                 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
4439
4440                 req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request->request_data;
4441                 if (NULL != req) {
4442                         g_free(req);
4443                 }
4444         }
4445         break;
4446
4447         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
4448                 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
4449
4450                 req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request->request_data;
4451                 if (NULL != req) {
4452                         g_free(req);
4453                 }
4454         }
4455         break;
4456
4457         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
4458                 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
4459
4460                 req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request->request_data;
4461                 if (NULL != req) {
4462                         g_free(req);
4463                 }
4464         }
4465         break;
4466
4467         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
4468                 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
4469
4470                 req = (ZigbeeZdoDevControlMgmtBindReq_t *)request->request_data;
4471                 if (NULL != req) {
4472                         g_free(req);
4473                 }
4474         }
4475         break;
4476
4477         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
4478                 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
4479
4480                 req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request->request_data;
4481                 if (NULL != req) {
4482                         g_free(req);
4483                 }
4484         }
4485         break;
4486
4487         case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
4488                 ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
4489
4490                 req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request->request_data;
4491                 if (NULL != req) {
4492                         g_free(req);
4493                 }
4494         }
4495         break;
4496
4497         case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
4498                 ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
4499
4500                 req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request->request_data;
4501                 if (NULL != req) {
4502                         g_free(req);
4503                 }
4504         }
4505         break;
4506
4507         default:
4508         break;
4509         }
4510 }
4511
4512 static void __zblib_request_free_zdo_bind_request_data(ZigBeeRequest *request,
4513         guint request_type)
4514 {
4515         guint ops_id;
4516
4517         /* Fetch ops ID */
4518         ops_id = __zblib_request_get_ops_id(request_type);
4519         switch (ops_id) {
4520         case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
4521                 ZigbeeZdoBindBindReq_t *req = NULL;
4522
4523                 req = (ZigbeeZdoBindBindReq_t *)request->request_data;
4524                 if (NULL != req) {
4525                         g_free(req);
4526                 }
4527         }
4528         break;
4529
4530         case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
4531                 ZigbeeZdoBindUnbindReq_t *req = NULL;
4532
4533                 req = (ZigbeeZdoBindUnbindReq_t *)request->request_data;
4534                 if (NULL != req) {
4535                         g_free(req);
4536                 }
4537         }
4538         break;
4539
4540         default:
4541         break;
4542         }
4543 }
4544
4545 static void __zblib_request_free_request_data(ZigBeeRequest *request)
4546 {
4547         guint request_type;
4548         ZblibDriverType_e driver_type;
4549
4550         zblib_check_null_ret("request", request);
4551
4552         request_type = request->request_type;
4553
4554         /* Fetch driver type */
4555         driver_type = __zblib_request_get_driver_type(request_type);
4556         switch (driver_type) {
4557         case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
4558                 __zblib_request_free_zcl_alarm_request_data(request, request_type);
4559         }
4560         break;
4561
4562         case ZBLIB_DRIVER_TYPE_CUSTOM: {
4563                 __zblib_request_free_custom_request_data(request, request_type);
4564         }
4565         break;
4566
4567         case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
4568                 __zblib_request_free_zcl_door_lock_request_data(request, request_type);
4569         }
4570         break;
4571
4572         case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
4573                 __zblib_request_free_zcl_fan_control_request_data(request, request_type);
4574         }
4575         break;
4576
4577         case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
4578                 __zblib_request_free_zcl_level_control_request_data(request, request_type);
4579         }
4580         break;
4581
4582         case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
4583                 __zblib_request_free_mfglib_control_request_data(request, request_type);
4584         }
4585         break;
4586
4587         case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
4588                 __zblib_request_free_zcl_on_off_request_data(request, request_type);
4589         }
4590         break;
4591
4592         case ZBLIB_DRIVER_TYPE_SERVICE: {
4593                 __zblib_request_free_service_request_data(request, request_type);
4594         }
4595         break;
4596
4597         case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
4598                 __zblib_request_free_zcl_thermostat_request_data(request, request_type);
4599         }
4600         break;
4601
4602         case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
4603                 __zblib_request_free_zcl_basic_request_data(request, request_type);
4604         }
4605         break;
4606
4607         case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
4608                 __zblib_request_free_zcl_global_control_request_data(request, request_type);
4609         }
4610         break;
4611
4612         case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
4613                 __zblib_request_free_zcl_ias_zone_request_data(request, request_type);
4614         }
4615         break;
4616
4617         case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
4618                 __zblib_request_free_zcl_identify_request_data(request, request_type);
4619         }
4620         break;
4621
4622         case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
4623                 __zblib_request_free_zcl_color_control_request_data(request, request_type);
4624         }
4625         break;
4626
4627         case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
4628                 __zblib_request_free_zcl_group_request_data(request, request_type);
4629         }
4630         break;
4631
4632         case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
4633                 __zblib_request_free_zcl_poll_control_request_data(request, request_type);
4634         }
4635         break;
4636
4637         case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
4638                 __zblib_request_free_zcl_scene_request_data(request, request_type);
4639         }
4640         break;
4641
4642         case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
4643                 __zblib_request_free_zdo_dev_control_request_data(request, request_type);
4644         }
4645         break;
4646
4647         case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
4648                 __zblib_request_free_zdo_bind_request_data(request, request_type);
4649         }
4650         break;
4651
4652         case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
4653         default: {
4654                 Z_LOGE("Unhandled driver type: [%d]", driver_type);
4655         }
4656         break;
4657         }
4658 }
4659
4660 gint zblib_request_new(ZigBeeServiceInterface *service_interface,
4661         guint request_type, gpointer request_data, guint request_data_len)
4662 {
4663         ZigBeeService *service = NULL;
4664         ZigBeeRequest *request = NULL;
4665         GHashTable *request_table = NULL;
4666
4667         zblib_check_null_ret_error("service_interface", service_interface, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4668
4669         service = zblib_service_interface_ref_service(service_interface);
4670         zblib_check_null_ret_error("service", service, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4671
4672         /* Allocate ZigBee request memory */
4673         request = g_malloc0(sizeof(ZigBeeRequest));
4674
4675         /* Update request */
4676         request->service_interface = service_interface;
4677         request->ref_count = 1; /* Initialize reference count to '1' for new request */
4678
4679         /* Update request data for specific request */
4680         request->request_data = __zblib_request_create_request_data(request_type,
4681                 request_data, request_data_len);
4682         request->request_type = request_type;
4683
4684         /* Generate request ID */
4685         request->request_id = zblib_service_generate_request_id(service);
4686         if (ZIGBEE_REQUEST_INVALID_REQUEST_ID == request->request_id) {
4687                 Z_LOGE("zblib_service_genrate_request_id failed!");
4688
4689                 /* Free resources */
4690                 __zblib_request_free_request_data(request);
4691                 g_free(request);
4692
4693                 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4694         }
4695
4696         /* Fetch request table from service */
4697         request_table = zblib_service_ref_request_hash_table(service);
4698         if (NULL == request_table) {
4699                 Z_LOGE("zblib_service_ref_request_hash_table failed!");
4700
4701                 /* Free resources */
4702                 __zblib_request_free_request_data(request);
4703                 g_free(request);
4704
4705                 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4706         }
4707
4708         /* Insert request to request table */
4709         g_hash_table_insert(request_table, (gpointer)(request->request_id), request);
4710
4711         return request->request_id;
4712 }
4713
4714 void zblib_request_free(ZigBeeServiceInterface *service_interface,
4715         guint request_id)
4716 {
4717         ZigBeeService *service = NULL;
4718         ZigBeeRequest *request = NULL;
4719
4720         zblib_check_null_ret("service_interface", service_interface);
4721
4722         /* Fetch service */
4723         service = zblib_service_interface_ref_service(service_interface);
4724         zblib_check_null_ret("service", service);
4725
4726         /* Fetch request based on request_id */
4727         request = __zblib_request_ref_request_by_request_id(service, request_id);
4728         zblib_check_null_ret("request", request);
4729
4730         /* Free resources */
4731         __zblib_request_free_request_data(request);
4732         g_free(request);
4733 }
4734
4735 gboolean zblib_request_set_response_cb(ZigBeeServiceInterface *service_interface,
4736         guint request_id,
4737         gpointer resp_cb, gpointer resp_cb_data)
4738 {
4739         ZigBeeService *service = NULL;
4740         ZigBeeRequest *request = NULL;
4741
4742         zblib_check_null_ret_error("service_interface", service_interface, FALSE);
4743
4744         /* Fetch service */
4745         service = zblib_service_interface_ref_service(service_interface);
4746         zblib_check_null_ret_error("service", service, FALSE);
4747
4748         /* Fetch request based on request_id */
4749         request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4750         if (NULL == request) {
4751                 Z_LOGE("No request available for request_id: [%d]", request_id);
4752                 return FALSE;
4753         }
4754
4755         /* Update response callback and response callback data */
4756         request->resp_cb = resp_cb;
4757         request->resp_cb_data = resp_cb_data;
4758
4759         return TRUE;
4760 }
4761
4762 gpointer zblib_request_ref_response_cb(ZigBeeServiceInterface *service_interface,
4763         guint request_id, gpointer *resp_cb_data)
4764 {
4765         ZigBeeService *service = NULL;
4766         ZigBeeRequest *request = NULL;
4767
4768         zblib_check_null_ret_error("service_interface", service_interface, NULL);
4769
4770         /* Fetch service */
4771         service = zblib_service_interface_ref_service(service_interface);
4772         zblib_check_null_ret_error("service", service, NULL);
4773
4774         /* Fetch request based on request_id */
4775         request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4776         if (NULL == request) {
4777                 Z_LOGE("No request available for request_id: [%d]", request_id);
4778                 return NULL;
4779         }
4780
4781         /* Response callback data */
4782         *resp_cb_data = request->resp_cb_data;
4783
4784         /* Return response callback */
4785         return request->resp_cb;
4786 }
4787
4788 ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request)
4789 {
4790         zblib_check_null_ret_error("request", request, NULL);
4791
4792         request->ref_count++;
4793
4794         return request;
4795 }
4796
4797 void zblib_request_unref(ZigBeeRequest *request)
4798 {
4799         zblib_check_null_ret("request", request);
4800
4801         request->ref_count--;
4802         if (0 == request->ref_count) {
4803                 Z_LOGD("Reference count is ZERO!");
4804
4805                 /* Free 'request' */
4806                 __zblib_request_free_request_data(request);
4807                 g_free(request);
4808         }
4809 }
4810
4811 guint zblib_request_ref_request_type(ZigBeeRequest *request)
4812 {
4813         zblib_check_null_ret_error("request", request, 0);
4814
4815         return request->request_type;
4816 }
4817
4818 ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeService *service,
4819         guint request_id)
4820 {
4821         ZigBeeRequest *request = NULL;
4822
4823         zblib_check_null_ret_error("service", service, NULL);
4824
4825         /* Fetch request based on request_id */
4826         request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4827         if (NULL == request) {
4828                 Z_LOGE("No request available for request_id: [%d]", request_id);
4829                 return NULL;
4830         }
4831
4832         return request->service_interface;
4833 }
4834
4835 gpointer zblib_request_ref_request_data(ZigBeeRequest *request)
4836 {
4837         zblib_check_null_ret_error("request", request, NULL);
4838
4839         return request->request_data;
4840 }
4841
4842 gpointer zblib_request_ref_request_data_by_id(ZigBeeService *service,
4843         guint request_id)
4844 {
4845         ZigBeeRequest *request = NULL;
4846
4847         /* Fetch request based on request_id */
4848         request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4849         if (NULL == request) {
4850                 Z_LOGE("No request available for request_id: [%d]", request_id);
4851                 return NULL;
4852         }
4853
4854         return request->request_data;
4855 }
4856
4857 guint zblib_request_generate_request_type(ZblibDriverType_e driver_type,
4858         guint ops_id)
4859 {
4860         guint request_type;
4861
4862         /*
4863          * request_type consists of driver_type and ops_id
4864          *      request_type = driver_type | 0x00 | 0x00 | ops_id
4865          */
4866         request_type = (driver_type << 24) | (ops_id);
4867
4868         return request_type;
4869 }
4870
4871 gint zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
4872         guint request_id)
4873 {
4874         return __zblib_request_ref_request_type_by_request_id(service, request_id);
4875 }
4876
4877 ZblibDriverType_e zblib_request_get_driver_type(guint request_type)
4878 {
4879         return __zblib_request_get_driver_type(request_type);
4880 }
4881
4882 guint zblib_request_get_ops_id(guint request_type)
4883 {
4884         return __zblib_request_get_ops_id(request_type);
4885 }