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

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