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                 }
1848
1849                 zclidentify_control_request_data = (gpointer)req;
1850         }
1851         break;
1852
1853         default:
1854         break;
1855         }
1856
1857         return zclidentify_control_request_data;
1858 }
1859
1860 static gpointer __zblib_request_create_zcl_color_control_request_data(guint request_type,
1861         gpointer request_data, guint request_data_len)
1862 {
1863         gpointer zcl_color_request_data = NULL;
1864         guint ops_id;
1865
1866         NOT_USED(request_data_len);
1867
1868         /* Fetch ops ID */
1869         ops_id = __zblib_request_get_ops_id(request_type);
1870         switch (ops_id) {
1871         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
1872                 ZigbeeZclColorControlMoveToHue_t *in_req;
1873                 ZigbeeZclColorControlMoveToHue_t *req = NULL;
1874
1875                 in_req = (ZigbeeZclColorControlMoveToHue_t *)request_data;
1876                 if (NULL != in_req) {
1877                         /* Allocate memory */
1878                         req = (ZigbeeZclColorControlMoveToHue_t *)
1879                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHue_t));
1880
1881                         /* Copy data */
1882                         req->node_id = in_req->node_id;
1883                         req->dest_ep = in_req->dest_ep;
1884                         req->hue = in_req->hue;
1885                         req->direction = in_req->direction;
1886                         req->transition_time = in_req->transition_time;
1887                 }
1888
1889                 zcl_color_request_data = (gpointer)req;
1890         }
1891         break;
1892
1893         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
1894                 ZigbeeZclColorControlMoveHue_t *in_req;
1895                 ZigbeeZclColorControlMoveHue_t *req = NULL;
1896
1897                 in_req = (ZigbeeZclColorControlMoveHue_t *)request_data;
1898                 if (NULL != in_req) {
1899                         /* Allocate memory */
1900                         req = (ZigbeeZclColorControlMoveHue_t *)
1901                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveHue_t));
1902
1903                         /* Copy data */
1904                         req->node_id = in_req->node_id;
1905                         req->dest_ep = in_req->dest_ep;
1906                         req->move_mode = in_req->move_mode;
1907                         req->rate = in_req->rate;
1908                 }
1909
1910                 zcl_color_request_data = (gpointer)req;
1911         }
1912         break;
1913
1914         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
1915                 ZigbeeZclColorControlStepHue_t *in_req;
1916                 ZigbeeZclColorControlStepHue_t *req = NULL;
1917
1918                 in_req = (ZigbeeZclColorControlStepHue_t *)request_data;
1919                 if (NULL != in_req) {
1920                         /* Allocate memory */
1921                         req = (ZigbeeZclColorControlStepHue_t *)
1922                                 g_malloc0(sizeof(ZigbeeZclColorControlStepHue_t));
1923
1924                         /* Copy data */
1925                         req->node_id = in_req->node_id;
1926                         req->dest_ep = in_req->dest_ep;
1927                         req->step_mode = in_req->step_mode;
1928                         req->step_size = in_req->step_size;
1929                         req->transition_time = in_req->transition_time;
1930                 }
1931
1932                 zcl_color_request_data = (gpointer)req;
1933         }
1934         break;
1935
1936         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
1937                 ZigbeeZclColorControlMoveToSaturation_t *in_req;
1938                 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
1939
1940                 in_req = (ZigbeeZclColorControlMoveToSaturation_t *)request_data;
1941                 if (NULL != in_req) {
1942                         /* Allocate memory */
1943                         req = (ZigbeeZclColorControlMoveToSaturation_t *)
1944                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveToSaturation_t));
1945
1946                         /* Copy data */
1947                         req->node_id = in_req->node_id;
1948                         req->dest_ep = in_req->dest_ep;
1949                         req->saturation = in_req->saturation;
1950                         req->transition_time = in_req->transition_time;
1951                 }
1952
1953                 zcl_color_request_data = (gpointer)req;
1954         }
1955         break;
1956
1957         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
1958                 ZigbeeZclColorControlMoveSaturation_t *in_req;
1959                 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
1960
1961                 in_req = (ZigbeeZclColorControlMoveSaturation_t *)request_data;
1962                 if (NULL != in_req) {
1963                         /* Allocate memory */
1964                         req = (ZigbeeZclColorControlMoveSaturation_t *)
1965                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveSaturation_t));
1966
1967                         /* Copy data */
1968                         req->node_id = in_req->node_id;
1969                         req->dest_ep = in_req->dest_ep;
1970                         req->move_mode = in_req->move_mode;
1971                         req->rate = in_req->rate;
1972                 }
1973
1974                 zcl_color_request_data = (gpointer)req;
1975         }
1976         break;
1977
1978         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
1979                 ZigbeeZclColorControlStepSaturation_t *in_req;
1980                 ZigbeeZclColorControlStepSaturation_t *req = NULL;
1981
1982                 in_req = (ZigbeeZclColorControlStepSaturation_t *)request_data;
1983                 if (NULL != in_req) {
1984                         /* Allocate memory */
1985                         req = (ZigbeeZclColorControlStepSaturation_t *)
1986                                 g_malloc0(sizeof(ZigbeeZclColorControlStepSaturation_t));
1987
1988                         /* Copy data */
1989                         req->node_id = in_req->node_id;
1990                         req->dest_ep = in_req->dest_ep;
1991                         req->step_mode = in_req->step_mode;
1992                         req->step_size = in_req->step_size;
1993                         req->transition_time = in_req->transition_time;
1994                 }
1995
1996                 zcl_color_request_data = (gpointer)req;
1997         }
1998         break;
1999
2000         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
2001                 ZigbeeZclColorControlMoveToHueAndSaturation_t *in_req;
2002                 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
2003
2004                 in_req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request_data;
2005                 if (NULL != in_req) {
2006                         /* Allocate memory */
2007                         req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)
2008                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveToHueAndSaturation_t));
2009
2010                         /* Copy data */
2011                         req->node_id = in_req->node_id;
2012                         req->dest_ep = in_req->dest_ep;
2013                         req->hue = in_req->hue;
2014                         req->saturation = in_req->saturation;
2015                         req->transition_time = in_req->transition_time;
2016                 }
2017
2018                 zcl_color_request_data = (gpointer)req;
2019         }
2020         break;
2021
2022         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
2023                 ZigbeeZclColorControlMoveToColor_t *in_req;
2024                 ZigbeeZclColorControlMoveToColor_t *req = NULL;
2025
2026                 in_req = (ZigbeeZclColorControlMoveToColor_t *)request_data;
2027                 if (NULL != in_req) {
2028                         /* Allocate memory */
2029                         req = (ZigbeeZclColorControlMoveToColor_t *)
2030                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveToColor_t));
2031
2032                         /* Copy data */
2033                         req->node_id = in_req->node_id;
2034                         req->dest_ep = in_req->dest_ep;
2035                         req->color_x = in_req->color_x;
2036                         req->color_y = in_req->color_y;
2037                         req->transition_time = in_req->transition_time;
2038                 }
2039
2040                 zcl_color_request_data = (gpointer)req;
2041         }
2042         break;
2043
2044         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
2045                 ZigbeeZclColorControlMoveColor_t *in_req;
2046                 ZigbeeZclColorControlMoveColor_t *req = NULL;
2047
2048                 in_req = (ZigbeeZclColorControlMoveColor_t *)request_data;
2049                 if (NULL != in_req) {
2050                         /* Allocate memory */
2051                         req = (ZigbeeZclColorControlMoveColor_t *)
2052                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveColor_t));
2053
2054                         /* Copy data */
2055                         req->node_id = in_req->node_id;
2056                         req->dest_ep = in_req->dest_ep;
2057                         req->rate_x = in_req->rate_x;
2058                         req->rate_y = in_req->rate_y;
2059                 }
2060
2061                 zcl_color_request_data = (gpointer)req;
2062         }
2063         break;
2064
2065         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
2066                 ZigbeeZclColorControlStepColor_t *in_req;
2067                 ZigbeeZclColorControlStepColor_t *req = NULL;
2068
2069                 in_req = (ZigbeeZclColorControlStepColor_t *)request_data;
2070                 if (NULL != in_req) {
2071                         /* Allocate memory */
2072                         req = (ZigbeeZclColorControlStepColor_t *)
2073                                 g_malloc0(sizeof(ZigbeeZclColorControlStepColor_t));
2074
2075                         /* Copy data */
2076                         req->node_id = in_req->node_id;
2077                         req->dest_ep = in_req->dest_ep;
2078                         req->step_x = in_req->step_x;
2079                         req->step_y = in_req->step_y;
2080                         req->transition_time = in_req->transition_time;
2081                 }
2082
2083                 zcl_color_request_data = (gpointer)req;
2084         }
2085         break;
2086
2087         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
2088                 ZigbeeZclColorControlMoveColorTemperature_t *in_req;
2089                 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
2090
2091                 in_req = (ZigbeeZclColorControlMoveColorTemperature_t *)request_data;
2092                 if (NULL != in_req) {
2093                         /* Allocate memory */
2094                         req = (ZigbeeZclColorControlMoveColorTemperature_t *)
2095                                 g_malloc0(sizeof(ZigbeeZclColorControlMoveColorTemperature_t));
2096
2097                         /* Copy data */
2098                         req->node_id = in_req->node_id;
2099                         req->dest_ep = in_req->dest_ep;
2100                         req->color_temperature = in_req->color_temperature;
2101                         req->transition_time = in_req->transition_time;
2102                 }
2103
2104                 zcl_color_request_data = (gpointer)req;
2105         }
2106         break;
2107
2108         default:
2109         break;
2110         }
2111
2112         return zcl_color_request_data;
2113 }
2114
2115 static gpointer __zblib_request_create_zcl_group_request_data(guint request_type,
2116         gpointer request_data, guint request_data_len)
2117 {
2118         gpointer zcl_group_request_data = NULL;
2119         guint ops_id;
2120
2121         NOT_USED(request_data_len);
2122
2123         /* Fetch ops ID */
2124         ops_id = __zblib_request_get_ops_id(request_type);
2125         switch (ops_id) {
2126         case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
2127                 ZigbeeZclGroupAddGroup_t *in_req;
2128                 ZigbeeZclGroupAddGroup_t *req = NULL;
2129
2130                 in_req = (ZigbeeZclGroupAddGroup_t *)request_data;
2131                 if (NULL != in_req) {
2132                         /* Allocate memory */
2133                         req = (ZigbeeZclGroupAddGroup_t *)
2134                                 g_malloc0(sizeof(ZigbeeZclGroupAddGroup_t));
2135
2136                         /* Copy data */
2137                         req->node_id = in_req->node_id;
2138                         req->dest_ep = in_req->dest_ep;
2139                         req->group_id = in_req->group_id;
2140                         g_strlcpy(req->group_name,
2141                                 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2142                 }
2143
2144                 zcl_group_request_data = (gpointer)req;
2145         }
2146         break;
2147
2148         case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
2149                 ZigbeeZclGroupViewGroup_t *in_req;
2150                 ZigbeeZclGroupViewGroup_t *req = NULL;
2151
2152                 in_req = (ZigbeeZclGroupViewGroup_t *)request_data;
2153                 if (NULL != in_req) {
2154                         /* Allocate memory */
2155                         req = (ZigbeeZclGroupViewGroup_t *)
2156                                 g_malloc0(sizeof(ZigbeeZclGroupViewGroup_t));
2157
2158                         /* Copy data */
2159                         req->node_id = in_req->node_id;
2160                         req->dest_ep = in_req->dest_ep;
2161                         req->group_id = in_req->group_id;
2162                 }
2163
2164                 zcl_group_request_data = (gpointer)req;
2165         }
2166         break;
2167
2168         case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
2169                 ZigbeeZclGroupGetGroupMembership_t *in_req;
2170                 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
2171
2172                 in_req = (ZigbeeZclGroupGetGroupMembership_t *)request_data;
2173                 if (NULL != in_req) {
2174                         /* Allocate memory */
2175                         req = (ZigbeeZclGroupGetGroupMembership_t *)
2176                                 g_malloc0(sizeof(ZigbeeZclGroupGetGroupMembership_t));
2177
2178                         /* Copy data */
2179                         req->node_id = in_req->node_id;
2180                         req->dest_ep = in_req->dest_ep;
2181                         req->group_count = in_req->group_count;
2182                         req->group_list = (gushort *)g_memdup(in_req->group_list,
2183                                 sizeof(gushort) * in_req->group_count);
2184                 }
2185
2186                 zcl_group_request_data = (gpointer)req;
2187         }
2188         break;
2189
2190         case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
2191                 ZigbeeZclGroupRemoveGroup_t *in_req;
2192                 ZigbeeZclGroupRemoveGroup_t *req = NULL;
2193
2194                 in_req = (ZigbeeZclGroupRemoveGroup_t *)request_data;
2195                 if (NULL != in_req) {
2196                         /* Allocate memory */
2197                         req = (ZigbeeZclGroupRemoveGroup_t *)
2198                                 g_malloc0(sizeof(ZigbeeZclGroupRemoveGroup_t));
2199
2200                         /* Copy data */
2201                         req->node_id = in_req->node_id;
2202                         req->dest_ep = in_req->dest_ep;
2203                         req->group_id = in_req->group_id;
2204                 }
2205
2206                 zcl_group_request_data = (gpointer)req;
2207         }
2208         break;
2209
2210         case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
2211                 ZigbeeZclGroupRemoveAllGroup_t *in_req;
2212                 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
2213
2214                 in_req = (ZigbeeZclGroupRemoveAllGroup_t *)request_data;
2215                 if (NULL != in_req) {
2216                         /* Allocate memory */
2217                         req = (ZigbeeZclGroupRemoveAllGroup_t *)
2218                                 g_malloc0(sizeof(ZigbeeZclGroupRemoveAllGroup_t));
2219
2220                         /* Copy data */
2221                         req->node_id = in_req->node_id;
2222                         req->dest_ep = in_req->dest_ep;
2223                 }
2224
2225                 zcl_group_request_data = (gpointer)req;
2226         }
2227         break;
2228
2229         case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
2230                 ZigbeeZclGroupAddGroupIfIdentifying_t *in_req;
2231                 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
2232
2233                 in_req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request_data;
2234                 if (NULL != in_req) {
2235                         /* Allocate memory */
2236                         req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)
2237                                 g_malloc0(sizeof(ZigbeeZclGroupAddGroupIfIdentifying_t));
2238
2239                         /* Copy data */
2240                         req->node_id = in_req->node_id;
2241                         req->dest_ep = in_req->dest_ep;
2242                         req->group_id = in_req->group_id;
2243                         g_strlcpy(req->group_name,
2244                                 in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
2245                 }
2246
2247                 zcl_group_request_data = (gpointer)req;
2248         }
2249         break;
2250
2251         default:
2252         break;
2253         }
2254
2255         return zcl_group_request_data;
2256 }
2257
2258 static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type,
2259         gpointer request_data, guint request_data_len)
2260 {
2261         gpointer zcl_poll_control_request_data = NULL;
2262         guint ops_id;
2263
2264         NOT_USED(request_data_len);
2265
2266         /* Fetch ops ID */
2267         ops_id = __zblib_request_get_ops_id(request_type);
2268         switch (ops_id) {
2269         case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
2270                 ZigbeeZclPollControlCheckInResponse_t *in_req;
2271                 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
2272
2273                 in_req = (ZigbeeZclPollControlCheckInResponse_t *)request_data;
2274                 if (NULL != in_req) {
2275                         /* Allocate memory */
2276                         req = (ZigbeeZclPollControlCheckInResponse_t *)
2277                                 g_malloc0(sizeof(ZigbeeZclPollControlCheckInResponse_t));
2278
2279                         /* Copy data */
2280                         req->node_id = in_req->node_id;
2281                         req->dest_ep = in_req->dest_ep;
2282                         req->start_fast_polling = in_req->start_fast_polling;
2283                         req->fast_poll_timeout = in_req->fast_poll_timeout;
2284                 }
2285
2286                 zcl_poll_control_request_data = (gpointer)req;
2287         }
2288         break;
2289
2290         case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
2291                 ZigbeeZclPollControlFastPollStop_t *in_req;
2292                 ZigbeeZclPollControlFastPollStop_t *req = NULL;
2293
2294                 in_req = (ZigbeeZclPollControlFastPollStop_t *)request_data;
2295                 if (NULL != in_req) {
2296                         /* Allocate memory */
2297                         req = (ZigbeeZclPollControlFastPollStop_t *)
2298                                 g_malloc0(sizeof(ZigbeeZclPollControlFastPollStop_t));
2299
2300                         /* Copy data */
2301                         req->node_id = in_req->node_id;
2302                         req->dest_ep = in_req->dest_ep;
2303                 }
2304
2305                 zcl_poll_control_request_data = (gpointer)req;
2306         }
2307         break;
2308
2309         case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
2310                 ZigbeeZclPollControlSetLongPollInterval_t *in_req;
2311                 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
2312
2313                 in_req = (ZigbeeZclPollControlSetLongPollInterval_t *)request_data;
2314                 if (NULL != in_req) {
2315                         /* Allocate memory */
2316                         req = (ZigbeeZclPollControlSetLongPollInterval_t *)
2317                                 g_malloc0(sizeof(ZigbeeZclPollControlSetLongPollInterval_t));
2318
2319                         /* Copy data */
2320                         req->node_id = in_req->node_id;
2321                         req->dest_ep = in_req->dest_ep;
2322                         req->new_long_poll_interval = in_req->new_long_poll_interval;
2323                 }
2324
2325                 zcl_poll_control_request_data = (gpointer)req;
2326         }
2327         break;
2328
2329         case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
2330                 ZigbeeZclPollControlSetShortPollInterval_t *in_req;
2331                 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
2332
2333                 in_req = (ZigbeeZclPollControlSetShortPollInterval_t *)request_data;
2334                 if (NULL != in_req) {
2335                         /* Allocate memory */
2336                         req = (ZigbeeZclPollControlSetShortPollInterval_t *)
2337                                 g_malloc0(sizeof(ZigbeeZclPollControlSetShortPollInterval_t));
2338
2339                         /* Copy data */
2340                         req->node_id = in_req->node_id;
2341                         req->dest_ep = in_req->dest_ep;
2342                         req->new_short_poll_interval = in_req->new_short_poll_interval;
2343                 }
2344
2345                 zcl_poll_control_request_data = (gpointer)req;
2346         }
2347         break;
2348
2349         default:
2350         break;
2351         }
2352
2353         return zcl_poll_control_request_data;
2354 }
2355
2356 static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type,
2357         gpointer request_data, guint request_data_len)
2358 {
2359         gpointer zcl_scene_request_data = NULL;
2360         guint ops_id;
2361
2362         NOT_USED(request_data_len);
2363
2364         /* Fetch ops ID */
2365         ops_id = __zblib_request_get_ops_id(request_type);
2366         switch (ops_id) {
2367         case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
2368                 ZigbeeZclSceneAddScene_t *in_req;
2369                 ZigbeeZclSceneAddScene_t *req = NULL;
2370
2371                 in_req = (ZigbeeZclSceneAddScene_t *)request_data;
2372                 if (NULL != in_req) {
2373                         /* Allocate memory */
2374                         req = (ZigbeeZclSceneAddScene_t *)
2375                                 g_malloc0(sizeof(ZigbeeZclSceneAddScene_t));
2376
2377                         /* Copy data */
2378                         req->node_id = in_req->node_id;
2379                         req->dest_ep = in_req->dest_ep;
2380                         req->group_id = in_req->group_id;
2381                         req->scene_id = in_req->scene_id;
2382                         req->transition_time = in_req->transition_time;
2383                         g_strlcpy(req->scene_name,
2384                                 in_req->scene_name, ZIGBEE_ZCL_SCENE_NAME_MAX_LEN + 1);
2385                         req->ext_field_set_len = in_req->ext_field_set_len;
2386                         req->ext_field_set = (guchar *)g_memdup(in_req->ext_field_set,
2387                                 in_req->ext_field_set_len);
2388                 }
2389
2390                 zcl_scene_request_data = (gpointer)req;
2391         }
2392         break;
2393
2394         case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
2395                 ZigbeeZclSceneViewScene_t *in_req;
2396                 ZigbeeZclSceneViewScene_t *req = NULL;
2397
2398                 in_req = (ZigbeeZclSceneViewScene_t *)request_data;
2399                 if (NULL != in_req) {
2400                         /* Allocate memory */
2401                         req = (ZigbeeZclSceneViewScene_t *)
2402                                 g_malloc0(sizeof(ZigbeeZclSceneViewScene_t));
2403
2404                         /* Copy data */
2405                         req->node_id = in_req->node_id;
2406                         req->dest_ep = in_req->dest_ep;
2407                         req->group_id = in_req->group_id;
2408                         req->scene_id = in_req->scene_id;
2409                 }
2410
2411                 zcl_scene_request_data = (gpointer)req;
2412         }
2413         break;
2414
2415         case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
2416                 ZigbeeZclSceneRemoveScene_t *in_req;
2417                 ZigbeeZclSceneRemoveScene_t *req = NULL;
2418
2419                 in_req = (ZigbeeZclSceneRemoveScene_t *)request_data;
2420                 if (NULL != in_req) {
2421                         /* Allocate memory */
2422                         req = (ZigbeeZclSceneRemoveScene_t *)
2423                                 g_malloc0(sizeof(ZigbeeZclSceneRemoveScene_t));
2424
2425                         /* Copy data */
2426                         req->node_id = in_req->node_id;
2427                         req->dest_ep = in_req->dest_ep;
2428                         req->group_id = in_req->group_id;
2429                         req->scene_id = in_req->scene_id;
2430                 }
2431
2432                 zcl_scene_request_data = (gpointer)req;
2433         }
2434         break;
2435
2436         case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
2437                 ZigbeeZclSceneStoreScene_t *in_req;
2438                 ZigbeeZclSceneStoreScene_t *req = NULL;
2439
2440                 in_req = (ZigbeeZclSceneStoreScene_t *)request_data;
2441                 if (NULL != in_req) {
2442                         /* Allocate memory */
2443                         req = (ZigbeeZclSceneStoreScene_t *)
2444                                 g_malloc0(sizeof(ZigbeeZclSceneStoreScene_t));
2445
2446                         /* Copy data */
2447                         req->node_id = in_req->node_id;
2448                         req->dest_ep = in_req->dest_ep;
2449                         req->group_id = in_req->group_id;
2450                         req->scene_id = in_req->scene_id;
2451                 }
2452
2453                 zcl_scene_request_data = (gpointer)req;
2454         }
2455         break;
2456
2457         case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
2458                 ZigbeeZclSceneRecallScene_t *in_req;
2459                 ZigbeeZclSceneRecallScene_t *req = NULL;
2460
2461                 in_req = (ZigbeeZclSceneRecallScene_t *)request_data;
2462                 if (NULL != in_req) {
2463                         /* Allocate memory */
2464                         req = (ZigbeeZclSceneRecallScene_t *)
2465                                 g_malloc0(sizeof(ZigbeeZclSceneRecallScene_t));
2466
2467                         /* Copy data */
2468                         req->node_id = in_req->node_id;
2469                         req->dest_ep = in_req->dest_ep;
2470                         req->group_id = in_req->group_id;
2471                         req->scene_id = in_req->scene_id;
2472                 }
2473
2474                 zcl_scene_request_data = (gpointer)req;
2475         }
2476         break;
2477
2478         case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
2479                 ZigbeeZclSceneRemoveAllScene_t *in_req;
2480                 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
2481
2482                 in_req = (ZigbeeZclSceneRemoveAllScene_t *)request_data;
2483                 if (NULL != in_req) {
2484                         /* Allocate memory */
2485                         req = (ZigbeeZclSceneRemoveAllScene_t *)
2486                                 g_malloc0(sizeof(ZigbeeZclSceneRemoveAllScene_t));
2487
2488                         /* Copy data */
2489                         req->node_id = in_req->node_id;
2490                         req->dest_ep = in_req->dest_ep;
2491                         req->group_id = in_req->group_id;
2492                 }
2493
2494                 zcl_scene_request_data = (gpointer)req;
2495         }
2496         break;
2497
2498         case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
2499                 ZigbeeZclSceneGetSceneMembership_t *in_req;
2500                 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
2501
2502                 in_req = (ZigbeeZclSceneGetSceneMembership_t *)request_data;
2503                 if (NULL != in_req) {
2504                         /* Allocate memory */
2505                         req = (ZigbeeZclSceneGetSceneMembership_t *)
2506                                 g_malloc0(sizeof(ZigbeeZclSceneGetSceneMembership_t));
2507
2508                         /* Copy data */
2509                         req->node_id = in_req->node_id;
2510                         req->dest_ep = in_req->dest_ep;
2511                         req->group_id = in_req->group_id;
2512                 }
2513
2514                 zcl_scene_request_data = (gpointer)req;
2515         }
2516         break;
2517
2518         default:
2519         break;
2520         }
2521
2522         return zcl_scene_request_data;
2523 }
2524
2525 static gpointer __zblib_request_create_zdo_dev_control_request_data(guint request_type,
2526         gpointer request_data, guint request_data_len)
2527 {
2528         gpointer zdodev_control_request_data = NULL;
2529         guint ops_id;
2530
2531         NOT_USED(request_data_len);
2532
2533         /* Fetch ops ID */
2534         ops_id = __zblib_request_get_ops_id(request_type);
2535         switch (ops_id) {
2536         case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
2537                 ZigbeeZdoDevControlNwkAddrReq_t *in_req;
2538                 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
2539
2540                 in_req = (ZigbeeZdoDevControlNwkAddrReq_t *)request_data;
2541                 if (NULL != in_req) {
2542                         /* Allocate memory */
2543                         req = (ZigbeeZdoDevControlNwkAddrReq_t *)
2544                                 g_malloc0(sizeof(ZigbeeZdoDevControlNwkAddrReq_t));
2545
2546                         /* Copy data */
2547                         memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
2548                         req->request_type = in_req->request_type;
2549                         req->start_index = in_req->start_index;
2550                 }
2551
2552                 zdodev_control_request_data = (gpointer)req;
2553         }
2554         break;
2555
2556         case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
2557                 ZigbeeZdoDevControlMatchedDescriptorReq_t *in_req;
2558                 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
2559
2560                 in_req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request_data;
2561                 if (NULL != in_req) {
2562                         /* Allocate memory */
2563                         req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)
2564                                 g_malloc0(sizeof(ZigbeeZdoDevControlMatchedDescriptorReq_t));
2565
2566                         /* Copy data */
2567                         req->node_id = in_req->node_id;
2568                         req->profile_id = in_req->profile_id;
2569                         req->num_in_cl = in_req->num_in_cl;
2570                         if (in_req->num_in_cl > 0) {
2571                                 req->in_cl = g_malloc0_n(in_req->num_in_cl, sizeof(unsigned short));
2572                                 memcpy(req->in_cl, in_req->in_cl,
2573                                         in_req->num_in_cl * sizeof(unsigned short));
2574                         }
2575                         req->num_out_cl = in_req->num_out_cl;
2576                         if (in_req->num_out_cl > 0) {
2577                                 req->out_cl = g_malloc0_n(in_req->num_out_cl, sizeof(unsigned short));
2578                                 memcpy(req->out_cl, in_req->out_cl,
2579                                         in_req->num_out_cl * sizeof(unsigned short));
2580                         }
2581                 }
2582
2583                 zdodev_control_request_data = (gpointer)req;
2584         }
2585         break;
2586
2587         case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
2588                 ZigbeeZdoDevControlIeeeAddrReq_t *in_req;
2589                 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
2590
2591                 in_req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request_data;
2592                 if (NULL != in_req) {
2593                         /* Allocate memory */
2594                         req = (ZigbeeZdoDevControlIeeeAddrReq_t *)
2595                                 g_malloc0(sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
2596
2597                         /* Copy data */
2598                         req->node_id = in_req->node_id;
2599                 }
2600
2601                 zdodev_control_request_data = (gpointer)req;
2602         }
2603         break;
2604
2605         case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
2606                 ZigbeeZdoDevControlActiveEpReq_t *in_req;
2607                 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
2608
2609                 in_req = (ZigbeeZdoDevControlActiveEpReq_t *)request_data;
2610                 if (NULL != in_req) {
2611                         /* Allocate memory */
2612                         req = (ZigbeeZdoDevControlActiveEpReq_t *)
2613                                 g_malloc0(sizeof(ZigbeeZdoDevControlActiveEpReq_t));
2614
2615                         /* Copy data */
2616                         req->node_id = in_req->node_id;
2617                 }
2618
2619                 zdodev_control_request_data = (gpointer)req;
2620         }
2621         break;
2622
2623         case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
2624                 ZigbeeZdoDevControlNodeDescriptorReq_t *in_req;
2625                 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
2626
2627                 in_req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request_data;
2628                 if (NULL != in_req) {
2629                         /* Allocate memory */
2630                         req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)
2631                                 g_malloc0(sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
2632
2633                         /* Copy data */
2634                         req->node_id = in_req->node_id;
2635                 }
2636
2637                 zdodev_control_request_data = (gpointer)req;
2638         }
2639         break;
2640
2641         case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
2642                 ZigbeeZdoDevControlPowerDescriptorReq_t *in_req;
2643                 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
2644
2645                 in_req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request_data;
2646                 if (NULL != in_req) {
2647                         /* Allocate memory */
2648                         req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)
2649                                 g_malloc0(sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
2650
2651                         /* Copy data */
2652                         req->node_id = in_req->node_id;
2653                 }
2654
2655                 zdodev_control_request_data = (gpointer)req;
2656         }
2657         break;
2658
2659         case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
2660                 ZigbeeZdoDevControlComplexDescriptorReq_t *in_req;
2661                 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
2662
2663                 in_req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request_data;
2664                 if (NULL != in_req) {
2665                         /* Allocate memory */
2666                         req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)
2667                                 g_malloc0(sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
2668
2669                         /* Copy data */
2670                         req->node_id = in_req->node_id;
2671                 }
2672
2673                 zdodev_control_request_data = (gpointer)req;
2674         }
2675         break;
2676
2677         case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
2678                 ZigbeeZdoDevControlUserDescriptorReq_t *in_req;
2679                 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
2680
2681                 in_req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request_data;
2682                 if (NULL != in_req) {
2683                         /* Allocate memory */
2684                         req = (ZigbeeZdoDevControlUserDescriptorReq_t *)
2685                                 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
2686
2687                         /* Copy data */
2688                         req->node_id = in_req->node_id;
2689                 }
2690
2691                 zdodev_control_request_data = (gpointer)req;
2692         }
2693         break;
2694
2695         case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
2696                 ZigbeeZdoDevControlUserDescriptorSetReq_t *in_req;
2697                 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
2698
2699                 in_req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request_data;
2700                 if (NULL != in_req) {
2701                         /* Allocate memory */
2702                         req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)
2703                                 g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
2704
2705                         /* Copy data */
2706                         req->node_id = in_req->node_id;
2707                         req->user_descriptor_len = in_req->user_descriptor_len;
2708                         memcpy(req->user_descriptor,
2709                                 in_req->user_descriptor, in_req->user_descriptor_len);
2710                 }
2711
2712                 zdodev_control_request_data = (gpointer)req;
2713         }
2714         break;
2715
2716         case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
2717                 ZigbeeZdoDevControlDeviceAnnounce_t *in_req;
2718                 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
2719
2720                 in_req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request_data;
2721                 if (NULL != in_req) {
2722                         /* Allocate memory */
2723                         req = (ZigbeeZdoDevControlDeviceAnnounce_t *)
2724                                 g_malloc0(sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
2725
2726                         /* Copy data */
2727                         req->node_id = in_req->node_id;
2728                         memcpy(req->mac_addr, in_req->mac_addr, ZIGBEE_EUI64_SIZE);
2729                         req->capability = in_req->capability;
2730                 }
2731
2732                 zdodev_control_request_data = (gpointer)req;
2733         }
2734         break;
2735
2736         case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
2737                 ZigbeeZdoDevControlSimpleDescriptorReq_t *in_req;
2738                 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
2739
2740                 in_req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request_data;
2741                 if (NULL != in_req) {
2742                         /* Allocate memory */
2743                         req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)
2744                                 g_malloc0(sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
2745
2746                         /* Copy data */
2747                         req->node_id = in_req->node_id;
2748                         req->endpoint = in_req->endpoint;
2749                 }
2750
2751                 zdodev_control_request_data = (gpointer)req;
2752         }
2753         break;
2754
2755         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
2756                 ZigbeeZdoDevControlMgmtLqiReq_t *in_req;
2757                 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
2758
2759                 in_req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request_data;
2760                 if (NULL != in_req) {
2761                         /* Allocate memory */
2762                         req = (ZigbeeZdoDevControlMgmtLqiReq_t *)
2763                                 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
2764
2765                         /* Copy data */
2766                         req->node_id = in_req->node_id;
2767                         req->start_index = in_req->start_index;
2768                 }
2769
2770                 zdodev_control_request_data = (gpointer)req;
2771         }
2772         break;
2773
2774         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
2775                 ZigbeeZdoDevControlMgmtRtgReq_t *in_req;
2776                 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
2777
2778                 in_req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request_data;
2779                 if (NULL != in_req) {
2780                         /* Allocate memory */
2781                         req = (ZigbeeZdoDevControlMgmtRtgReq_t *)
2782                                 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtRtgReq_t));
2783
2784                         /* Copy data */
2785                         req->node_id = in_req->node_id;
2786                         req->start_index = in_req->start_index;
2787                 }
2788
2789                 zdodev_control_request_data = (gpointer)req;
2790         }
2791         break;
2792
2793         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
2794                 ZigbeeZdoDevControlMgmtBindReq_t *in_req;
2795                 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
2796
2797                 in_req = (ZigbeeZdoDevControlMgmtBindReq_t *)request_data;
2798                 if (NULL != in_req) {
2799                         /* Allocate memory */
2800                         req = (ZigbeeZdoDevControlMgmtBindReq_t *)
2801                                 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtBindReq_t));
2802
2803                         /* Copy data */
2804                         req->node_id = in_req->node_id;
2805                         req->start_index = in_req->start_index;
2806                 }
2807
2808                 zdodev_control_request_data = (gpointer)req;
2809         }
2810         break;
2811
2812         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
2813                 ZigbeeZdoDevControlMgmtPermitJoinReq_t *in_req;
2814                 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
2815
2816                 in_req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request_data;
2817                 if (NULL != in_req) {
2818                         /* Allocate memory */
2819                         req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)
2820                                 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
2821
2822                         /* Copy data */
2823                         req->node_id = in_req->node_id;
2824                         req->duration = in_req->duration;
2825                         req->tc_significance = in_req->tc_significance;
2826                 }
2827
2828                 zdodev_control_request_data = (gpointer)req;
2829         }
2830         break;
2831
2832         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_UPDATE_REQ: {
2833                 ZigbeeZdoDevControlMgmtNwkUpdateReq_t *in_req;
2834                 ZigbeeZdoDevControlMgmtNwkUpdateReq_t *req = NULL;
2835
2836                 in_req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *)request_data;
2837                 if (NULL != in_req) {
2838                         /* Allocate memory */
2839                         req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *)
2840                                 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtNwkUpdateReq_t));
2841
2842                         /* Copy data */
2843                         req->node_id = in_req->node_id;
2844                         req->scan_channel = in_req->scan_channel;
2845                         req->scan_duration = in_req->scan_duration;
2846                         req->scan_count = in_req->scan_count;
2847                         req->network_update_id = in_req->network_update_id;
2848                 }
2849
2850                 zdodev_control_request_data = (gpointer)req;
2851         }
2852         break;
2853
2854         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_DISC_REQ: {
2855                 ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *in_req;
2856                 ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *req = NULL;
2857
2858                 in_req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *)request_data;
2859                 if (NULL != in_req) {
2860                         /* Allocate memory */
2861                         req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *)
2862                                 g_malloc0(sizeof(ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t));
2863
2864                         /* Copy data */
2865                         req->node_id = in_req->node_id;
2866                         req->scan_channel = in_req->scan_channel;
2867                         req->scan_duration = in_req->scan_duration;
2868                         req->scan_count = in_req->scan_count;
2869                         req->start_index = in_req->start_index;
2870                 }
2871
2872                 zdodev_control_request_data = (gpointer)req;
2873         }
2874         break;
2875
2876         default:
2877         break;
2878         }
2879
2880         return zdodev_control_request_data;
2881 }
2882
2883 static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type,
2884         gpointer request_data, guint request_data_len)
2885 {
2886         gpointer zdo_bind_request_data = NULL;
2887         guint ops_id;
2888
2889         NOT_USED(request_data_len);
2890
2891         /* Fetch ops ID */
2892         ops_id = __zblib_request_get_ops_id(request_type);
2893         switch (ops_id) {
2894         case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
2895                 ZigbeeZdoBindBindReq_t *in_req;
2896                 ZigbeeZdoBindBindReq_t *req = NULL;
2897
2898                 in_req = (ZigbeeZdoBindBindReq_t *)request_data;
2899                 if (NULL != in_req) {
2900                         /* Allocate memory */
2901                         req = (ZigbeeZdoBindBindReq_t *)
2902                                 g_malloc0(sizeof(ZigbeeZdoBindBindReq_t));
2903
2904                         /* Copy data */
2905                         req->node_id = in_req->node_id;
2906                         memcpy(req->src_addr, in_req->src_addr, ZIGBEE_EUI64_SIZE);
2907                         req->src_ep = in_req->src_ep;
2908                         req->cluster_id = in_req->cluster_id;
2909                         memcpy(req->dst_addr, in_req->dst_addr, ZIGBEE_EUI64_SIZE);
2910                         req->bind_type = in_req->bind_type;
2911                         req->group_addr = in_req->group_addr;
2912                         req->dst_ep = in_req->dst_ep;
2913                 }
2914
2915                 zdo_bind_request_data = (gpointer)req;
2916         }
2917         break;
2918
2919         case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
2920                 ZigbeeZdoBindUnbindReq_t *in_req;
2921                 ZigbeeZdoBindUnbindReq_t *req = NULL;
2922
2923                 in_req = (ZigbeeZdoBindUnbindReq_t *)request_data;
2924                 if (NULL != in_req) {
2925                         /* Allocate memory */
2926                         req = (ZigbeeZdoBindUnbindReq_t *)
2927                                 g_malloc0(sizeof(ZigbeeZdoBindUnbindReq_t));
2928
2929                         /* Copy data */
2930                         req->node_id = in_req->node_id;
2931                         memcpy(req->src_addr, in_req->src_addr, ZIGBEE_EUI64_SIZE);
2932                         req->src_ep = in_req->src_ep;
2933                         req->cluster_id = in_req->cluster_id;
2934                         memcpy(req->dst_addr, in_req->dst_addr, ZIGBEE_EUI64_SIZE);
2935                         req->bind_type = in_req->bind_type;
2936                         req->group_addr = in_req->group_addr;
2937                         req->dst_ep = in_req->dst_ep;
2938                 }
2939
2940                 zdo_bind_request_data = (gpointer)req;
2941         }
2942         break;
2943
2944         default:
2945         break;
2946         }
2947
2948         return zdo_bind_request_data;
2949 }
2950
2951
2952 static gpointer __zblib_request_create_request_data(guint request_type,
2953         gpointer request_data, guint request_data_len)
2954 {
2955         gpointer _request_data = NULL;
2956         ZblibDriverType_e driver_type;
2957
2958         /* Fetch driver type */
2959         driver_type = __zblib_request_get_driver_type(request_type);
2960         switch (driver_type) {
2961         case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
2962                 _request_data = __zblib_request_create_zcl_alarm_request_data(request_type,
2963                         request_data, request_data_len);
2964         }
2965         break;
2966
2967         case ZBLIB_DRIVER_TYPE_CUSTOM: {
2968                 _request_data = __zblib_request_create_custom_request_data(request_type,
2969                         request_data, request_data_len);
2970         }
2971         break;
2972
2973         case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
2974                 _request_data = __zblib_request_create_zcl_door_lock_request_data(request_type,
2975                         request_data, request_data_len);
2976         }
2977         break;
2978
2979         case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
2980                 _request_data = __zblib_request_create_zcl_fan_control_request_data(request_type,
2981                         request_data, request_data_len);
2982         }
2983         break;
2984
2985         case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
2986                 _request_data = __zblib_request_create_zcl_level_control_request_data(request_type,
2987                         request_data, request_data_len);
2988         }
2989         break;
2990
2991         case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
2992                 _request_data = __zblib_request_create_mfglib_control_request_data(request_type,
2993                         request_data, request_data_len);
2994         }
2995         break;
2996
2997         case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
2998                 _request_data = __zblib_request_create_zcl_on_off_request_data(request_type,
2999                         request_data, request_data_len);
3000         }
3001         break;
3002
3003         case ZBLIB_DRIVER_TYPE_SERVICE: {
3004                 _request_data = __zblib_request_create_service_request_data(request_type,
3005                         request_data, request_data_len);
3006         }
3007         break;
3008
3009         case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
3010                 _request_data = __zblib_request_create_zcl_thermostat_request_data(request_type,
3011                         request_data, request_data_len);
3012         }
3013         break;
3014
3015         case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
3016                 _request_data = __zblib_request_create_zcl_basic_request_data(request_type,
3017                         request_data, request_data_len);
3018         }
3019         break;
3020
3021         case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
3022                 _request_data = __zblib_request_create_zcl_global_control_request_data(request_type,
3023                         request_data, request_data_len);
3024         }
3025         break;
3026
3027         case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
3028                 _request_data = __zblib_request_create_zcl_ias_zone_request_data(request_type,
3029                         request_data, request_data_len);
3030         }
3031         break;
3032
3033         case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
3034                 _request_data = __zblib_request_create_zcl_identify_request_data(request_type,
3035                         request_data, request_data_len);
3036         }
3037         break;
3038
3039         case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
3040                 _request_data = __zblib_request_create_zcl_color_control_request_data(request_type,
3041                         request_data, request_data_len);
3042         }
3043         break;
3044
3045         case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
3046                 _request_data = __zblib_request_create_zcl_group_request_data(request_type,
3047                         request_data, request_data_len);
3048         }
3049         break;
3050
3051         case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
3052                 _request_data = __zblib_request_create_zcl_poll_control_request_data(request_type,
3053                         request_data, request_data_len);
3054         }
3055         break;
3056
3057         case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
3058                 _request_data = __zblib_request_create_zcl_scene_request_data(request_type,
3059                         request_data, request_data_len);
3060         }
3061         break;
3062
3063         case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
3064                 _request_data = __zblib_request_create_zdo_dev_control_request_data(request_type,
3065                         request_data, request_data_len);
3066         }
3067         break;
3068
3069         case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
3070                 _request_data = __zblib_request_create_zdo_bind_request_data(request_type,
3071                         request_data, request_data_len);
3072         }
3073         break;
3074
3075         case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
3076         default: {
3077                 Z_LOGE("Unhandled driver type: [%d]", driver_type);
3078         }
3079         break;
3080         }
3081
3082         return _request_data;
3083 }
3084
3085 static void __zblib_request_free_zcl_alarm_request_data(ZigBeeRequest *request,
3086         guint request_type)
3087 {
3088         guint ops_id;
3089
3090         /* Fetch ops ID */
3091         ops_id = __zblib_request_get_ops_id(request_type);
3092         switch (ops_id) {
3093         case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: {
3094                 ZigbeeZclAlarmGetAlarmCount_t *req = NULL;
3095
3096                 req = (ZigbeeZclAlarmGetAlarmCount_t *)request->request_data;
3097                 if (NULL != req) {
3098                         g_free(req);
3099                 }
3100         }
3101         break;
3102
3103         case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
3104                 ZigbeeZclAlarmResetAlarm_t *req = NULL;
3105
3106                 req = (ZigbeeZclAlarmResetAlarm_t *)request->request_data;
3107                 if (NULL != req) {
3108                         g_free(req);
3109                 }
3110         }
3111         break;
3112
3113         case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
3114                 ZigbeeZclAlarmResetAllAlarm_t *req = NULL;
3115
3116                 req = (ZigbeeZclAlarmResetAllAlarm_t *)request->request_data;
3117                 if (NULL != req) {
3118                         g_free(req);
3119                 }
3120         }
3121         break;
3122
3123         case ZBLIB_ZCL_ALARM_OPS_ALARM: {
3124                 ZigbeeZclAlarmAlarm_t *req = NULL;
3125
3126                 req = (ZigbeeZclAlarmAlarm_t *)request->request_data;
3127                 if (NULL != req) {
3128                         g_free(req);
3129                 }
3130         }
3131         break;
3132
3133         case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
3134                 ZigbeeZclAlarmResetAlarmLogs_t *req = NULL;
3135
3136                 req = (ZigbeeZclAlarmResetAlarmLogs_t *)request->request_data;
3137                 if (NULL != req) {
3138                         g_free(req);
3139                 }
3140         }
3141         break;
3142
3143         case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
3144         }
3145         break;
3146
3147         default:
3148         break;
3149         }
3150 }
3151
3152 static void __zblib_request_free_custom_request_data(ZigBeeRequest *request,
3153         guint request_type)
3154 {
3155         guint ops_id;
3156
3157         /* Fetch ops ID */
3158         ops_id = __zblib_request_get_ops_id(request_type);
3159         switch (ops_id) {
3160         case ZBLIB_CUSTOM_OPS_APS_SEND: {
3161                 ZigbeeCustomApsSend_t *req = NULL;
3162
3163                 req = (ZigbeeCustomApsSend_t *)request->request_data;
3164                 if (NULL != req) {
3165                         g_free(req);
3166                 }
3167         }
3168         break;
3169
3170         case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
3171                 ZigbeeCustomZclSend_t *req = NULL;
3172
3173                 req = (ZigbeeCustomZclSend_t *)request->request_data;
3174                 if (NULL != req) {
3175                         g_free(req);
3176                 }
3177         }
3178         break;
3179
3180         case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
3181                 ZigbeeCustomSendToLocal_t *req = NULL;
3182
3183                 req = (ZigbeeCustomSendToLocal_t *)request->request_data;
3184                 if (NULL != req) {
3185                         g_free(req);
3186                 }
3187         }
3188         break;
3189
3190         default:
3191         break;
3192         }
3193 }
3194
3195 static void __zblib_request_free_zcl_door_lock_request_data(ZigBeeRequest *request,
3196         guint request_type)
3197 {
3198         guint ops_id;
3199
3200         /* Fetch ops ID */
3201         ops_id = __zblib_request_get_ops_id(request_type);
3202         switch (ops_id) {
3203         case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
3204                 ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
3205
3206                 req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request->request_data;
3207                 if (NULL != req) {
3208                         g_free(req);
3209                 }
3210         }
3211         break;
3212
3213         case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
3214                 ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
3215
3216                 req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request->request_data;
3217                 if (NULL != req) {
3218                         g_free(req);
3219                 }
3220         }
3221         break;
3222
3223         case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
3224                 ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
3225
3226                 req = (ZigbeeZclDoorLockSetDoorLock_t *)request->request_data;
3227                 if (NULL != req) {
3228                         g_free(req);
3229                 }
3230         }
3231         break;
3232
3233         case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
3234                 ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
3235
3236                 req = (ZigbeeZclDoorLockGetDoorLock_t *)request->request_data;
3237                 if (NULL != req) {
3238                         g_free(req);
3239                 }
3240         }
3241         break;
3242
3243         default:
3244         break;
3245         }
3246 }
3247
3248 static void __zblib_request_free_zcl_fan_control_request_data(ZigBeeRequest *request,
3249         guint request_type)
3250 {
3251         guint ops_id;
3252
3253         /* Fetch ops ID */
3254         ops_id = __zblib_request_get_ops_id(request_type);
3255         switch (ops_id) {
3256         case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
3257                 ZigbeeZclFanControlSetFanMode_t *req = NULL;
3258
3259                 req = (ZigbeeZclFanControlSetFanMode_t *)request->request_data;
3260                 if (NULL != req) {
3261                         g_free(req);
3262                 }
3263         }
3264         break;
3265
3266         case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
3267                 ZigbeeZclFanControlGetFanMode_t *req = NULL;
3268
3269                 req = (ZigbeeZclFanControlGetFanMode_t *)request->request_data;
3270                 if (NULL != req) {
3271                         g_free(req);
3272                 }
3273         }
3274         break;
3275
3276         case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
3277                 ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
3278
3279                 req = (ZigbeeZclFanControlSetFanModeSequence_t *)request->request_data;
3280                 if (NULL != req) {
3281                         g_free(req);
3282                 }
3283         }
3284         break;
3285
3286         case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
3287                 ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
3288
3289                 req = (ZigbeeZclFanControlGetFanModeSequence_t *)request->request_data;
3290                 if (NULL != req) {
3291                         g_free(req);
3292                 }
3293         }
3294         break;
3295
3296         default:
3297         break;
3298         }
3299 }
3300
3301 static void __zblib_request_free_zcl_level_control_request_data(ZigBeeRequest *request,
3302         guint request_type)
3303 {
3304         guint ops_id;
3305
3306         /* Fetch ops ID */
3307         ops_id = __zblib_request_get_ops_id(request_type);
3308         switch (ops_id) {
3309         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
3310                 ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
3311
3312                 req = (ZigbeeZclLevelControlMoveToLevel_t *)request->request_data;
3313                 if (NULL != req) {
3314                         g_free(req);
3315                 }
3316         }
3317         break;
3318
3319         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
3320                 ZigbeeZclLevelControlMove_t *req = NULL;
3321
3322                 req = (ZigbeeZclLevelControlMove_t *)request->request_data;
3323                 if (NULL != req) {
3324                         g_free(req);
3325                 }
3326         }
3327         break;
3328
3329         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
3330                 ZigbeeZclLevelControlStep_t *req = NULL;
3331
3332                 req = (ZigbeeZclLevelControlStep_t *)request->request_data;
3333                 if (NULL != req) {
3334                         g_free(req);
3335                 }
3336         }
3337         break;
3338
3339         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
3340                 ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
3341
3342                 req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request->request_data;
3343                 if (NULL != req) {
3344                         g_free(req);
3345                 }
3346         }
3347         break;
3348
3349         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
3350                 ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
3351
3352                 req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request->request_data;
3353                 if (NULL != req) {
3354                         g_free(req);
3355                 }
3356         }
3357         break;
3358
3359         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
3360                 ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
3361
3362                 req = (ZigbeeZclLevelControlStepWithOnOff_t *)request->request_data;
3363                 if (NULL != req) {
3364                         g_free(req);
3365                 }
3366         }
3367         break;
3368
3369         case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
3370                 ZigbeeZclLevelControlStop_t *req = NULL;
3371
3372                 req = (ZigbeeZclLevelControlStop_t *)request->request_data;
3373                 if (NULL != req) {
3374                         g_free(req);
3375                 }
3376         }
3377         break;
3378
3379         default:
3380         break;
3381         }
3382 }
3383
3384 static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *request,
3385         guint request_type)
3386 {
3387         guint ops_id;
3388
3389         /* Fetch ops ID */
3390         ops_id = __zblib_request_get_ops_id(request_type);
3391         switch (ops_id) {
3392         case ZBLIB_MFGLIB_CONTROL_OPS_START: {
3393                 ZigbeeMfglibControlStart_t *req = NULL;
3394
3395                 req = (ZigbeeMfglibControlStart_t *)request->request_data;
3396                 if (NULL != req) {
3397                         g_free(req);
3398                 }
3399         }
3400         break;
3401
3402         case ZBLIB_MFGLIB_CONTROL_OPS_END: {
3403                 ZigbeeMfglibControlEnd_t *req = NULL;
3404
3405                 req = (ZigbeeMfglibControlEnd_t *)request->request_data;
3406                 if (NULL != req) {
3407                         g_free(req);
3408                 }
3409         }
3410         break;
3411
3412         case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
3413                 ZigbeeMfglibControlStartTone_t *req = NULL;
3414
3415                 req = (ZigbeeMfglibControlStartTone_t *)request->request_data;
3416                 if (NULL != req) {
3417                         g_free(req);
3418                 }
3419         }
3420         break;
3421
3422         case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
3423                 ZigbeeMfglibControlStopTone_t *req = NULL;
3424
3425                 req = (ZigbeeMfglibControlStopTone_t *)request->request_data;
3426                 if (NULL != req) {
3427                         g_free(req);
3428                 }
3429         }
3430         break;
3431
3432         case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
3433                 ZigbeeMfglibControlStartStream_t *req = NULL;
3434
3435                 req = (ZigbeeMfglibControlStartStream_t *)request->request_data;
3436                 if (NULL != req) {
3437                         g_free(req);
3438                 }
3439         }
3440         break;
3441
3442         case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
3443                 ZigbeeMfglibControlStopStream_t *req = NULL;
3444
3445                 req = (ZigbeeMfglibControlStopStream_t *)request->request_data;
3446                 if (NULL != req) {
3447                         g_free(req);
3448                 }
3449         }
3450         break;
3451
3452         case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
3453                 ZigbeeMfglibControlSendPacket_t *req = NULL;
3454
3455                 req = (ZigbeeMfglibControlSendPacket_t *)request->request_data;
3456                 if (NULL != req) {
3457                         g_free(req);
3458                 }
3459         }
3460         break;
3461
3462         case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
3463                 ZigbeeMfglibControlSetChannel_t *req = NULL;
3464
3465                 req = (ZigbeeMfglibControlSetChannel_t *)request->request_data;
3466                 if (NULL != req) {
3467                         g_free(req);
3468                 }
3469         }
3470         break;
3471
3472         case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
3473                 ZigbeeMfglibControlGetChannel_t *req = NULL;
3474
3475                 req = (ZigbeeMfglibControlGetChannel_t *)request->request_data;
3476                 if (NULL != req) {
3477                         g_free(req);
3478                 }
3479         }
3480         break;
3481
3482         case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
3483                 ZigbeeMfglibControlSetPower_t *req = NULL;
3484
3485                 req = (ZigbeeMfglibControlSetPower_t *)request->request_data;
3486                 if (NULL != req) {
3487                         g_free(req);
3488                 }
3489         }
3490         break;
3491
3492         case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
3493                 ZigbeeMfglibControlGetPower_t *req = NULL;
3494
3495                 req = (ZigbeeMfglibControlGetPower_t *)request->request_data;
3496                 if (NULL != req) {
3497                         g_free(req);
3498                 }
3499         }
3500         break;
3501
3502         case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
3503                 ZigbeeMfglibControlSetSynOffset_t *req = NULL;
3504
3505                 req = (ZigbeeMfglibControlSetSynOffset_t *)request->request_data;
3506                 if (NULL != req) {
3507                         g_free(req);
3508                 }
3509         }
3510         break;
3511
3512         case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
3513                 ZigbeeMfglibControlGetSynOffset_t *req = NULL;
3514
3515                 req = (ZigbeeMfglibControlGetSynOffset_t *)request->request_data;
3516                 if (NULL != req) {
3517                         g_free(req);
3518                 }
3519         }
3520         break;
3521
3522         case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
3523                 ZigbeeMfglibControlRxStart_t *req = NULL;
3524
3525                 req = (ZigbeeMfglibControlRxStart_t *)request->request_data;
3526                 if (NULL != req) {
3527                         g_free(req);
3528                 }
3529         }
3530         break;
3531
3532         case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
3533                 ZigbeeMfglibControlRxStop_t *req = NULL;
3534
3535                 req = (ZigbeeMfglibControlRxStop_t *)request->request_data;
3536                 if (NULL != req) {
3537                         g_free(req);
3538                 }
3539         }
3540         break;
3541
3542         case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
3543                 ZigbeeMfglibControlRxVerify_t *req = NULL;
3544
3545                 req = (ZigbeeMfglibControlRxVerify_t *)request->request_data;
3546                 if (NULL != req) {
3547                         g_free(req);
3548                 }
3549         }
3550         break;
3551
3552         case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
3553                 ZigbeeMfglibControlGetRssi_t *req = NULL;
3554
3555                 req = (ZigbeeMfglibControlGetRssi_t *)request->request_data;
3556                 if (NULL != req) {
3557                         g_free(req);
3558                 }
3559         }
3560         break;
3561
3562         default:
3563         break;
3564         }
3565 }
3566
3567 static void __zblib_request_free_zcl_on_off_request_data(ZigBeeRequest *request,
3568         guint request_type)
3569 {
3570         guint ops_id;
3571
3572         /* Fetch ops ID */
3573         ops_id = __zblib_request_get_ops_id(request_type);
3574         switch (ops_id) {
3575         case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
3576                 ZigbeeZclOnOffSetOnOff_t *req = NULL;
3577
3578                 req = (ZigbeeZclOnOffSetOnOff_t *)request->request_data;
3579                 if (NULL != req) {
3580                         g_free(req);
3581                 }
3582         }
3583         break;
3584
3585         case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
3586                 ZigbeeZclOnOffGetOnOffState_t *req = NULL;
3587
3588                 req = (ZigbeeZclOnOffGetOnOffState_t *)request->request_data;
3589                 if (NULL != req) {
3590                         g_free(req);
3591                 }
3592         }
3593         break;
3594
3595         default:
3596         break;
3597         }
3598 }
3599
3600 static void __zblib_request_free_service_request_data(ZigBeeRequest *request,
3601         guint request_type)
3602 {
3603         guint ops_id;
3604
3605         /* Fetch ops ID */
3606         ops_id = __zblib_request_get_ops_id(request_type);
3607         switch (ops_id) {
3608         case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
3609         }
3610         break;
3611
3612         case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
3613         }
3614         break;
3615
3616         case ZBLIB_SERVICE_OPS_COEX_START: {
3617                 ZigbeeServiceCoexStart_t *req = NULL;
3618
3619                 req = (ZigbeeServiceCoexStart_t *)request->request_data;
3620                 if (NULL != req) {
3621                         g_free(req);
3622                 }
3623         }
3624         break;
3625
3626         case ZBLIB_SERVICE_OPS_COEX_STOP: {
3627         }
3628         break;
3629
3630         case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
3631         }
3632         break;
3633
3634         case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
3635         }
3636         break;
3637
3638         case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
3639                 ZigbeeServicePermitJoin_t *req = NULL;
3640
3641                 req = (ZigbeeServicePermitJoin_t *)request->request_data;
3642                 if (NULL != req) {
3643                         g_free(req);
3644                 }
3645         }
3646         break;
3647
3648         case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
3649                 ZigbeeServiceLeaveRequest_t *req = NULL;
3650
3651                 req = (ZigbeeServiceLeaveRequest_t *)request->request_data;
3652                 if (NULL != req) {
3653                         g_free(req);
3654                 }
3655         }
3656         break;
3657
3658         case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
3659         }
3660         break;
3661
3662         case ZBLIB_SERVICE_OPS_GET_MAC: {
3663         }
3664         break;
3665
3666         case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
3667         }
3668         break;
3669
3670         case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
3671                 ZigbeeServiceGetEndpointList_t *req = NULL;
3672
3673                 req = (ZigbeeServiceGetEndpointList_t *)request->request_data;
3674                 if (NULL != req) {
3675                         g_free(req);
3676                 }
3677         }
3678         break;
3679
3680         case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
3681                 ZigbeeServiceGetClusterList_t *req = NULL;
3682
3683                 req = (ZigbeeServiceGetClusterList_t *)request->request_data;
3684                 if (NULL != req) {
3685                         g_free(req);
3686                 }
3687         }
3688         break;
3689
3690         case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
3691                 ZigbeeServiceGetNodeType_t *req = NULL;
3692
3693                 req = (ZigbeeServiceGetNodeType_t *)request->request_data;
3694                 if (NULL != req) {
3695                         g_free(req);
3696                 }
3697         }
3698         break;
3699
3700         default:
3701         break;
3702         }
3703 }
3704
3705 static void __zblib_request_free_zcl_thermostat_request_data(ZigBeeRequest *request,
3706         guint request_type)
3707 {
3708         guint ops_id;
3709
3710         /* Fetch ops ID */
3711         ops_id = __zblib_request_get_ops_id(request_type);
3712         switch (ops_id) {
3713         case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
3714                 ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
3715
3716                 req = (ZigbeeZclThermostatGetLocalTemp_t *)request->request_data;
3717                 if (NULL != req) {
3718                         g_free(req);
3719                 }
3720         }
3721         break;
3722
3723         case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
3724                 ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
3725
3726                 req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request->request_data;
3727                 if (NULL != req) {
3728                         g_free(req);
3729                 }
3730         }
3731         break;
3732
3733         case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
3734                 ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
3735
3736                 req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request->request_data;
3737                 if (NULL != req) {
3738                         g_free(req);
3739                 }
3740         }
3741         break;
3742
3743         case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
3744                 ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
3745
3746                 req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request->request_data;
3747                 if (NULL != req) {
3748                         g_free(req);
3749                 }
3750         }
3751         break;
3752
3753         case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
3754                 ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
3755
3756                 req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request->request_data;
3757                 if (NULL != req) {
3758                         g_free(req);
3759                 }
3760         }
3761         break;
3762
3763         default:
3764         break;
3765         }
3766 }
3767
3768 static void __zblib_request_free_zcl_basic_request_data(ZigBeeRequest *request,
3769         guint request_type)
3770 {
3771         guint ops_id;
3772
3773         /* Fetch ops ID */
3774         ops_id = __zblib_request_get_ops_id(request_type);
3775         switch (ops_id) {
3776         case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
3777                 ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
3778
3779                 req = (ZigbeeZclBasicResetFactoryDefault_t *)request->request_data;
3780                 if (NULL != req) {
3781                         g_free(req);
3782                 }
3783         }
3784         break;
3785
3786         default:
3787         break;
3788         }
3789 }
3790
3791 static void __zblib_request_free_zcl_global_control_request_data(ZigBeeRequest *request,
3792         guint request_type)
3793 {
3794         guint ops_id;
3795
3796         /* Fetch ops ID */
3797         ops_id = __zblib_request_get_ops_id(request_type);
3798         switch (ops_id) {
3799         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
3800                 ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
3801
3802                 req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request->request_data;
3803                 if (NULL != req) {
3804                         g_free(req->attribute_id);
3805                         g_free(req);
3806                 }
3807         }
3808         break;
3809
3810         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
3811                 ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
3812
3813                 req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request->request_data;
3814                 if (NULL != req) {
3815                         g_free(req->write_records);
3816                         g_free(req);
3817                 }
3818         }
3819         break;
3820
3821         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
3822                 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
3823
3824                 req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request->request_data;
3825                 if (NULL != req) {
3826                         g_free(req->write_records);
3827                         g_free(req);
3828                 }
3829         }
3830         break;
3831
3832         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
3833                 ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
3834
3835                 req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request->request_data;
3836                 if (NULL != req) {
3837                         g_free(req->write_records);
3838                         g_free(req);
3839                 }
3840         }
3841         break;
3842
3843         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
3844                 ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
3845
3846                 req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request->request_data;
3847                 if (NULL != req) {
3848                         g_free(req->write_records);
3849                         g_free(req);
3850                 }
3851         }
3852         break;
3853
3854         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
3855                 ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
3856
3857                 req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request->request_data;
3858                 if (NULL != req) {
3859                         g_free(req->read_records);
3860                         g_free(req);
3861                 }
3862         }
3863         break;
3864
3865         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
3866                 ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
3867
3868                 req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request->request_data;
3869                 if (NULL != req) {
3870                         g_free(req->read_records);
3871                         g_free(req);
3872                 }
3873         }
3874         break;
3875
3876         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
3877                 ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
3878
3879                 req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request->request_data;
3880                 if (NULL != req) {
3881                         g_free(req->read_records);
3882                         g_free(req);
3883                 }
3884         }
3885         break;
3886
3887         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
3888                 ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
3889
3890                 req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request->request_data;
3891                 if (NULL != req) {
3892                         g_free(req);
3893                 }
3894         }
3895         break;
3896
3897         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
3898                 ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
3899
3900                 req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request->request_data;
3901                 if (NULL != req) {
3902                         g_free(req);
3903                 }
3904         }
3905         break;
3906
3907         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
3908                 ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
3909
3910                 req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request->request_data;
3911                 if (NULL != req) {
3912                         g_free(req);
3913                 }
3914         }
3915         break;
3916
3917         case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
3918                 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
3919
3920                 req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request->request_data;
3921                 if (NULL != req) {
3922                         g_free(req);
3923                 }
3924         }
3925         break;
3926
3927         default:
3928         break;
3929         }
3930 }
3931
3932 static void __zblib_request_free_zcl_ias_zone_request_data(ZigBeeRequest *request,
3933         guint request_type)
3934 {
3935         guint ops_id;
3936
3937         /* Fetch ops ID */
3938         ops_id = __zblib_request_get_ops_id(request_type);
3939         switch (ops_id) {
3940         case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
3941                 ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
3942
3943                 req = (ZigbeeZclIasZoneEnrollResponse_t *)request->request_data;
3944                 if (NULL != req) {
3945                         g_free(req);
3946                 }
3947         }
3948         break;
3949
3950         default:
3951         break;
3952         }
3953 }
3954
3955 static void __zblib_request_free_zcl_identify_request_data(ZigBeeRequest *request,
3956         guint request_type)
3957 {
3958         guint ops_id;
3959
3960         /* Fetch ops ID */
3961         ops_id = __zblib_request_get_ops_id(request_type);
3962         switch (ops_id) {
3963         case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
3964                 ZigbeeZclIdentifyIdentify_t *req = NULL;
3965
3966                 req = (ZigbeeZclIdentifyIdentify_t *)request->request_data;
3967                 if (NULL != req) {
3968                         g_free(req);
3969                 }
3970         }
3971         break;
3972
3973         case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
3974                 ZigbeeZclIdentifyQuery_t *req = NULL;
3975
3976                 req = (ZigbeeZclIdentifyQuery_t *)request->request_data;
3977                 if (NULL != req) {
3978                         g_free(req);
3979                 }
3980         }
3981         break;
3982
3983         default:
3984         break;
3985         }
3986 }
3987
3988 static void __zblib_request_free_zcl_color_control_request_data(ZigBeeRequest *request,
3989         guint request_type)
3990 {
3991         guint ops_id;
3992
3993         /* Fetch ops ID */
3994         ops_id = __zblib_request_get_ops_id(request_type);
3995         switch (ops_id) {
3996         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
3997                 ZigbeeZclColorControlMoveToHue_t *req = NULL;
3998
3999                 req = (ZigbeeZclColorControlMoveToHue_t *)request->request_data;
4000                 if (NULL != req) {
4001                         g_free(req);
4002                 }
4003         }
4004         break;
4005
4006         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
4007                 ZigbeeZclColorControlMoveHue_t *req = NULL;
4008
4009                 req = (ZigbeeZclColorControlMoveHue_t *)request->request_data;
4010                 if (NULL != req) {
4011                         g_free(req);
4012                 }
4013         }
4014         break;
4015
4016         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
4017                 ZigbeeZclColorControlStepHue_t *req = NULL;
4018
4019                 req = (ZigbeeZclColorControlStepHue_t *)request->request_data;
4020                 if (NULL != req) {
4021                         g_free(req);
4022                 }
4023         }
4024         break;
4025
4026         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
4027                 ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
4028
4029                 req = (ZigbeeZclColorControlMoveToSaturation_t *)request->request_data;
4030                 if (NULL != req) {
4031                         g_free(req);
4032                 }
4033         }
4034         break;
4035
4036         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
4037                 ZigbeeZclColorControlMoveSaturation_t *req = NULL;
4038
4039                 req = (ZigbeeZclColorControlMoveSaturation_t *)request->request_data;
4040                 if (NULL != req) {
4041                         g_free(req);
4042                 }
4043         }
4044         break;
4045
4046         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
4047                 ZigbeeZclColorControlStepSaturation_t *req = NULL;
4048
4049                 req = (ZigbeeZclColorControlStepSaturation_t *)request->request_data;
4050                 if (NULL != req) {
4051                         g_free(req);
4052                 }
4053         }
4054         break;
4055
4056         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
4057                 ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
4058
4059                 req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request->request_data;
4060                 if (NULL != req) {
4061                         g_free(req);
4062                 }
4063         }
4064         break;
4065
4066         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
4067                 ZigbeeZclColorControlMoveToColor_t *req = NULL;
4068
4069                 req = (ZigbeeZclColorControlMoveToColor_t *)request->request_data;
4070                 if (NULL != req) {
4071                         g_free(req);
4072                 }
4073         }
4074         break;
4075
4076         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
4077                 ZigbeeZclColorControlMoveColor_t *req = NULL;
4078
4079                 req = (ZigbeeZclColorControlMoveColor_t *)request->request_data;
4080                 if (NULL != req) {
4081                         g_free(req);
4082                 }
4083         }
4084         break;
4085
4086         case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
4087                 ZigbeeZclColorControlStepColor_t *req = NULL;
4088
4089                 req = (ZigbeeZclColorControlStepColor_t *)request->request_data;
4090                 if (NULL != req) {
4091                         g_free(req);
4092                 }
4093         }
4094         break;
4095
4096         case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
4097                 ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
4098
4099                 req = (ZigbeeZclColorControlMoveColorTemperature_t *)request->request_data;
4100                 if (NULL != req) {
4101                         g_free(req);
4102                 }
4103         }
4104         break;
4105
4106         default:
4107         break;
4108         }
4109 }
4110
4111 static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request,
4112         guint request_type)
4113 {
4114         guint ops_id;
4115
4116         /* Fetch ops ID */
4117         ops_id = __zblib_request_get_ops_id(request_type);
4118         switch (ops_id) {
4119         case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
4120                 ZigbeeZclGroupAddGroup_t *req = NULL;
4121
4122                 req = (ZigbeeZclGroupAddGroup_t *)request->request_data;
4123                 if (NULL != req) {
4124                         g_free(req);
4125                 }
4126         }
4127         break;
4128
4129         case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
4130                 ZigbeeZclGroupViewGroup_t *req = NULL;
4131
4132                 req = (ZigbeeZclGroupViewGroup_t *)request->request_data;
4133                 if (NULL != req) {
4134                         g_free(req);
4135                 }
4136         }
4137         break;
4138
4139         case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
4140                 ZigbeeZclGroupGetGroupMembership_t *req = NULL;
4141
4142                 req = (ZigbeeZclGroupGetGroupMembership_t *)request->request_data;
4143                 if (NULL != req) {
4144                         g_free(req->group_list);
4145                         g_free(req);
4146                 }
4147         }
4148         break;
4149
4150         case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
4151                 ZigbeeZclGroupRemoveGroup_t *req = NULL;
4152
4153                 req = (ZigbeeZclGroupRemoveGroup_t *)request->request_data;
4154                 if (NULL != req) {
4155                         g_free(req);
4156                 }
4157         }
4158         break;
4159
4160         case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
4161                 ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
4162
4163                 req = (ZigbeeZclGroupRemoveAllGroup_t *)request->request_data;
4164                 if (NULL != req) {
4165                         g_free(req);
4166                 }
4167         }
4168         break;
4169
4170         case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
4171                 ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
4172
4173                 req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request->request_data;
4174                 if (NULL != req) {
4175                         g_free(req);
4176                 }
4177         }
4178         break;
4179
4180         default:
4181         break;
4182         }
4183 }
4184
4185 static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *request,
4186         guint request_type)
4187 {
4188         guint ops_id;
4189
4190         /* Fetch ops ID */
4191         ops_id = __zblib_request_get_ops_id(request_type);
4192         switch (ops_id) {
4193         case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
4194                 ZigbeeZclPollControlCheckInResponse_t *req = NULL;
4195
4196                 req = (ZigbeeZclPollControlCheckInResponse_t *)request->request_data;
4197                 if (NULL != req) {
4198                         g_free(req);
4199                 }
4200         }
4201         break;
4202
4203         case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
4204                 ZigbeeZclPollControlFastPollStop_t *req = NULL;
4205
4206                 req = (ZigbeeZclPollControlFastPollStop_t *)request->request_data;
4207                 if (NULL != req) {
4208                         g_free(req);
4209                 }
4210         }
4211         break;
4212
4213         case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
4214                 ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
4215
4216                 req = (ZigbeeZclPollControlSetLongPollInterval_t *)request->request_data;
4217                 if (NULL != req) {
4218                         g_free(req);
4219                 }
4220         }
4221         break;
4222
4223         case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
4224                 ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
4225
4226                 req = (ZigbeeZclPollControlSetShortPollInterval_t *)request->request_data;
4227                 if (NULL != req) {
4228                         g_free(req);
4229                 }
4230         }
4231         break;
4232
4233         default:
4234         break;
4235         }
4236 }
4237
4238 static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request,
4239         guint request_type)
4240 {
4241         guint ops_id;
4242
4243         /* Fetch ops ID */
4244         ops_id = __zblib_request_get_ops_id(request_type);
4245         switch (ops_id) {
4246         case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
4247                 ZigbeeZclSceneAddScene_t *req = NULL;
4248
4249                 req = (ZigbeeZclSceneAddScene_t *)request->request_data;
4250                 if (NULL != req) {
4251                         g_free(req->ext_field_set);
4252                         g_free(req);
4253                 }
4254         }
4255         break;
4256
4257         case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
4258                 ZigbeeZclSceneViewScene_t *req = NULL;
4259
4260                 req = (ZigbeeZclSceneViewScene_t *)request->request_data;
4261                 if (NULL != req) {
4262                         g_free(req);
4263                 }
4264         }
4265         break;
4266
4267         case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
4268                 ZigbeeZclSceneRemoveScene_t *req = NULL;
4269
4270                 req = (ZigbeeZclSceneRemoveScene_t *)request->request_data;
4271                 if (NULL != req) {
4272                         g_free(req);
4273                 }
4274         }
4275         break;
4276
4277         case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
4278                 ZigbeeZclSceneStoreScene_t *req = NULL;
4279
4280                 req = (ZigbeeZclSceneStoreScene_t *)request->request_data;
4281                 if (NULL != req) {
4282                         g_free(req);
4283                 }
4284         }
4285         break;
4286
4287         case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
4288                 ZigbeeZclSceneRecallScene_t *req = NULL;
4289
4290                 req = (ZigbeeZclSceneRecallScene_t *)request->request_data;
4291                 if (NULL != req) {
4292                         g_free(req);
4293                 }
4294         }
4295         break;
4296
4297         case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
4298                 ZigbeeZclSceneRemoveAllScene_t *req = NULL;
4299
4300                 req = (ZigbeeZclSceneRemoveAllScene_t *)request->request_data;
4301                 if (NULL != req) {
4302                         g_free(req);
4303                 }
4304         }
4305         break;
4306
4307         case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
4308                 ZigbeeZclSceneGetSceneMembership_t *req = NULL;
4309
4310                 req = (ZigbeeZclSceneGetSceneMembership_t *)request->request_data;
4311                 if (NULL != req) {
4312                         g_free(req);
4313                 }
4314         }
4315         break;
4316
4317         default:
4318         break;
4319         }
4320 }
4321
4322 static void __zblib_request_free_zdo_dev_control_request_data(ZigBeeRequest *request,
4323         guint request_type)
4324 {
4325         guint ops_id;
4326
4327         /* Fetch ops ID */
4328         ops_id = __zblib_request_get_ops_id(request_type);
4329         switch (ops_id) {
4330         case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
4331                 ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
4332
4333                 req = (ZigbeeZdoDevControlNwkAddrReq_t *)request->request_data;
4334                 if (NULL != req) {
4335                         g_free(req);
4336                 }
4337         }
4338         break;
4339
4340         case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
4341                 ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
4342
4343                 req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request->request_data;
4344                 if (NULL != req) {
4345                         g_free(req->in_cl);
4346                         g_free(req->out_cl);
4347                         g_free(req);
4348                 }
4349         }
4350         break;
4351
4352         case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
4353                 ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
4354
4355                 req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request->request_data;
4356                 if (NULL != req) {
4357                         g_free(req);
4358                 }
4359         }
4360         break;
4361
4362         case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
4363                 ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
4364
4365                 req = (ZigbeeZdoDevControlActiveEpReq_t *)request->request_data;
4366                 if (NULL != req) {
4367                         g_free(req);
4368                 }
4369         }
4370         break;
4371
4372         case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
4373                 ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
4374
4375                 req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request->request_data;
4376                 if (NULL != req) {
4377                         g_free(req);
4378                 }
4379         }
4380         break;
4381
4382         case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
4383                 ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
4384
4385                 req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request->request_data;
4386                 if (NULL != req) {
4387                         g_free(req);
4388                 }
4389         }
4390         break;
4391
4392         case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
4393                 ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
4394
4395                 req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request->request_data;
4396                 if (NULL != req) {
4397                         g_free(req);
4398                 }
4399         }
4400         break;
4401
4402         case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
4403                 ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
4404
4405                 req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request->request_data;
4406                 if (NULL != req) {
4407                         g_free(req);
4408                 }
4409         }
4410         break;
4411
4412         case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
4413                 ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
4414
4415                 req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request->request_data;
4416                 if (NULL != req) {
4417                         g_free(req);
4418                 }
4419         }
4420         break;
4421
4422         case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
4423                 ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
4424
4425                 req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request->request_data;
4426                 if (NULL != req) {
4427                         g_free(req);
4428                 }
4429         }
4430         break;
4431
4432         case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
4433                 ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
4434
4435                 req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request->request_data;
4436                 if (NULL != req) {
4437                         g_free(req);
4438                 }
4439         }
4440         break;
4441
4442         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
4443                 ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
4444
4445                 req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request->request_data;
4446                 if (NULL != req) {
4447                         g_free(req);
4448                 }
4449         }
4450         break;
4451
4452         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
4453                 ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
4454
4455                 req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request->request_data;
4456                 if (NULL != req) {
4457                         g_free(req);
4458                 }
4459         }
4460         break;
4461
4462         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
4463                 ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
4464
4465                 req = (ZigbeeZdoDevControlMgmtBindReq_t *)request->request_data;
4466                 if (NULL != req) {
4467                         g_free(req);
4468                 }
4469         }
4470         break;
4471
4472         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
4473                 ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
4474
4475                 req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request->request_data;
4476                 if (NULL != req) {
4477                         g_free(req);
4478                 }
4479         }
4480         break;
4481
4482         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_UPDATE_REQ: {
4483                 ZigbeeZdoDevControlMgmtNwkUpdateReq_t *req = NULL;
4484
4485                 req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *)request->request_data;
4486                 if (NULL != req) {
4487                         g_free(req);
4488                 }
4489         }
4490         break;
4491
4492         case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_DISC_REQ: {
4493                 ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *req = NULL;
4494
4495                 req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *)request->request_data;
4496                 if (NULL != req) {
4497                         g_free(req);
4498                 }
4499         }
4500         break;
4501
4502         default:
4503         break;
4504         }
4505 }
4506
4507 static void __zblib_request_free_zdo_bind_request_data(ZigBeeRequest *request,
4508         guint request_type)
4509 {
4510         guint ops_id;
4511
4512         /* Fetch ops ID */
4513         ops_id = __zblib_request_get_ops_id(request_type);
4514         switch (ops_id) {
4515         case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
4516                 ZigbeeZdoBindBindReq_t *req = NULL;
4517
4518                 req = (ZigbeeZdoBindBindReq_t *)request->request_data;
4519                 if (NULL != req) {
4520                         g_free(req);
4521                 }
4522         }
4523         break;
4524
4525         case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
4526                 ZigbeeZdoBindUnbindReq_t *req = NULL;
4527
4528                 req = (ZigbeeZdoBindUnbindReq_t *)request->request_data;
4529                 if (NULL != req) {
4530                         g_free(req);
4531                 }
4532         }
4533         break;
4534
4535         default:
4536         break;
4537         }
4538 }
4539
4540 static void __zblib_request_free_request_data(ZigBeeRequest *request)
4541 {
4542         guint request_type;
4543         ZblibDriverType_e driver_type;
4544
4545         zblib_check_null_ret("request", request);
4546
4547         request_type = request->request_type;
4548
4549         /* Fetch driver type */
4550         driver_type = __zblib_request_get_driver_type(request_type);
4551         switch (driver_type) {
4552         case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
4553                 __zblib_request_free_zcl_alarm_request_data(request, request_type);
4554         }
4555         break;
4556
4557         case ZBLIB_DRIVER_TYPE_CUSTOM: {
4558                 __zblib_request_free_custom_request_data(request, request_type);
4559         }
4560         break;
4561
4562         case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
4563                 __zblib_request_free_zcl_door_lock_request_data(request, request_type);
4564         }
4565         break;
4566
4567         case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
4568                 __zblib_request_free_zcl_fan_control_request_data(request, request_type);
4569         }
4570         break;
4571
4572         case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
4573                 __zblib_request_free_zcl_level_control_request_data(request, request_type);
4574         }
4575         break;
4576
4577         case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
4578                 __zblib_request_free_mfglib_control_request_data(request, request_type);
4579         }
4580         break;
4581
4582         case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
4583                 __zblib_request_free_zcl_on_off_request_data(request, request_type);
4584         }
4585         break;
4586
4587         case ZBLIB_DRIVER_TYPE_SERVICE: {
4588                 __zblib_request_free_service_request_data(request, request_type);
4589         }
4590         break;
4591
4592         case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
4593                 __zblib_request_free_zcl_thermostat_request_data(request, request_type);
4594         }
4595         break;
4596
4597         case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
4598                 __zblib_request_free_zcl_basic_request_data(request, request_type);
4599         }
4600         break;
4601
4602         case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
4603                 __zblib_request_free_zcl_global_control_request_data(request, request_type);
4604         }
4605         break;
4606
4607         case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
4608                 __zblib_request_free_zcl_ias_zone_request_data(request, request_type);
4609         }
4610         break;
4611
4612         case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
4613                 __zblib_request_free_zcl_identify_request_data(request, request_type);
4614         }
4615         break;
4616
4617         case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
4618                 __zblib_request_free_zcl_color_control_request_data(request, request_type);
4619         }
4620         break;
4621
4622         case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
4623                 __zblib_request_free_zcl_group_request_data(request, request_type);
4624         }
4625         break;
4626
4627         case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
4628                 __zblib_request_free_zcl_poll_control_request_data(request, request_type);
4629         }
4630         break;
4631
4632         case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
4633                 __zblib_request_free_zcl_scene_request_data(request, request_type);
4634         }
4635         break;
4636
4637         case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
4638                 __zblib_request_free_zdo_dev_control_request_data(request, request_type);
4639         }
4640         break;
4641
4642         case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
4643                 __zblib_request_free_zdo_bind_request_data(request, request_type);
4644         }
4645         break;
4646
4647         case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
4648         default: {
4649                 Z_LOGE("Unhandled driver type: [%d]", driver_type);
4650         }
4651         break;
4652         }
4653 }
4654
4655 gint zblib_request_new(ZigBeeServiceInterface *service_interface,
4656         guint request_type, gpointer request_data, guint request_data_len)
4657 {
4658         ZigBeeService *service = NULL;
4659         ZigBeeRequest *request = NULL;
4660         GHashTable *request_table = NULL;
4661
4662         zblib_check_null_ret_error("service_interface", service_interface, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4663
4664         service = zblib_service_interface_ref_service(service_interface);
4665         zblib_check_null_ret_error("service", service, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
4666
4667         /* Allocate ZigBee request memory */
4668         request = g_malloc0(sizeof(ZigBeeRequest));
4669
4670         /* Update request */
4671         request->service_interface = service_interface;
4672         request->ref_count = 1; /* Initialize reference count to '1' for new request */
4673
4674         /* Update request data for specific request */
4675         request->request_data = __zblib_request_create_request_data(request_type,
4676                 request_data, request_data_len);
4677         request->request_type = request_type;
4678
4679         /* Generate request ID */
4680         request->request_id = zblib_service_generate_request_id(service);
4681         if (ZIGBEE_REQUEST_INVALID_REQUEST_ID == request->request_id) {
4682                 Z_LOGE("zblib_service_genrate_request_id failed!");
4683
4684                 /* Free resources */
4685                 __zblib_request_free_request_data(request);
4686                 g_free(request);
4687
4688                 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4689         }
4690
4691         /* Fetch request table from service */
4692         request_table = zblib_service_ref_request_hash_table(service);
4693         if (NULL == request_table) {
4694                 Z_LOGE("zblib_service_ref_request_hash_table failed!");
4695
4696                 /* Free resources */
4697                 __zblib_request_free_request_data(request);
4698                 g_free(request);
4699
4700                 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
4701         }
4702
4703         /* Insert request to request table */
4704         g_hash_table_insert(request_table, (gpointer)(request->request_id), request);
4705
4706         return request->request_id;
4707 }
4708
4709 void zblib_request_free(ZigBeeServiceInterface *service_interface,
4710         guint request_id)
4711 {
4712         ZigBeeService *service = NULL;
4713         ZigBeeRequest *request = NULL;
4714
4715         zblib_check_null_ret("service_interface", service_interface);
4716
4717         /* Fetch service */
4718         service = zblib_service_interface_ref_service(service_interface);
4719         zblib_check_null_ret("service", service);
4720
4721         /* Fetch request based on request_id */
4722         request = __zblib_request_ref_request_by_request_id(service, request_id);
4723         zblib_check_null_ret("request", request);
4724
4725         /* Free resources */
4726         __zblib_request_free_request_data(request);
4727         g_free(request);
4728 }
4729
4730 gboolean zblib_request_set_response_cb(ZigBeeServiceInterface *service_interface,
4731         guint request_id,
4732         gpointer resp_cb, gpointer resp_cb_data)
4733 {
4734         ZigBeeService *service = NULL;
4735         ZigBeeRequest *request = NULL;
4736
4737         zblib_check_null_ret_error("service_interface", service_interface, FALSE);
4738
4739         /* Fetch service */
4740         service = zblib_service_interface_ref_service(service_interface);
4741         zblib_check_null_ret_error("service", service, FALSE);
4742
4743         /* Fetch request based on request_id */
4744         request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4745         if (NULL == request) {
4746                 Z_LOGE("No request available for request_id: [%d]", request_id);
4747                 return FALSE;
4748         }
4749
4750         /* Update response callback and response callback data */
4751         request->resp_cb = resp_cb;
4752         request->resp_cb_data = resp_cb_data;
4753
4754         return TRUE;
4755 }
4756
4757 gpointer zblib_request_ref_response_cb(ZigBeeServiceInterface *service_interface,
4758         guint request_id, gpointer *resp_cb_data)
4759 {
4760         ZigBeeService *service = NULL;
4761         ZigBeeRequest *request = NULL;
4762
4763         zblib_check_null_ret_error("service_interface", service_interface, NULL);
4764
4765         /* Fetch service */
4766         service = zblib_service_interface_ref_service(service_interface);
4767         zblib_check_null_ret_error("service", service, NULL);
4768
4769         /* Fetch request based on request_id */
4770         request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4771         if (NULL == request) {
4772                 Z_LOGE("No request available for request_id: [%d]", request_id);
4773                 return NULL;
4774         }
4775
4776         /* Response callback data */
4777         *resp_cb_data = request->resp_cb_data;
4778
4779         /* Return response callback */
4780         return request->resp_cb;
4781 }
4782
4783 ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request)
4784 {
4785         zblib_check_null_ret_error("request", request, NULL);
4786
4787         request->ref_count++;
4788
4789         return request;
4790 }
4791
4792 void zblib_request_unref(ZigBeeRequest *request)
4793 {
4794         zblib_check_null_ret("request", request);
4795
4796         request->ref_count--;
4797         if (0 == request->ref_count) {
4798                 Z_LOGD("Reference count is ZERO!");
4799
4800                 /* Free 'request' */
4801                 __zblib_request_free_request_data(request);
4802                 g_free(request);
4803         }
4804 }
4805
4806 guint zblib_request_ref_request_type(ZigBeeRequest *request)
4807 {
4808         zblib_check_null_ret_error("request", request, 0);
4809
4810         return request->request_type;
4811 }
4812
4813 ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeService *service,
4814         guint request_id)
4815 {
4816         ZigBeeRequest *request = NULL;
4817
4818         zblib_check_null_ret_error("service", service, NULL);
4819
4820         /* Fetch request based on request_id */
4821         request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4822         if (NULL == request) {
4823                 Z_LOGE("No request available for request_id: [%d]", request_id);
4824                 return NULL;
4825         }
4826
4827         return request->service_interface;
4828 }
4829
4830 gpointer zblib_request_ref_request_data(ZigBeeRequest *request)
4831 {
4832         zblib_check_null_ret_error("request", request, NULL);
4833
4834         return request->request_data;
4835 }
4836
4837 gpointer zblib_request_ref_request_data_by_id(ZigBeeService *service,
4838         guint request_id)
4839 {
4840         ZigBeeRequest *request = NULL;
4841
4842         /* Fetch request based on request_id */
4843         request = __zblib_request_ref_request_by_by_request_id(service, request_id);
4844         if (NULL == request) {
4845                 Z_LOGE("No request available for request_id: [%d]", request_id);
4846                 return NULL;
4847         }
4848
4849         return request->request_data;
4850 }
4851
4852 guint zblib_request_generate_request_type(ZblibDriverType_e driver_type,
4853         guint ops_id)
4854 {
4855         guint request_type;
4856
4857         /*
4858          * request_type consists of driver_type and ops_id
4859          *      request_type = driver_type | 0x00 | 0x00 | ops_id
4860          */
4861         request_type = (driver_type << 24) | (ops_id);
4862
4863         return request_type;
4864 }
4865
4866 gint zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
4867         guint request_id)
4868 {
4869         return __zblib_request_ref_request_type_by_request_id(service, request_id);
4870 }
4871
4872 ZblibDriverType_e zblib_request_get_driver_type(guint request_type)
4873 {
4874         return __zblib_request_get_driver_type(request_type);
4875 }
4876
4877 guint zblib_request_get_ops_id(guint request_type)
4878 {
4879         return __zblib_request_get_ops_id(request_type);
4880 }