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

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