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