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