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