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