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