From 47b8338a27e23131e7800798eddbc4e43e6b4248 Mon Sep 17 00:00:00 2001 From: Suresh Kumar N Date: Fri, 23 Dec 2016 21:44:54 +0530 Subject: [PATCH] Added deep copy logic for request data - Data copy + data free Change-Id: Ied89725d195461a9d4104f0cc3163f12c486edab Signed-off-by: Suresh Kumar N --- common/include/zigbee_alarm_type.h | 6 +- common/include/zigbee_custom_type.h | 6 +- common/include/zigbee_door_lock_type.h | 12 +- common/include/zigbee_fan_control_type.h | 6 +- common/include/zigbee_level_control_type.h | 2 + common/include/zigbee_mfglib_control_type.h | 12 +- common/include/zigbee_on_off_type.h | 2 + common/include/zigbee_service_type.h | 6 +- common/include/zigbee_thermostat_type.h | 12 +- common/include/zigbee_types.h | 77 + common/include/zigbee_zcl_color_type.h | 6 +- common/include/zigbee_zcl_group_type.h | 6 +- common/include/zigbee_zcl_poll_control_type.h | 2 + common/include/zigbee_zcl_scene_type.h | 6 +- common/include/zigbee_zclbasic_control_type.h | 2 + common/include/zigbee_zclglobal_control_type.h | 2 + common/include/zigbee_zclias_control_type.h | 2 + common/include/zigbee_zclidentify_control_type.h | 11 +- common/include/zigbee_zdo_bind_type.h | 10 +- common/include/zigbee_zdodev_control_type.h | 15 +- zigbee-daemon/CMakeLists.txt | 1 + zigbee-daemon/zigbee-lib/include/zblib.h | 1 + zigbee-daemon/zigbee-lib/include/zblib_common.h | 38 + zigbee-daemon/zigbee-lib/include/zblib_request.h | 3 +- zigbee-daemon/zigbee-lib/src/zblib_common.c | 22 + zigbee-daemon/zigbee-lib/src/zblib_request.c | 3924 ++++++++++++++++++++-- 26 files changed, 3900 insertions(+), 292 deletions(-) create mode 100644 common/include/zigbee_types.h create mode 100644 zigbee-daemon/zigbee-lib/include/zblib_common.h create mode 100644 zigbee-daemon/zigbee-lib/src/zblib_common.c diff --git a/common/include/zigbee_alarm_type.h b/common/include/zigbee_alarm_type.h index 43ca7aa..05a7340 100644 --- a/common/include/zigbee_alarm_type.h +++ b/common/include/zigbee_alarm_type.h @@ -19,11 +19,7 @@ #ifndef __ZIGBEE_ALARM_TYPE_H__ #define __ZIGBEE_ALARM_TYPE_H__ -/** - * @brief Definition for size of EUI64 (an IEEE address) in bytes (8). - * @since_tizen 3.0 - */ -#define ZIGBEE_EUI64_SIZE 8 +#include /** * @brief Definition for alarm structure. diff --git a/common/include/zigbee_custom_type.h b/common/include/zigbee_custom_type.h index 8fe8ab6..5acd45d 100644 --- a/common/include/zigbee_custom_type.h +++ b/common/include/zigbee_custom_type.h @@ -19,11 +19,7 @@ #ifndef __ZIGBEE_CUSTOM_TYPE_H__ #define __ZIGBEE_CUSTOM_TYPE_H__ -/** - * @brief Definition for custom send payload/data length (128). - * @since_tizen 3.0 - */ -#define ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN 128 +#include /** * @brief Definition for APS send structure. diff --git a/common/include/zigbee_door_lock_type.h b/common/include/zigbee_door_lock_type.h index 7913f41..c962b3b 100644 --- a/common/include/zigbee_door_lock_type.h +++ b/common/include/zigbee_door_lock_type.h @@ -19,17 +19,7 @@ #ifndef __ZIGBEE_DOOR_LOCK_TYPE_H__ #define __ZIGBEE_DOOR_LOCK_TYPE_H__ -/** - * @brief Definition for size of EUI64 (an IEEE address) in bytes (8). - * @since_tizen 3.0 - */ -#define ZIGBEE_EUI64_SIZE 8 - -/** - * @brief Definition for maximum length of door lock pin (10). - * @since_tizen 3.0 - */ -#define ZIGBEE_DOOR_LOCK_MAX_PIN_LEN 10 +#include /** * @brief Definition for subscriber lock event structure. diff --git a/common/include/zigbee_fan_control_type.h b/common/include/zigbee_fan_control_type.h index 40e1a74..1f7b510 100644 --- a/common/include/zigbee_fan_control_type.h +++ b/common/include/zigbee_fan_control_type.h @@ -19,11 +19,7 @@ #ifndef __ZIGBEE_FAN_CONTROL_TYPE_H__ #define __ZIGBEE_FAN_CONTROL_TYPE_H__ -/** - * @brief Definition for size of EUI64 (an IEEE address) in bytes (8). - * @since_tizen 3.0 - */ -#define ZIGBEE_EUI64_SIZE 8 +#include /** * @brief Definition for fan control set fan mode structure. diff --git a/common/include/zigbee_level_control_type.h b/common/include/zigbee_level_control_type.h index d62e874..730b62a 100644 --- a/common/include/zigbee_level_control_type.h +++ b/common/include/zigbee_level_control_type.h @@ -19,6 +19,8 @@ #ifndef __ZIGBEE_LEVEL_CONTROL_TYPE_H__ #define __ZIGBEE_LEVEL_CONTROL_TYPE_H__ +#include + /** * @brief Definition for level control move to level structure. * @since_tizen 3.0 diff --git a/common/include/zigbee_mfglib_control_type.h b/common/include/zigbee_mfglib_control_type.h index 82426f2..45f482e 100644 --- a/common/include/zigbee_mfglib_control_type.h +++ b/common/include/zigbee_mfglib_control_type.h @@ -19,17 +19,7 @@ #ifndef __ZIGBEE_MFGLIB_CONTROL_TYPE_H__ #define __ZIGBEE_MFGLIB_CONTROL_TYPE_H__ -/** - * @brief Definition for size of EUI64 (an IEEE address) in bytes (8). - * @since_tizen 3.0 - */ -#define ZIGBEE_EUI64_SIZE 8 - -/** - * @brief Definition for size of mfglib control packet content (1024). - * @since_tizen 3.0 - */ -#define ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN 1024 +#include /** * @brief Definition for mfglib control start structure. diff --git a/common/include/zigbee_on_off_type.h b/common/include/zigbee_on_off_type.h index b459b88..7e75a91 100644 --- a/common/include/zigbee_on_off_type.h +++ b/common/include/zigbee_on_off_type.h @@ -19,6 +19,8 @@ #ifndef __ZIGBEE_ON_OFF_TYPE_H__ #define __ZIGBEE_ON_OFF_TYPE_H__ +#include + /** * @brief Definition for on/off set on/off structure. * @since_tizen 3.0 diff --git a/common/include/zigbee_service_type.h b/common/include/zigbee_service_type.h index a84cbfb..aadc189 100644 --- a/common/include/zigbee_service_type.h +++ b/common/include/zigbee_service_type.h @@ -19,11 +19,7 @@ #ifndef __ZIGBEE_SERVICE_TYPE_H__ #define __ZIGBEE_SERVICE_TYPE_H__ -/** - * @brief Definition for size of EUI64 (an IEEE address) in bytes (8). - * @since_tizen 3.0 - */ -#define ZIGBEE_EUI64_SIZE 8 +#include /** * @brief Definition for service coex start structure. diff --git a/common/include/zigbee_thermostat_type.h b/common/include/zigbee_thermostat_type.h index c9fbf9e..96acba2 100644 --- a/common/include/zigbee_thermostat_type.h +++ b/common/include/zigbee_thermostat_type.h @@ -19,17 +19,7 @@ #ifndef __ZIGBEE_THERMOSTAT_TYPE_H__ #define __ZIGBEE_THERMOSTAT_TYPE_H__ -/** - * @brief Definition for size of EUI64 (an IEEE address) in bytes (8). - * @since_tizen 3.0 - */ -#define ZIGBEE_EUI64_SIZE 8 - -/** - * @brief Definition for maximum size of thermostat payload (128). - * @since_tizen 3.0 - */ -#define ZIGBEE_THERMSTAT_PAYLOAD_MAX_LEN 128 +#include /** * @brief Definition for thermostat get local temperature structure. diff --git a/common/include/zigbee_types.h b/common/include/zigbee_types.h new file mode 100644 index 0000000..4b35d5e --- /dev/null +++ b/common/include/zigbee_types.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Suresh Kumar N (suresh.n@samsung.com) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __ZIGBEE_TYPES_H__ +#define __ZIGBEE_TYPES_H__ + +/** + * @brief Definition for size of EUI64 (an IEEE address) in bytes (8). + * @since_tizen 3.0 + */ +#define ZIGBEE_EUI64_SIZE 8 + +/** + * @brief Definition for custom send payload/data length (128). + * @since_tizen 3.0 + */ +#define ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN 128 + +/** + * @brief Definition for maximum length of door lock pin (10). + * @since_tizen 3.0 + */ +#define ZIGBEE_DOOR_LOCK_MAX_PIN_LEN 10 + +/** + * @brief Definition for size of mfglib control packet content (1024). + * @since_tizen 3.0 + */ +#define ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN 1024 + +/** + * @brief Definition for maximum size of thermostat payload (128). + * @since_tizen 3.0 + */ +#define ZIGBEE_THERMSTAT_PAYLOAD_MAX_LEN 128 + +/** + * @brief Definition for maximum size of Zcl group name (16). + * @since_tizen 3.0 + */ +#define ZIGBEE_ZCL_GROUP_NAME_MAX_LEN 16 + +/** + * @brief Definition for maximum size of Zcl scene name (16). + * @since_tizen 3.0 + */ +#define ZIGBEE_ZCL_SCENE_NAME_MAX_LEN 16 + +/** + * @brief Definition for maximum size of Zdodev control user + * descriptor length in bytes (16). + * @since_tizen 3.0 + */ +#define ZIGBEE_ZDODEV_CONTROL_USER_DECRIPTOR_MAX_LEN 16 + +/** + * @brief Definition for maximum size of Zdo bind address length in bytes (8). + * @since_tizen 3.0 + */ +#define ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN 8 + +#endif /* __ZIGBEE_TYPES_H__ */ diff --git a/common/include/zigbee_zcl_color_type.h b/common/include/zigbee_zcl_color_type.h index 9f4a04a..68ed56f 100644 --- a/common/include/zigbee_zcl_color_type.h +++ b/common/include/zigbee_zcl_color_type.h @@ -19,6 +19,8 @@ #ifndef __ZIGBEE_ZCL_COLOR_TYPE_H__ #define __ZIGBEE_ZCL_COLOR_TYPE_H__ +#include + /** * @brief Definition for Zcl color move to hue structure. * @since_tizen 3.0 @@ -50,7 +52,7 @@ typedef struct { short node_id; /**< Node ID */ char dest_ep; /**< Destination endpoint */ char step_mode; /**< Step mode */ - char step_zize; /**< Step size */ + char step_size; /**< Step size */ short transition_time; /**< Transtion time */ } ZigbeeZclColorStepHue_t; @@ -84,7 +86,7 @@ typedef struct { short node_id; /**< Node ID */ char dest_ep; /**< Destination endpoint */ char step_mode; /**< Step mode */ - char step_zize; /**< Step size */ + char step_size; /**< Step size */ short transition_time; /**< Transtion time */ } ZigbeeZclColorStepSaturation_t; diff --git a/common/include/zigbee_zcl_group_type.h b/common/include/zigbee_zcl_group_type.h index 1b569b1..9264a82 100644 --- a/common/include/zigbee_zcl_group_type.h +++ b/common/include/zigbee_zcl_group_type.h @@ -19,11 +19,7 @@ #ifndef __ZIGBEE_ZCL_GROUP_TYPE_H__ #define __ZIGBEE_ZCL_GROUP_TYPE_H__ -/** - * @brief Definition for maximum size of Zcl group name (16). - * @since_tizen 3.0 - */ -#define ZIGBEE_ZCL_GROUP_NAME_MAX_LEN 16 +#include /** * @brief Definition for Zcl group add group structure. diff --git a/common/include/zigbee_zcl_poll_control_type.h b/common/include/zigbee_zcl_poll_control_type.h index 623b991..012a762 100644 --- a/common/include/zigbee_zcl_poll_control_type.h +++ b/common/include/zigbee_zcl_poll_control_type.h @@ -19,6 +19,8 @@ #ifndef __ZIGBEE_ZCL_POLL_CONTROL_TYPE_H__ #define __ZIGBEE_ZCL_POLL_CONTROL_TYPE_H__ +#include + /** * @brief Definition for Zcl poll control check in response structure. * @since_tizen 3.0 diff --git a/common/include/zigbee_zcl_scene_type.h b/common/include/zigbee_zcl_scene_type.h index 2f1f2d3..d3f80bc 100644 --- a/common/include/zigbee_zcl_scene_type.h +++ b/common/include/zigbee_zcl_scene_type.h @@ -19,11 +19,7 @@ #ifndef __ZIGBEE_ZCL_SCENE_TYPE_H__ #define __ZIGBEE_ZCL_SCENE_TYPE_H__ -/** - * @brief Definition for maximum size of Zcl scene name (16). - * @since_tizen 3.0 - */ -#define ZIGBEE_ZCL_SCENE_NAME_MAX_LEN 16 +#include /** * @brief Definition for Zcl scene add scene structure. diff --git a/common/include/zigbee_zclbasic_control_type.h b/common/include/zigbee_zclbasic_control_type.h index 1dc2cf6..548a2f5 100644 --- a/common/include/zigbee_zclbasic_control_type.h +++ b/common/include/zigbee_zclbasic_control_type.h @@ -19,6 +19,8 @@ #ifndef __ZIGBEE_ZCLBASIC_CONTROL_TYPE_H__ #define __ZIGBEE_ZCLBASIC_CONTROL_TYPE_H__ +#include + /** * @brief Definition for Zclbasic control reset factort default structure. * @since_tizen 3.0 diff --git a/common/include/zigbee_zclglobal_control_type.h b/common/include/zigbee_zclglobal_control_type.h index 1773430..17b01ac 100644 --- a/common/include/zigbee_zclglobal_control_type.h +++ b/common/include/zigbee_zclglobal_control_type.h @@ -19,6 +19,8 @@ #ifndef __ZIGBEE_ZCLGLOBAL_CONTROL_TYPE_H__ #define __ZIGBEE_ZCLGLOBAL_CONTROL_TYPE_H__ +#include + /** * @brief Definition for Zclglobal control read attributes request structure. * @since_tizen 3.0 diff --git a/common/include/zigbee_zclias_control_type.h b/common/include/zigbee_zclias_control_type.h index 24173b4..b976f39 100644 --- a/common/include/zigbee_zclias_control_type.h +++ b/common/include/zigbee_zclias_control_type.h @@ -19,6 +19,8 @@ #ifndef __ZIGBEE_ZCLIAS_CONTROL_TYPE_H__ #define __ZIGBEE_ZCLIAS_CONTROL_TYPE_H__ +#include + /** * @brief Definition for Zclias control enrol response structure. * @since_tizen 3.0 diff --git a/common/include/zigbee_zclidentify_control_type.h b/common/include/zigbee_zclidentify_control_type.h index 7fb5461..e289af2 100644 --- a/common/include/zigbee_zclidentify_control_type.h +++ b/common/include/zigbee_zclidentify_control_type.h @@ -19,6 +19,8 @@ #ifndef __ZIGBEE_ZCLIDENTIFY_CONTROL_TYPE_H__ #define __ZIGBEE_ZCLIDENTIFY_CONTROL_TYPE_H__ +#include + /** * @brief Definition for Zclidentify control identify structure. * @since_tizen 3.0 @@ -27,7 +29,14 @@ typedef struct { short node_id; /**< Node ID */ char dest_ep; /**< Destination endpoint */ short identify_time; /**< Identify time */ - char zone_id; /**< Zone ID */ } ZigbeeZclidentifyControlIdentify_t; +/** + * @brief Definition for Zclidentify control identify structure. + * @since_tizen 3.0 + */ +typedef struct { + short node_id; /**< Node ID */ +} ZigbeeZclidentifyControlQuery_t; + #endif /* __ZIGBEE_ZCLIDENTIFY_CONTROL_TYPE_H__ */ diff --git a/common/include/zigbee_zdo_bind_type.h b/common/include/zigbee_zdo_bind_type.h index daaa194..1cfb9da 100644 --- a/common/include/zigbee_zdo_bind_type.h +++ b/common/include/zigbee_zdo_bind_type.h @@ -19,11 +19,7 @@ #ifndef __ZIGBEE_ZDO_BIND_TYPE_H__ #define __ZIGBEE_ZDO_BIND_TYPE_H__ -/** - * @brief Definition for maximum size of Zdo bind address length in bytes (8). - * @since_tizen 3.0 - */ -#define ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN 8 +#include /** * @brief Definition for Zdo bind bind request structure. @@ -37,7 +33,7 @@ typedef struct { char dst_addr[ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1]; /**< Destination address */ char bind_type; /**< Bind type */ short group_addr; /**< Group address */ - char dest_ep; /**< Destination endpoint */ + char dst_ep; /**< Destination endpoint */ } ZigbeeZdoBindBindReq_t; /** @@ -52,7 +48,7 @@ typedef struct { char dst_addr[ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1]; /**< Destination address */ char bind_type; /**< Bind type */ short group_addr; /**< Group address */ - char dest_ep; /**< Destination endpoint */ + char dst_ep; /**< Destination endpoint */ } ZigbeeZdoBindUnbindReq_t; #endif /* __ZIGBEE_ZDO_BIND_TYPE_H__ */ diff --git a/common/include/zigbee_zdodev_control_type.h b/common/include/zigbee_zdodev_control_type.h index b28fb99..07b5ec1 100644 --- a/common/include/zigbee_zdodev_control_type.h +++ b/common/include/zigbee_zdodev_control_type.h @@ -19,18 +19,7 @@ #ifndef __ZIGBEE_ZDODEV_CONTROL_TYPE_H__ #define __ZIGBEE_ZDODEV_CONTROL_TYPE_H__ -/** - * @brief Definition for size of EUI64 (an IEEE address) in bytes (8). - * @since_tizen 3.0 - */ -#define ZIGBEE_EUI64_SIZE 8 - -/** - * @brief Definition for maximum size of Zdodev control user - * descriptor length in bytes (16). - * @since_tizen 3.0 - */ -#define ZIGBEE_ZDODEV_CONTROL_USER_DECRIPTOR_MAX_LEN 16 +#include /** * @brief Definition for Zdodev control network address request structure. @@ -53,8 +42,6 @@ typedef struct { char *in_cl; /**< In CL */ char num_out_cl; /**< Number of out CL */ char *out_cl; /**< Out CL */ - char request_type; /**< Request type */ - char start_index; /**< Start index */ } ZigbeeZdodevControlMatchedDescriptorReq_t; /** diff --git a/zigbee-daemon/CMakeLists.txt b/zigbee-daemon/CMakeLists.txt index 3c7a69f..5f3f17b 100644 --- a/zigbee-daemon/CMakeLists.txt +++ b/zigbee-daemon/CMakeLists.txt @@ -61,6 +61,7 @@ SET(ZIGBEE_LIB_SRCS ${ZIGBEE_LIB_SRC_PATH}/zblib_driver.c ${ZIGBEE_LIB_SRC_PATH}/zblib_request.c ${ZIGBEE_LIB_SRC_PATH}/zblib_log.c + ${ZIGBEE_LIB_SRC_PATH}/zblib_common.c ${ZIGBEE_LIB_SRC_PATH}/zblib_util.c ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_alarm.c ${ZIGBEE_LIB_SRC_PATH}/drivers/zblib_driver_custom.c diff --git a/zigbee-daemon/zigbee-lib/include/zblib.h b/zigbee-daemon/zigbee-lib/include/zblib.h index e180cc3..1eb60cc 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib.h +++ b/zigbee-daemon/zigbee-lib/include/zblib.h @@ -26,6 +26,7 @@ #include #include +#include #include #include diff --git a/zigbee-daemon/zigbee-lib/include/zblib_common.h b/zigbee-daemon/zigbee-lib/include/zblib_common.h new file mode 100644 index 0000000..2e08098 --- /dev/null +++ b/zigbee-daemon/zigbee-lib/include/zblib_common.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Suresh Kumar N (suresh.n@samsung.com) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __ZIGBEE_LIB_COMMON_H__ +#define __ZIGBEE_LIB_COMMON_H__ + +#include + +#define zblib_check_null_ret_error(name, value, error) do { \ + if (G_UNLIKELY(NULL == (value))) { \ + Z_LOGE("%s is NULL", name); \ + return error; \ + } \ +} while (FALSE) + +#define zblib_check_null_ret(name, value) do { \ + if (G_UNLIKELY(NULL == (value))) { \ + Z_LOGE("%s is NULL", name); \ + return; \ + } \ +} while (FALSE) + +#endif /* __ZIGBEE_LIB_COMMON_H__ */ diff --git a/zigbee-daemon/zigbee-lib/include/zblib_request.h b/zigbee-daemon/zigbee-lib/include/zblib_request.h index 2a800cc..8bf56ca 100644 --- a/zigbee-daemon/zigbee-lib/include/zblib_request.h +++ b/zigbee-daemon/zigbee-lib/include/zblib_request.h @@ -24,7 +24,8 @@ gint zblib_request_new(ZigBeeServiceInterface *service_interface, guint request_type, gpointer request_data, guint request_data_len); -void zblib_request_free(ZigBeeRequest *request); +void zblib_request_free(ZigBeeServiceInterface *service_interface, + guint request_id); ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request); void zblib_request_unref(ZigBeeRequest *request); diff --git a/zigbee-daemon/zigbee-lib/src/zblib_common.c b/zigbee-daemon/zigbee-lib/src/zblib_common.c new file mode 100644 index 0000000..e78d5df --- /dev/null +++ b/zigbee-daemon/zigbee-lib/src/zblib_common.c @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Suresh Kumar N (suresh.n@samsung.com) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + + diff --git a/zigbee-daemon/zigbee-lib/src/zblib_request.c b/zigbee-daemon/zigbee-lib/src/zblib_request.c index be8340b..be1039a 100644 --- a/zigbee-daemon/zigbee-lib/src/zblib_request.c +++ b/zigbee-daemon/zigbee-lib/src/zblib_request.c @@ -71,39 +71,165 @@ static ZblibDriverType_e __zblib_request_get_ops_id(guint request_type) return ops_id; } +static gint __zblib_request_ref_request_type_by_request_id(ZigBeeService *service, + guint request_id) +{ + ZigBeeRequest *request = NULL; + GHashTable *request_table = NULL; + + /* Fetch request table from service */ + request_table = zblib_service_ref_request_hash_table(service); + if (NULL == request_table) { + Z_LOGE("zblib_service_ref_request_hash_table failed!"); + return -1; + } + + /* Look-up requets_id in request hash table */ + request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id); + if (NULL == request_table) { + Z_LOGE("No request availabel for request_id: [%d]", request_id); + return -1; + } + + return (gint)(request->request_type); +} + +static ZigBeeRequest *__zblib_request_ref_request_by_request_id(ZigBeeService *service, + guint request_id) +{ + ZigBeeRequest *request = NULL; + GHashTable *request_table = NULL; + + /* Fetch request table from service */ + request_table = zblib_service_ref_request_hash_table(service); + if (NULL == request_table) { + Z_LOGE("zblib_service_ref_request_hash_table failed!"); + return NULL; + } + + /* Look-up requets_id in request hash table */ + request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id); + if (NULL == request_table) { + Z_LOGE("No request availabel for request_id: [%d]", request_id); + return NULL; + } + + return request; +} + static gpointer __zblib_request_create_alarm_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer alarm_request_data = NULL; guint ops_id; - NOT_USED(request_data); NOT_USED(request_data_len); /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ALARM_OPS_GET_ALARM_COUNT: { + ZigbeeAlarmGetAlarmCount_t *in_req; + ZigbeeAlarmGetAlarmCount_t *req = NULL; + + in_req = (ZigbeeAlarmGetAlarmCount_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeAlarmGetAlarmCount_t *) + g_malloc0(sizeof(ZigbeeAlarmGetAlarmCount_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + } + + alarm_request_data = (gpointer)req; } break; case ZBLIB_ALARM_OPS_RESET_ALARM: { + ZigbeeAlarmResetAlarm_t *in_req; + ZigbeeAlarmResetAlarm_t *req = NULL; + + in_req = (ZigbeeAlarmResetAlarm_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeAlarmResetAlarm_t *) + g_malloc0(sizeof(ZigbeeAlarmResetAlarm_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + req->alarm_code = in_req->alarm_code; + req->cluster_id = in_req->cluster_id; + } + + alarm_request_data = (gpointer)req; } break; case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: { + ZigbeeAlarmResetAllAlarm_t *in_req; + ZigbeeAlarmResetAllAlarm_t *req = NULL; + + in_req = (ZigbeeAlarmResetAllAlarm_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeAlarmResetAllAlarm_t *) + g_malloc0(sizeof(ZigbeeAlarmResetAllAlarm_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + } + + alarm_request_data = (gpointer)req; } break; case ZBLIB_ALARM_OPS_ALARM: { + ZigbeeAlarmAlarm_t *in_req; + ZigbeeAlarmAlarm_t *req = NULL; + + in_req = (ZigbeeAlarmAlarm_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeAlarmAlarm_t *) + g_malloc0(sizeof(ZigbeeAlarmAlarm_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + req->alarm_code = in_req->alarm_code; + req->cluster_id = in_req->cluster_id; + } + + alarm_request_data = (gpointer)req; } break; case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: { + ZigbeeAlarmResetAlarmLogs_t *in_req; + ZigbeeAlarmResetAlarmLogs_t *req = NULL; + + in_req = (ZigbeeAlarmResetAlarmLogs_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeAlarmResetAlarmLogs_t *) + g_malloc0(sizeof(ZigbeeAlarmResetAlarmLogs_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + } + + alarm_request_data = (gpointer)req; } break; case ZBLIB_ALARM_OPS_GET_ALARM: { + alarm_request_data = NULL; } break; @@ -120,21 +246,79 @@ static gpointer __zblib_request_create_custom_request_data(guint request_type, gpointer custom_request_data = NULL; guint ops_id; - NOT_USED(request_data); NOT_USED(request_data_len); /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_CUSTOM_OPS_APS_SEND: { + ZigbeeCustomApsSend_t *in_req; + ZigbeeCustomApsSend_t *req = NULL; + + in_req = (ZigbeeCustomApsSend_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeCustomApsSend_t *) + g_malloc0(sizeof(ZigbeeCustomApsSend_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->aps_frame_ctl = in_req->aps_frame_ctl; + req->src_ep = in_req->src_ep; + req->dest_ep = in_req->dest_ep; + req->cluster_id = in_req->cluster_id; + req->profile_id = in_req->profile_id; + req->zcl_frame_ctl = in_req->zcl_frame_ctl; + req->mfg_code = in_req->mfg_code; + memcpy(req->payload, + in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN); + } + + custom_request_data = (gpointer)req; } break; case ZBLIB_CUSTOM_OPS_ZCL_SEND: { + ZigbeeCustomZclSend_t *in_req; + ZigbeeCustomZclSend_t *req = NULL; + + in_req = (ZigbeeCustomZclSend_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeCustomZclSend_t *) + g_malloc0(sizeof(ZigbeeCustomZclSend_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->src_ep = in_req->src_ep; + req->dest_ep = in_req->dest_ep; + req->cluster_id = in_req->cluster_id; + req->zcl_frame_ctl = in_req->zcl_frame_ctl; + req->cmd_id = in_req->cmd_id; + memcpy(req->payload, + in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN); + } + + custom_request_data = (gpointer)req; } break; case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: { + ZigbeeCustomSendToLocal_t *in_req; + ZigbeeCustomSendToLocal_t *req = NULL; + + in_req = (ZigbeeCustomSendToLocal_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeCustomSendToLocal_t *) + g_malloc0(sizeof(ZigbeeCustomSendToLocal_t)); + + /* Copy data */ + memcpy(req->data, + in_req->data, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN); + } + + custom_request_data = (gpointer)req; } break; @@ -151,25 +335,96 @@ static gpointer __zblib_request_create_door_lock_request_data(guint request_type gpointer door_lock_request_data = NULL; guint ops_id; - NOT_USED(request_data); NOT_USED(request_data_len); /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: { + ZigbeeDoorLockSubscriberLockEvent_t *in_req; + ZigbeeDoorLockSubscriberLockEvent_t *req = NULL; + + in_req = (ZigbeeDoorLockSubscriberLockEvent_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeDoorLockSubscriberLockEvent_t *) + g_malloc0(sizeof(ZigbeeDoorLockSubscriberLockEvent_t)); + + /* Copy data */ + memcpy(req->eui64, + in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + } + + door_lock_request_data = (gpointer)req; } break; case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: { + ZigbeeDoorLockSetDoorLockPin_t *in_req; + ZigbeeDoorLockSetDoorLockPin_t *req = NULL; + + in_req = (ZigbeeDoorLockSetDoorLockPin_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeDoorLockSetDoorLockPin_t *) + g_malloc0(sizeof(ZigbeeDoorLockSetDoorLockPin_t)); + + /* Copy data */ + req->uid = in_req->uid; + req->ustatus = in_req->ustatus; + req->utype = in_req->utype; + memcpy(req->eui64, + in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + memcpy(req->pin, + in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN); + } + + door_lock_request_data = (gpointer)req; } break; case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: { + ZigbeeDoorLockSetDoorLock_t *in_req; + ZigbeeDoorLockSetDoorLock_t *req = NULL; + + in_req = (ZigbeeDoorLockSetDoorLock_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeDoorLockSetDoorLock_t *) + g_malloc0(sizeof(ZigbeeDoorLockSetDoorLock_t)); + + /* Copy data */ + memcpy(req->eui64, + in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + memcpy(req->pin, + in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN); + req->lock_unlock_type = in_req->lock_unlock_type; + } + + door_lock_request_data = (gpointer)req; } break; case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: { + ZigbeeDoorLockGetDoorLock_t *in_req; + ZigbeeDoorLockGetDoorLock_t *req = NULL; + + in_req = (ZigbeeDoorLockGetDoorLock_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeDoorLockGetDoorLock_t *) + g_malloc0(sizeof(ZigbeeDoorLockGetDoorLock_t)); + + /* Copy data */ + memcpy(req->eui64, + in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + } + + door_lock_request_data = (gpointer)req; } break; @@ -186,25 +441,88 @@ static gpointer __zblib_request_create_fan_control_request_data(guint request_ty gpointer fan_control_request_data = NULL; guint ops_id; - NOT_USED(request_data); NOT_USED(request_data_len); /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE: { + ZigbeeFanControlSetFanMode_t *in_req; + ZigbeeFanControlSetFanMode_t *req = NULL; + + in_req = (ZigbeeFanControlSetFanMode_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeFanControlSetFanMode_t *) + g_malloc0(sizeof(ZigbeeFanControlSetFanMode_t)); + + /* Copy data */ + memcpy(req->eui64, + in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + } + + fan_control_request_data = (gpointer)req; } break; case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: { + ZigbeeFanControlGetFanMode_t *in_req; + ZigbeeFanControlGetFanMode_t *req = NULL; + + in_req = (ZigbeeFanControlGetFanMode_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeFanControlGetFanMode_t *) + g_malloc0(sizeof(ZigbeeFanControlGetFanMode_t)); + + /* Copy data */ + memcpy(req->eui64, + in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + } + + fan_control_request_data = (gpointer)req; } break; case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: { + ZigbeeFanControlSetFanModeSequence_t *in_req; + ZigbeeFanControlSetFanModeSequence_t *req = NULL; + + in_req = (ZigbeeFanControlSetFanModeSequence_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeFanControlSetFanModeSequence_t *) + g_malloc0(sizeof(ZigbeeFanControlSetFanModeSequence_t)); + + /* Copy data */ + memcpy(req->eui64, + in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + } + + fan_control_request_data = (gpointer)req; } break; case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: { + ZigbeeFanControlGetFanModeSequence_t *in_req; + ZigbeeFanControlGetFanModeSequence_t *req = NULL; + + in_req = (ZigbeeFanControlGetFanModeSequence_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeFanControlGetFanModeSequence_t *) + g_malloc0(sizeof(ZigbeeFanControlGetFanModeSequence_t)); + + /* Copy data */ + memcpy(req->eui64, + in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + } + + fan_control_request_data = (gpointer)req; } break; @@ -221,37 +539,155 @@ static gpointer __zblib_request_create_level_control_request_data(guint request_ gpointer level_control_request_data = NULL; guint ops_id; - NOT_USED(request_data); NOT_USED(request_data_len); /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: { + ZigbeeLevelControlMoveToLevel_t *in_req; + ZigbeeLevelControlMoveToLevel_t *req = NULL; + + in_req = (ZigbeeLevelControlMoveToLevel_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeLevelControlMoveToLevel_t *) + g_malloc0(sizeof(ZigbeeLevelControlMoveToLevel_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + req->level = in_req->level; + req->transition = in_req->transition; + } + + level_control_request_data = (gpointer)req; } break; case ZBLIB_LEVEL_CONTROL_OPS_MOVE: { + ZigbeeLevelControlMove_t *in_req; + ZigbeeLevelControlMove_t *req = NULL; + + in_req = (ZigbeeLevelControlMove_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeLevelControlMove_t *) + g_malloc0(sizeof(ZigbeeLevelControlMove_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + req->move_mode = in_req->move_mode; + req->rate = in_req->rate; + } + + level_control_request_data = (gpointer)req; } break; case ZBLIB_LEVEL_CONTROL_OPS_STEP: { + ZigbeeLevelControlStep_t *in_req; + ZigbeeLevelControlStep_t *req = NULL; + + in_req = (ZigbeeLevelControlStep_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeLevelControlStep_t *) + g_malloc0(sizeof(ZigbeeLevelControlStep_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + req->step_mode = in_req->step_mode; + req->move_mode = in_req->move_mode; + req->transition_time = in_req->transition_time; + } + + level_control_request_data = (gpointer)req; } break; case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: { + ZigbeeLevelControlMoveToLevelWithOnOff_t *in_req; + ZigbeeLevelControlMoveToLevelWithOnOff_t *req = NULL; + + in_req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *) + g_malloc0(sizeof(ZigbeeLevelControlMoveToLevelWithOnOff_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + req->level = in_req->level; + req->transition = in_req->transition; + } + + level_control_request_data = (gpointer)req; } break; case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: { + ZigbeeLevelControlMoveOnOff_t *in_req; + ZigbeeLevelControlMoveOnOff_t *req = NULL; + + in_req = (ZigbeeLevelControlMoveOnOff_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeLevelControlMoveOnOff_t *) + g_malloc0(sizeof(ZigbeeLevelControlMoveOnOff_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + req->move_mode = in_req->move_mode; + req->rate = in_req->rate; + } + + level_control_request_data = (gpointer)req; } break; case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: { + ZigbeeLevelControlStepWithOnOff_t *in_req; + ZigbeeLevelControlStepWithOnOff_t *req = NULL; + + in_req = (ZigbeeLevelControlStepWithOnOff_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeLevelControlStepWithOnOff_t *) + g_malloc0(sizeof(ZigbeeLevelControlStepWithOnOff_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + req->step_mode = in_req->step_mode; + req->move_mode = in_req->move_mode; + req->transition_time = in_req->transition_time; + } + + level_control_request_data = (gpointer)req; } break; case ZBLIB_LEVEL_CONTROL_OPS_STOP: { + ZigbeeLevelControlStop_t *in_req; + ZigbeeLevelControlStop_t *req = NULL; + + in_req = (ZigbeeLevelControlStop_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeLevelControlStop_t *) + g_malloc0(sizeof(ZigbeeLevelControlStop_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + } + + level_control_request_data = (gpointer)req; } break; @@ -268,77 +704,327 @@ static gpointer __zblib_request_create_mfglib_control_request_data(guint request gpointer mfglib_control_request_data = NULL; guint ops_id; - NOT_USED(request_data); NOT_USED(request_data_len); /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_MFGLIB_CONTROL_OPS_START: { + ZigbeeMfglibControlStart_t *in_req; + ZigbeeMfglibControlStart_t *req = NULL; + + in_req = (ZigbeeMfglibControlStart_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlStart_t *) + g_malloc0(sizeof(ZigbeeMfglibControlStart_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->mfglib_start = in_req->mfglib_start; + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_END: { + ZigbeeMfglibControlEnd_t *in_req; + ZigbeeMfglibControlEnd_t *req = NULL; + + in_req = (ZigbeeMfglibControlEnd_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlEnd_t *) + g_malloc0(sizeof(ZigbeeMfglibControlEnd_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: { + ZigbeeMfglibControlStartTone_t *in_req; + ZigbeeMfglibControlStartTone_t *req = NULL; + + in_req = (ZigbeeMfglibControlStartTone_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlStartTone_t *) + g_malloc0(sizeof(ZigbeeMfglibControlStartTone_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: { + ZigbeeMfglibControlStopTone_t *in_req; + ZigbeeMfglibControlStopTone_t *req = NULL; + + in_req = (ZigbeeMfglibControlStopTone_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlStopTone_t *) + g_malloc0(sizeof(ZigbeeMfglibControlStopTone_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: { + ZigbeeMfglibControlStartStream_t *in_req; + ZigbeeMfglibControlStartStream_t *req = NULL; + + in_req = (ZigbeeMfglibControlStartStream_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlStartStream_t *) + g_malloc0(sizeof(ZigbeeMfglibControlStartStream_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: { + ZigbeeMfglibControlStopStream_t *in_req; + ZigbeeMfglibControlStopStream_t *req = NULL; + + in_req = (ZigbeeMfglibControlStopStream_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlStopStream_t *) + g_malloc0(sizeof(ZigbeeMfglibControlStopStream_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: { + ZigbeeMfglibControlSendPacket_t *in_req; + ZigbeeMfglibControlSendPacket_t *req = NULL; + + in_req = (ZigbeeMfglibControlSendPacket_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlSendPacket_t *) + g_malloc0(sizeof(ZigbeeMfglibControlSendPacket_t)); + + /* Copy data */ + memcpy(req->packet_content, + in_req->packet_content, + ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN); + req->packet_length = in_req->packet_length; + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: { + ZigbeeMfglibControlSetChannel_t *in_req; + ZigbeeMfglibControlSetChannel_t *req = NULL; + + in_req = (ZigbeeMfglibControlSetChannel_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlSetChannel_t *) + g_malloc0(sizeof(ZigbeeMfglibControlSetChannel_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->channel = in_req->channel; + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: { + ZigbeeMfglibControlGetChannel_t *in_req; + ZigbeeMfglibControlGetChannel_t *req = NULL; + + in_req = (ZigbeeMfglibControlGetChannel_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlGetChannel_t *) + g_malloc0(sizeof(ZigbeeMfglibControlGetChannel_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: { + ZigbeeMfglibControlSetPower_t *in_req; + ZigbeeMfglibControlSetPower_t *req = NULL; + + in_req = (ZigbeeMfglibControlSetPower_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlSetPower_t *) + g_malloc0(sizeof(ZigbeeMfglibControlSetPower_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->tx_power_mode = in_req->tx_power_mode; + req->power = in_req->power; + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: { + ZigbeeMfglibControlGetPower_t *in_req; + ZigbeeMfglibControlGetPower_t *req = NULL; + + in_req = (ZigbeeMfglibControlGetPower_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlGetPower_t *) + g_malloc0(sizeof(ZigbeeMfglibControlGetPower_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: { + ZigbeeMfglibControlSetSynOffset_t *in_req; + ZigbeeMfglibControlSetSynOffset_t *req = NULL; + + in_req = (ZigbeeMfglibControlSetSynOffset_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlSetSynOffset_t *) + g_malloc0(sizeof(ZigbeeMfglibControlSetSynOffset_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->channel = in_req->channel; + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: { + ZigbeeMfglibControlGetSynOffset_t *in_req; + ZigbeeMfglibControlGetSynOffset_t *req = NULL; + + in_req = (ZigbeeMfglibControlGetSynOffset_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlGetSynOffset_t *) + g_malloc0(sizeof(ZigbeeMfglibControlGetSynOffset_t)); + + /* Copy data */ + memcpy(req->packet, + in_req->packet, + ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN); + req->packet_length = in_req->packet_length; + req->link_quality = in_req->link_quality; + req->rssi = in_req->rssi; + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: { + ZigbeeMfglibControlRxStart_t *in_req; + ZigbeeMfglibControlRxStart_t *req = NULL; + + in_req = (ZigbeeMfglibControlRxStart_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlRxStart_t *) + g_malloc0(sizeof(ZigbeeMfglibControlRxStart_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: { + ZigbeeMfglibControlRxStop_t *in_req; + ZigbeeMfglibControlRxStop_t *req = NULL; + + in_req = (ZigbeeMfglibControlRxStop_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlRxStop_t *) + g_malloc0(sizeof(ZigbeeMfglibControlRxStop_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: { + ZigbeeMfglibControlRxVerify_t *in_req; + ZigbeeMfglibControlRxVerify_t *req = NULL; + + in_req = (ZigbeeMfglibControlRxVerify_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlRxVerify_t *) + g_malloc0(sizeof(ZigbeeMfglibControlRxVerify_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + mfglib_control_request_data = (gpointer)req; } break; case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: { + ZigbeeMfglibControlGetRssi_t *in_req; + ZigbeeMfglibControlGetRssi_t *req = NULL; + + in_req = (ZigbeeMfglibControlGetRssi_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeMfglibControlGetRssi_t *) + g_malloc0(sizeof(ZigbeeMfglibControlGetRssi_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + mfglib_control_request_data = (gpointer)req; } break; @@ -355,17 +1041,47 @@ static gpointer __zblib_request_create_on_off_request_data(guint request_type, gpointer on_off_request_data = NULL; guint ops_id; - NOT_USED(request_data); NOT_USED(request_data_len); /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ON_OFF_OPS_SET_ON_OFF: { + ZigbeeOnOffSetOnOff_t *in_req; + ZigbeeOnOffSetOnOff_t *req = NULL; + + in_req = (ZigbeeOnOffSetOnOff_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeOnOffSetOnOff_t *) + g_malloc0(sizeof(ZigbeeOnOffSetOnOff_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + req->on_off_type = in_req->on_off_type; + } + + on_off_request_data = (gpointer)req; } break; case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: { + ZigbeeOnOffGetOnOffState_t *in_req; + ZigbeeOnOffGetOnOffState_t *req = NULL; + + in_req = (ZigbeeOnOffGetOnOffState_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeOnOffGetOnOffState_t *) + g_malloc0(sizeof(ZigbeeOnOffGetOnOffState_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + } + + on_off_request_data = (gpointer)req; } break; @@ -379,12 +1095,2479 @@ static gpointer __zblib_request_create_on_off_request_data(guint request_type, static gpointer __zblib_request_create_service_request_data(guint request_type, gpointer request_data, guint request_data_len) { - gpointer service_request_data = NULL; + gpointer service_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_SERVICE_OPS_ENABLE: { + service_request_data = NULL; + } + break; + + case ZBLIB_SERVICE_OPS_DISABLE: { + service_request_data = NULL; + } + break; + + case ZBLIB_SERVICE_OPS_ZB_HW_RESET: { + service_request_data = NULL; + } + break; + + case ZBLIB_SERVICE_OPS_FORM_NETWORK: { + service_request_data = NULL; + } + break; + + case ZBLIB_SERVICE_OPS_COEX_START: { + ZigbeeServiceCoexStart_t *in_req; + ZigbeeServiceCoexStart_t *req = NULL; + + in_req = (ZigbeeServiceCoexStart_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeServiceCoexStart_t *) + g_malloc0(sizeof(ZigbeeServiceCoexStart_t)); + + /* Copy data */ + req->channel = in_req->channel; + } + + service_request_data = (gpointer)req; + } + break; + + case ZBLIB_SERVICE_OPS_COEX_STOP: { + service_request_data = NULL; + } + break; + + case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: { + service_request_data = NULL; + } + break; + + case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: { + service_request_data = NULL; + } + break; + + case ZBLIB_SERVICE_OPS_PERMIT_JOIN: { + ZigbeeServicePermitJoin_t *in_req; + ZigbeeServicePermitJoin_t *req = NULL; + + in_req = (ZigbeeServicePermitJoin_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeServicePermitJoin_t *) + g_malloc0(sizeof(ZigbeeServicePermitJoin_t)); + + /* Copy data */ + req->permit_join = in_req->permit_join; + req->duration = in_req->duration; + } + + service_request_data = (gpointer)req; + } + break; + + case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: { + ZigbeeServiceLeaveRequest_t *in_req; + ZigbeeServiceLeaveRequest_t *req = NULL; + + in_req = (ZigbeeServiceLeaveRequest_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeServiceLeaveRequest_t *) + g_malloc0(sizeof(ZigbeeServiceLeaveRequest_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->remove_child = in_req->remove_child; + req->rejoin = in_req->rejoin; + } + + service_request_data = (gpointer)req; + } + break; + + case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: { + service_request_data = NULL; + } + break; + + case ZBLIB_SERVICE_OPS_GET_MAC: { + service_request_data = NULL; + } + break; + + case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: { + service_request_data = NULL; + } + break; + + case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: { + ZigbeeServiceGetEndpointList_t *in_req; + ZigbeeServiceGetEndpointList_t *req = NULL; + + in_req = (ZigbeeServiceGetEndpointList_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeServiceGetEndpointList_t *) + g_malloc0(sizeof(ZigbeeServiceGetEndpointList_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + service_request_data = (gpointer)req; + } + break; + + case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: { + ZigbeeServiceGetClusterList_t *in_req; + ZigbeeServiceGetClusterList_t *req = NULL; + + in_req = (ZigbeeServiceGetClusterList_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeServiceGetClusterList_t *) + g_malloc0(sizeof(ZigbeeServiceGetClusterList_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + } + + service_request_data = (gpointer)req; + } + break; + + case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: { + ZigbeeServiceGetNodeType_t *in_req; + ZigbeeServiceGetNodeType_t *req = NULL; + + in_req = (ZigbeeServiceGetNodeType_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeServiceGetNodeType_t *) + g_malloc0(sizeof(ZigbeeServiceGetNodeType_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + } + + service_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return service_request_data; +} + +static gpointer __zblib_request_create_thermostat_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer thermostat_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP: { + ZigbeeThermostatGetLocalTemp_t *in_req; + ZigbeeThermostatGetLocalTemp_t *req = NULL; + + in_req = (ZigbeeThermostatGetLocalTemp_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeThermostatGetLocalTemp_t *) + g_malloc0(sizeof(ZigbeeThermostatGetLocalTemp_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + } + + thermostat_request_data = (gpointer)req; + } + break; + + case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: { + ZigbeeThermostatGetWeeklySchedule_t *in_req; + ZigbeeThermostatGetWeeklySchedule_t *req = NULL; + + in_req = (ZigbeeThermostatGetWeeklySchedule_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeThermostatGetWeeklySchedule_t *) + g_malloc0(sizeof(ZigbeeThermostatGetWeeklySchedule_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + req->num_of_days = in_req->num_of_days; + req->mode = in_req->mode; + } + + thermostat_request_data = (gpointer)req; + } + break; + + case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: { + ZigbeeThermostatSetWeeklySchedule_t *in_req; + ZigbeeThermostatSetWeeklySchedule_t *req = NULL; + + in_req = (ZigbeeThermostatSetWeeklySchedule_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeThermostatSetWeeklySchedule_t *) + g_malloc0(sizeof(ZigbeeThermostatSetWeeklySchedule_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + req->no_of_transitions = in_req->no_of_transitions; + req->num_of_days = in_req->num_of_days; + req->mode = in_req->mode; + memcpy(req->payload, + in_req->payload, ZIGBEE_THERMSTAT_PAYLOAD_MAX_LEN); + req->payload_len = in_req->payload_len; + } + + thermostat_request_data = (gpointer)req; + } + break; + + case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: { + ZigbeeThermostatClearWeeklySchedule_t *in_req; + ZigbeeThermostatClearWeeklySchedule_t *req = NULL; + + in_req = (ZigbeeThermostatClearWeeklySchedule_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeThermostatClearWeeklySchedule_t *) + g_malloc0(sizeof(ZigbeeThermostatClearWeeklySchedule_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->endpoint = in_req->endpoint; + } + + thermostat_request_data = (gpointer)req; + } + break; + + case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: { + ZigbeeThermostatSetpointRaiseLower_t *in_req; + ZigbeeThermostatSetpointRaiseLower_t *req = NULL; + + in_req = (ZigbeeThermostatSetpointRaiseLower_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeThermostatSetpointRaiseLower_t *) + g_malloc0(sizeof(ZigbeeThermostatSetpointRaiseLower_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + req->mode = in_req->mode; + req->amount = in_req->amount; + } + + thermostat_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return thermostat_request_data; +} + +static gpointer __zblib_request_create_zclbasic_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zclbasic_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT: { + ZigbeeZclbasicControlResetFactoryDefault_t *in_req; + ZigbeeZclbasicControlResetFactoryDefault_t *req = NULL; + + in_req = (ZigbeeZclbasicControlResetFactoryDefault_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclbasicControlResetFactoryDefault_t *) + g_malloc0(sizeof(ZigbeeZclbasicControlResetFactoryDefault_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + } + + zclbasic_control_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return zclbasic_control_request_data; +} + +static gpointer __zblib_request_create_zclglobal_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zclglobal_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: { + ZigbeeZclglobalControlReadAttributesRequest_t *in_req; + ZigbeeZclglobalControlReadAttributesRequest_t *req = NULL; + + in_req = (ZigbeeZclglobalControlReadAttributesRequest_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlReadAttributesRequest_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlReadAttributesRequest_t)); + + /* Copy data */ + req->attribute_id = g_strdup(in_req->attribute_id); + req->attribute_id_len = in_req->attribute_id_len; + req->node_id = in_req->node_id; + req->cluster_id = in_req->cluster_id; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->dest_ep = in_req->dest_ep; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: { + ZigbeeZclglobalControlWriteAttributesRequest_t *in_req; + ZigbeeZclglobalControlWriteAttributesRequest_t *req = NULL; + + in_req = (ZigbeeZclglobalControlWriteAttributesRequest_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlWriteAttributesRequest_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesRequest_t)); + + /* Copy data */ + req->write_records = g_strdup(in_req->write_records); + req->records_len = in_req->records_len; + req->node_id = in_req->node_id; + req->cluster_id = in_req->cluster_id; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->src_ep = in_req->src_ep; + req->dest_ep = in_req->dest_ep; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: { + ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *in_req; + ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *req = NULL; + + in_req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesUndividedRequest_t)); + + /* Copy data */ + req->write_records = g_strdup(in_req->write_records); + req->records_len = in_req->records_len; + req->node_id = in_req->node_id; + req->cluster_id = in_req->cluster_id; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->src_ep = in_req->src_ep; + req->dest_ep = in_req->dest_ep; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: { + ZigbeeZclglobalControlWriteAttributesNoResponse_t *in_req; + ZigbeeZclglobalControlWriteAttributesNoResponse_t *req = NULL; + + in_req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesNoResponse_t)); + + /* Copy data */ + req->write_records = g_strdup(in_req->write_records); + req->records_len = in_req->records_len; + req->node_id = in_req->node_id; + req->cluster_id = in_req->cluster_id; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->src_ep = in_req->src_ep; + req->dest_ep = in_req->dest_ep; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: { + ZigbeeZclglobalControlWriteAttributesStructed_t *in_req; + ZigbeeZclglobalControlWriteAttributesStructed_t *req = NULL; + + in_req = (ZigbeeZclglobalControlWriteAttributesStructed_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlWriteAttributesStructed_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesStructed_t)); + + /* Copy data */ + req->write_records = g_strdup(in_req->write_records); + req->records_len = in_req->records_len; + req->node_id = in_req->node_id; + req->cluster_id = in_req->cluster_id; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->src_ep = in_req->src_ep; + req->dest_ep = in_req->dest_ep; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: { + ZigbeeZclglobalControlReadAttributesStructed_t *in_req; + ZigbeeZclglobalControlReadAttributesStructed_t *req = NULL; + + in_req = (ZigbeeZclglobalControlReadAttributesStructed_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlReadAttributesStructed_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlReadAttributesStructed_t)); + + /* Copy data */ + req->read_records = g_strdup(in_req->read_records); + req->records_len = in_req->records_len; + req->node_id = in_req->node_id; + req->cluster_id = in_req->cluster_id; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->src_ep = in_req->src_ep; + req->dest_ep = in_req->dest_ep; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: { + ZigbeeZclglobalControlConfigureReportingReq_t *in_req; + ZigbeeZclglobalControlConfigureReportingReq_t *req = NULL; + + in_req = (ZigbeeZclglobalControlConfigureReportingReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlConfigureReportingReq_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlConfigureReportingReq_t)); + + /* Copy data */ + req->read_records = g_strdup(in_req->read_records); + req->records_len = in_req->records_len; + req->node_id = in_req->node_id; + req->cluster_id = in_req->cluster_id; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->src_ep = in_req->src_ep; + req->dest_ep = in_req->dest_ep; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: { + ZigbeeZclglobalControlReadConfigureReporting_t *in_req; + ZigbeeZclglobalControlReadConfigureReporting_t *req = NULL; + + in_req = (ZigbeeZclglobalControlReadConfigureReporting_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlReadConfigureReporting_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlReadConfigureReporting_t)); + + /* Copy data */ + req->read_records = g_strdup(in_req->read_records); + req->records_len = in_req->records_len; + req->node_id = in_req->node_id; + req->cluster_id = in_req->cluster_id; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->src_ep = in_req->src_ep; + req->dest_ep = in_req->dest_ep; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: { + ZigbeeZclglobalControlDiscoverAttributes_t *in_req; + ZigbeeZclglobalControlDiscoverAttributes_t *req = NULL; + + in_req = (ZigbeeZclglobalControlDiscoverAttributes_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlDiscoverAttributes_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverAttributes_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->cluster_id = in_req->cluster_id; + req->start_attribute = in_req->start_attribute; + req->max = in_req->max; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: { + ZigbeeZclglobalControlDiscoverAttributesExtended_t *in_req; + ZigbeeZclglobalControlDiscoverAttributesExtended_t *req = NULL; + + in_req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverAttributesExtended_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->cluster_id = in_req->cluster_id; + req->start_attribute = in_req->start_attribute; + req->max = in_req->max; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: { + ZigbeeZclglobalControlDiscoverCommandsReceived_t *in_req; + ZigbeeZclglobalControlDiscoverCommandsReceived_t *req = NULL; + + in_req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverCommandsReceived_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->cluster_id = in_req->cluster_id; + req->start_attribute = in_req->start_attribute; + req->max = in_req->max; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: { + ZigbeeZclglobalControlDiscoverCommandsGenerated_t *in_req; + ZigbeeZclglobalControlDiscoverCommandsGenerated_t *req = NULL; + + in_req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *) + g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverCommandsGenerated_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; + req->cluster_id = in_req->cluster_id; + req->start_attribute = in_req->start_attribute; + req->max = in_req->max; + } + + zclglobal_control_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return zclglobal_control_request_data; +} + +static gpointer __zblib_request_create_zclias_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zclias_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE: { + ZigbeeZcliasControlEnrolResponse_t *in_req; + ZigbeeZcliasControlEnrolResponse_t *req = NULL; + + in_req = (ZigbeeZcliasControlEnrolResponse_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZcliasControlEnrolResponse_t *) + g_malloc0(sizeof(ZigbeeZcliasControlEnrolResponse_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->enroll_code = in_req->enroll_code; + req->zone_id = in_req->zone_id; + } + + zclias_control_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return zclias_control_request_data; +} + +static gpointer __zblib_request_create_zclidentify_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zclidentify_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY: { + ZigbeeZclidentifyControlIdentify_t *in_req; + ZigbeeZclidentifyControlIdentify_t *req = NULL; + + in_req = (ZigbeeZclidentifyControlIdentify_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclidentifyControlIdentify_t *) + g_malloc0(sizeof(ZigbeeZclidentifyControlIdentify_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->identify_time = in_req->identify_time; + } + + zclidentify_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: { + ZigbeeZclidentifyControlQuery_t *in_req; + ZigbeeZclidentifyControlQuery_t *req = NULL; + + in_req = (ZigbeeZclidentifyControlQuery_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclidentifyControlQuery_t *) + g_malloc0(sizeof(ZigbeeZclidentifyControlQuery_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + } + + zclidentify_control_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return zclidentify_control_request_data; +} + +static gpointer __zblib_request_create_zcl_color_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zcl_color_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE: { + ZigbeeZclColorMoveToHue_t *in_req; + ZigbeeZclColorMoveToHue_t *req = NULL; + + in_req = (ZigbeeZclColorMoveToHue_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclColorMoveToHue_t *) + g_malloc0(sizeof(ZigbeeZclColorMoveToHue_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->hue = in_req->hue; + req->direction = in_req->direction; + req->transition_time = in_req->transition_time; + } + + zcl_color_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: { + ZigbeeZclColorMoveHue_t *in_req; + ZigbeeZclColorMoveHue_t *req = NULL; + + in_req = (ZigbeeZclColorMoveHue_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclColorMoveHue_t *) + g_malloc0(sizeof(ZigbeeZclColorMoveHue_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->move_mode = in_req->move_mode; + req->rate = in_req->rate; + } + + zcl_color_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: { + ZigbeeZclColorStepHue_t *in_req; + ZigbeeZclColorStepHue_t *req = NULL; + + in_req = (ZigbeeZclColorStepHue_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclColorStepHue_t *) + g_malloc0(sizeof(ZigbeeZclColorStepHue_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->step_mode = in_req->step_mode; + req->step_size = in_req->step_size; + req->transition_time = in_req->transition_time; + } + + zcl_color_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: { + ZigbeeZclColorMoveToSaturation_t *in_req; + ZigbeeZclColorMoveToSaturation_t *req = NULL; + + in_req = (ZigbeeZclColorMoveToSaturation_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclColorMoveToSaturation_t *) + g_malloc0(sizeof(ZigbeeZclColorMoveToSaturation_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->saturation = in_req->saturation; + req->transition_time = in_req->transition_time; + } + + zcl_color_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: { + ZigbeeZclColorMoveSaturation_t *in_req; + ZigbeeZclColorMoveSaturation_t *req = NULL; + + in_req = (ZigbeeZclColorMoveSaturation_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclColorMoveSaturation_t *) + g_malloc0(sizeof(ZigbeeZclColorMoveSaturation_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->move_mode = in_req->move_mode; + req->rate = in_req->rate; + } + + zcl_color_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: { + ZigbeeZclColorStepSaturation_t *in_req; + ZigbeeZclColorStepSaturation_t *req = NULL; + + in_req = (ZigbeeZclColorStepSaturation_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclColorStepSaturation_t *) + g_malloc0(sizeof(ZigbeeZclColorStepSaturation_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->step_mode = in_req->step_mode; + req->step_size = in_req->step_size; + req->transition_time = in_req->transition_time; + } + + zcl_color_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: { + ZigbeeZclColorMoveToHueAndSaturation_t *in_req; + ZigbeeZclColorMoveToHueAndSaturation_t *req = NULL; + + in_req = (ZigbeeZclColorMoveToHueAndSaturation_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclColorMoveToHueAndSaturation_t *) + g_malloc0(sizeof(ZigbeeZclColorMoveToHueAndSaturation_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->hue = in_req->hue; + req->saturation = in_req->saturation; + req->transition_time = in_req->transition_time; + } + + zcl_color_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: { + ZigbeeZclColorMoveToColor_t *in_req; + ZigbeeZclColorMoveToColor_t *req = NULL; + + in_req = (ZigbeeZclColorMoveToColor_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclColorMoveToColor_t *) + g_malloc0(sizeof(ZigbeeZclColorMoveToColor_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->color_x = in_req->color_x; + req->color_y = in_req->color_y; + req->transition_time = in_req->transition_time; + } + + zcl_color_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: { + ZigbeeZclColorMoveColor_t *in_req; + ZigbeeZclColorMoveColor_t *req = NULL; + + in_req = (ZigbeeZclColorMoveColor_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclColorMoveColor_t *) + g_malloc0(sizeof(ZigbeeZclColorMoveColor_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->rate_x = in_req->rate_x; + req->rate_y = in_req->rate_y; + } + + zcl_color_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: { + ZigbeeZclColorStepColor_t *in_req; + ZigbeeZclColorStepColor_t *req = NULL; + + in_req = (ZigbeeZclColorStepColor_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclColorStepColor_t *) + g_malloc0(sizeof(ZigbeeZclColorStepColor_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->rate_x = in_req->rate_x; + req->rate_y = in_req->rate_y; + req->transition_time = in_req->transition_time; + } + + zcl_color_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: { + ZigbeeZclColorMoveColorTemperature_t *in_req; + ZigbeeZclColorMoveColorTemperature_t *req = NULL; + + in_req = (ZigbeeZclColorMoveColorTemperature_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclColorMoveColorTemperature_t *) + g_malloc0(sizeof(ZigbeeZclColorMoveColorTemperature_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->color_temperature = in_req->color_temperature; + req->transition_time = in_req->transition_time; + } + + zcl_color_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return zcl_color_request_data; +} + +static gpointer __zblib_request_create_zcl_group_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zcl_group_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: { + ZigbeeZclGroupAddGroup_t *in_req; + ZigbeeZclGroupAddGroup_t *req = NULL; + + in_req = (ZigbeeZclGroupAddGroup_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclGroupAddGroup_t *) + g_malloc0(sizeof(ZigbeeZclGroupAddGroup_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->group_id = in_req->group_id; + g_strlcpy(req->group_name, + in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1); + } + + zcl_group_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: { + ZigbeeZclGroupViewGroup_t *in_req; + ZigbeeZclGroupViewGroup_t *req = NULL; + + in_req = (ZigbeeZclGroupViewGroup_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclGroupViewGroup_t *) + g_malloc0(sizeof(ZigbeeZclGroupViewGroup_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + } + + zcl_group_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: { + ZigbeeZclGroupGetGroupMembership_t *in_req; + ZigbeeZclGroupGetGroupMembership_t *req = NULL; + + in_req = (ZigbeeZclGroupGetGroupMembership_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclGroupGetGroupMembership_t *) + g_malloc0(sizeof(ZigbeeZclGroupGetGroupMembership_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->group_count = in_req->group_count; + req->group_list = (gshort *)g_memdup(in_req->group_list, + in_req->group_count); + } + + zcl_group_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: { + ZigbeeZclGroupRemoveGroup_t *in_req; + ZigbeeZclGroupRemoveGroup_t *req = NULL; + + in_req = (ZigbeeZclGroupRemoveGroup_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclGroupRemoveGroup_t *) + g_malloc0(sizeof(ZigbeeZclGroupRemoveGroup_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->group_id = in_req->group_id; + } + + zcl_group_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: { + ZigbeeZclGroupRemoveAllGroup_t *in_req; + ZigbeeZclGroupRemoveAllGroup_t *req = NULL; + + in_req = (ZigbeeZclGroupRemoveAllGroup_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclGroupRemoveAllGroup_t *) + g_malloc0(sizeof(ZigbeeZclGroupRemoveAllGroup_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + } + + zcl_group_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: { + ZigbeeZclGroupAddGroupIfIdentifying_t *in_req; + ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL; + + in_req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclGroupAddGroupIfIdentifying_t *) + g_malloc0(sizeof(ZigbeeZclGroupAddGroupIfIdentifying_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->group_id = in_req->group_id; + g_strlcpy(req->group_name, + in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1); + } + + zcl_group_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return zcl_group_request_data; +} + +static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zcl_poll_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: { + ZigbeeZclPollControlCheckInResponse_t *in_req; + ZigbeeZclPollControlCheckInResponse_t *req = NULL; + + in_req = (ZigbeeZclPollControlCheckInResponse_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclPollControlCheckInResponse_t *) + g_malloc0(sizeof(ZigbeeZclPollControlCheckInResponse_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->start_fast_polling = in_req->start_fast_polling; + req->fast_poll_timeout = in_req->fast_poll_timeout; + } + + zcl_poll_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: { + ZigbeeZclPollControlFastPollStop_t *in_req; + ZigbeeZclPollControlFastPollStop_t *req = NULL; + + in_req = (ZigbeeZclPollControlFastPollStop_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclPollControlFastPollStop_t *) + g_malloc0(sizeof(ZigbeeZclPollControlFastPollStop_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + } + + zcl_poll_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: { + ZigbeeZclPollControlSetLongPollInterval_t *in_req; + ZigbeeZclPollControlSetLongPollInterval_t *req = NULL; + + in_req = (ZigbeeZclPollControlSetLongPollInterval_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclPollControlSetLongPollInterval_t *) + g_malloc0(sizeof(ZigbeeZclPollControlSetLongPollInterval_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->new_long_poll_interval = in_req->new_long_poll_interval; + } + + zcl_poll_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: { + ZigbeeZclPollControlSetShortPollInterval_t *in_req; + ZigbeeZclPollControlSetShortPollInterval_t *req = NULL; + + in_req = (ZigbeeZclPollControlSetShortPollInterval_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclPollControlSetShortPollInterval_t *) + g_malloc0(sizeof(ZigbeeZclPollControlSetShortPollInterval_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->new_short_poll_interval = in_req->new_short_poll_interval; + } + + zcl_poll_control_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return zcl_poll_control_request_data; +} + +static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zcl_scene_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: { + ZigbeeZclSceneAddScene_t *in_req; + ZigbeeZclSceneAddScene_t *req = NULL; + + in_req = (ZigbeeZclSceneAddScene_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclSceneAddScene_t *) + g_malloc0(sizeof(ZigbeeZclSceneAddScene_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->group_id = in_req->group_id; + req->scene_id = in_req->scene_id; + req->transition_time = in_req->transition_time; + g_strlcpy(req->scene_name, + in_req->scene_name, ZIGBEE_ZCL_SCENE_NAME_MAX_LEN + 1); + req->ext_field_set_len = in_req->ext_field_set_len; + req->ext_field_set = (gshort *)g_memdup(in_req->ext_field_set, + in_req->ext_field_set_len); + } + + zcl_scene_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: { + ZigbeeZclSceneViewScene_t *in_req; + ZigbeeZclSceneViewScene_t *req = NULL; + + in_req = (ZigbeeZclSceneViewScene_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclSceneViewScene_t *) + g_malloc0(sizeof(ZigbeeZclSceneViewScene_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->group_id = in_req->group_id; + req->scene_id = in_req->scene_id; + } + + zcl_scene_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: { + ZigbeeZclSceneRemoveScene_t *in_req; + ZigbeeZclSceneRemoveScene_t *req = NULL; + + in_req = (ZigbeeZclSceneRemoveScene_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclSceneRemoveScene_t *) + g_malloc0(sizeof(ZigbeeZclSceneRemoveScene_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->group_id = in_req->group_id; + req->scene_id = in_req->scene_id; + } + + zcl_scene_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: { + ZigbeeZclSceneStoreScene_t *in_req; + ZigbeeZclSceneStoreScene_t *req = NULL; + + in_req = (ZigbeeZclSceneStoreScene_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclSceneStoreScene_t *) + g_malloc0(sizeof(ZigbeeZclSceneStoreScene_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->group_id = in_req->group_id; + req->scene_id = in_req->scene_id; + } + + zcl_scene_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: { + ZigbeeZclSceneRecallScene_t *in_req; + ZigbeeZclSceneRecallScene_t *req = NULL; + + in_req = (ZigbeeZclSceneRecallScene_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclSceneRecallScene_t *) + g_malloc0(sizeof(ZigbeeZclSceneRecallScene_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->group_id = in_req->group_id; + req->scene_id = in_req->scene_id; + } + + zcl_scene_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: { + ZigbeeZclSceneRemoveAllScene_t *in_req; + ZigbeeZclSceneRemoveAllScene_t *req = NULL; + + in_req = (ZigbeeZclSceneRemoveAllScene_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclSceneRemoveAllScene_t *) + g_malloc0(sizeof(ZigbeeZclSceneRemoveAllScene_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->group_id = in_req->group_id; + } + + zcl_scene_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: { + ZigbeeZclSceneGetSceneMembership_t *in_req; + ZigbeeZclSceneGetSceneMembership_t *req = NULL; + + in_req = (ZigbeeZclSceneGetSceneMembership_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZclSceneGetSceneMembership_t *) + g_malloc0(sizeof(ZigbeeZclSceneGetSceneMembership_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; + req->group_id = in_req->group_id; + } + + zcl_scene_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return zcl_scene_request_data; +} + +static gpointer __zblib_request_create_zdodev_control_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zdodev_control_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ: { + ZigbeeZdodevControlNwkAddrReq_t *in_req; + ZigbeeZdodevControlNwkAddrReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlNwkAddrReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlNwkAddrReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlNwkAddrReq_t)); + + /* Copy data */ + memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); + req->request_type = in_req->request_type; + req->start_index = in_req->start_index; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: { + ZigbeeZdodevControlMatchedDescriptorReq_t *in_req; + ZigbeeZdodevControlMatchedDescriptorReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlMatchedDescriptorReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlMatchedDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlMatchedDescriptorReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->profile_id = in_req->profile_id; + req->num_in_cl = in_req->num_in_cl; + req->in_cl = g_strdup(in_req->in_cl); + req->num_out_cl = in_req->num_out_cl; + req->out_cl = g_strdup(in_req->out_cl); + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: { + ZigbeeZdodevControlIeeeAddrReq_t *in_req; + ZigbeeZdodevControlIeeeAddrReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlIeeeAddrReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlIeeeAddrReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlIeeeAddrReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: { + ZigbeeZdodevControlActiveEpReq_t *in_req; + ZigbeeZdodevControlActiveEpReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlActiveEpReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlActiveEpReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlActiveEpReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: { + ZigbeeZdodevControlNodeDescriptorReq_t *in_req; + ZigbeeZdodevControlNodeDescriptorReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlNodeDescriptorReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlNodeDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlNodeDescriptorReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: { + ZigbeeZdodevControlPowerDescriptorReq_t *in_req; + ZigbeeZdodevControlPowerDescriptorReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlPowerDescriptorReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlPowerDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlPowerDescriptorReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: { + ZigbeeZdodevControlComplexDescriptorReq_t *in_req; + ZigbeeZdodevControlComplexDescriptorReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlComplexDescriptorReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlComplexDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlComplexDescriptorReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: { + ZigbeeZdodevControlUserDescriptorReq_t *in_req; + ZigbeeZdodevControlUserDescriptorReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlUserDescriptorReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlUserDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlUserDescriptorReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: { + ZigbeeZdodevControlUserDescriptorSetReq_t *in_req; + ZigbeeZdodevControlUserDescriptorSetReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlUserDescriptorSetReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlUserDescriptorSetReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlUserDescriptorSetReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->user_descriptor_len = in_req->user_descriptor_len; + memcpy(req->user_descriptor, + in_req->user_descriptor, in_req->user_descriptor_len); + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: { + ZigbeeZdodevControlDeviceAnnounce_t *in_req; + ZigbeeZdodevControlDeviceAnnounce_t *req = NULL; + + in_req = (ZigbeeZdodevControlDeviceAnnounce_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlDeviceAnnounce_t *) + g_malloc0(sizeof(ZigbeeZdodevControlDeviceAnnounce_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + memcpy(req->mac_addr, in_req->mac_addr, ZIGBEE_EUI64_SIZE); + req->capability = in_req->capability; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: { + ZigbeeZdodevControlSimpleDescriptorReq_t *in_req; + ZigbeeZdodevControlSimpleDescriptorReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlSimpleDescriptorReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlSimpleDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlSimpleDescriptorReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: { + ZigbeeZdodevControlMgmtLqiReq_t *in_req; + ZigbeeZdodevControlMgmtLqiReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlMgmtLqiReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlMgmtLqiReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlMgmtLqiReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->start_index = in_req->start_index; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: { + ZigbeeZdodevControlMgmtRtgReq_t *in_req; + ZigbeeZdodevControlMgmtRtgReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlMgmtRtgReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlMgmtRtgReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlMgmtRtgReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->start_index = in_req->start_index; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: { + ZigbeeZdodevControlMgmtBindReq_t *in_req; + ZigbeeZdodevControlMgmtBindReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlMgmtBindReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlMgmtBindReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlMgmtBindReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->start_index = in_req->start_index; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: { + ZigbeeZdodevControlMgmtPermitJoinReq_t *in_req; + ZigbeeZdodevControlMgmtPermitJoinReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlMgmtPermitJoinReq_t)); + + /* Copy data */ + req->addr = in_req->addr; + req->duration = in_req->duration; + req->tc_significance = in_req->tc_significance; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: { + ZigbeeZdodevControlNwkUpdateReq_t *in_req; + ZigbeeZdodevControlNwkUpdateReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlNwkUpdateReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlNwkUpdateReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlNwkUpdateReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->scan_channel = in_req->scan_channel; + req->scan_duration = in_req->scan_duration; + req->scan_count = in_req->scan_count; + req->network_update_id = in_req->network_update_id; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: { + ZigbeeZdodevControlNwkDescriptorReq_t *in_req; + ZigbeeZdodevControlNwkDescriptorReq_t *req = NULL; + + in_req = (ZigbeeZdodevControlNwkDescriptorReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdodevControlNwkDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdodevControlNwkDescriptorReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->scan_channel = in_req->scan_channel; + req->scan_duration = in_req->scan_duration; + req->scan_count = in_req->scan_count; + req->start_index = in_req->start_index; + } + + zdodev_control_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return zdodev_control_request_data; +} + +static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer zdo_bind_request_data = NULL; + guint ops_id; + + NOT_USED(request_data_len); + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ZDO_BIND_OPS_BIND_REQ: { + ZigbeeZdoBindBindReq_t *in_req; + ZigbeeZdoBindBindReq_t *req = NULL; + + in_req = (ZigbeeZdoBindBindReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdoBindBindReq_t *) + g_malloc0(sizeof(ZigbeeZdoBindBindReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + g_strlcpy(req->src_addr, + in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1); + req->src_ep = in_req->src_ep; + req->cluster_id = in_req->cluster_id; + g_strlcpy(req->dst_addr, + in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1); + req->bind_type = in_req->bind_type; + req->group_addr = in_req->group_addr; + req->dst_ep = in_req->dst_ep; + } + + zdo_bind_request_data = (gpointer)req; + } + break; + + case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: { + ZigbeeZdoBindUnbindReq_t *in_req; + ZigbeeZdoBindUnbindReq_t *req = NULL; + + in_req = (ZigbeeZdoBindUnbindReq_t *)request_data; + if (NULL != in_req) { + /* Allocate memory */ + req = (ZigbeeZdoBindUnbindReq_t *) + g_malloc0(sizeof(ZigbeeZdoBindUnbindReq_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + g_strlcpy(req->src_addr, + in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1); + req->src_ep = in_req->src_ep; + req->cluster_id = in_req->cluster_id; + g_strlcpy(req->dst_addr, + in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1); + req->bind_type = in_req->bind_type; + req->group_addr = in_req->group_addr; + req->dst_ep = in_req->dst_ep; + } + + zdo_bind_request_data = (gpointer)req; + } + break; + + default: + break; + } + + return zdo_bind_request_data; +} + + +static gpointer __zblib_request_create_request_data(guint request_type, + gpointer request_data, guint request_data_len) +{ + gpointer _request_data = NULL; + ZblibDriverType_e driver_type; + + /* Fetch driver type */ + driver_type = __zblib_request_get_driver_type(request_type); + switch (driver_type) { + case ZBLIB_DRIVER_TYPE_ALARM: { + _request_data = __zblib_request_create_alarm_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_CUSTOM: { + _request_data = __zblib_request_create_custom_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_DOOR_LOCK: { + _request_data = __zblib_request_create_door_lock_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_FAN_CONTROL: { + _request_data = __zblib_request_create_fan_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_LEVEL_CONTROL: { + _request_data = __zblib_request_create_level_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: { + _request_data = __zblib_request_create_mfglib_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ON_OFF: { + _request_data = __zblib_request_create_on_off_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_SERVICE: { + _request_data = __zblib_request_create_service_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_THERMOSTAT: { + _request_data = __zblib_request_create_thermostat_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL: { + _request_data = __zblib_request_create_zclbasic_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL: { + _request_data = __zblib_request_create_zclglobal_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL: { + _request_data = __zblib_request_create_zclias_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL: { + _request_data = __zblib_request_create_zclidentify_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCL_COLOR: { + _request_data = __zblib_request_create_zcl_color_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCL_GROUP: { + _request_data = __zblib_request_create_zcl_group_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: { + _request_data = __zblib_request_create_zcl_poll_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZCL_SCENE: { + _request_data = __zblib_request_create_zcl_scene_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL: { + _request_data = __zblib_request_create_zdodev_control_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_ZDO_BIND: { + _request_data = __zblib_request_create_zdo_bind_request_data(request_type, + request_data, request_data_len); + } + break; + + case ZBLIB_DRIVER_TYPE_NONE: /* Fallthrough */ + default: { + Z_LOGE("Unhandled driver type: [%d]", driver_type); + } + break; + } + + return _request_data; +} + +static void __zblib_request_free_alarm_request_data(ZigBeeRequest *request, + guint request_type) +{ + guint ops_id; + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ALARM_OPS_GET_ALARM_COUNT: { + ZigbeeAlarmGetAlarmCount_t *req = NULL; + + req = (ZigbeeAlarmGetAlarmCount_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_ALARM_OPS_RESET_ALARM: { + ZigbeeAlarmResetAlarm_t *req = NULL; + + req = (ZigbeeAlarmResetAlarm_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: { + ZigbeeAlarmResetAllAlarm_t *req = NULL; + + req = (ZigbeeAlarmResetAllAlarm_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_ALARM_OPS_ALARM: { + ZigbeeAlarmAlarm_t *req = NULL; + + req = (ZigbeeAlarmAlarm_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: { + ZigbeeAlarmResetAlarmLogs_t *req = NULL; + + req = (ZigbeeAlarmResetAlarmLogs_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_ALARM_OPS_GET_ALARM: { + } + break; + + default: + break; + } +} + +static void __zblib_request_free_custom_request_data(ZigBeeRequest *request, + guint request_type) +{ + guint ops_id; + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_CUSTOM_OPS_APS_SEND: { + ZigbeeCustomApsSend_t *req = NULL; + + req = (ZigbeeCustomApsSend_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_CUSTOM_OPS_ZCL_SEND: { + ZigbeeCustomZclSend_t *req = NULL; + + req = (ZigbeeCustomZclSend_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: { + ZigbeeCustomSendToLocal_t *req = NULL; + + req = (ZigbeeCustomSendToLocal_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + default: + break; + } +} + +static void __zblib_request_free_door_lock_request_data(ZigBeeRequest *request, + guint request_type) +{ + guint ops_id; + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: { + ZigbeeDoorLockSubscriberLockEvent_t *req = NULL; + + req = (ZigbeeDoorLockSubscriberLockEvent_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: { + ZigbeeDoorLockSetDoorLockPin_t *req = NULL; + + req = (ZigbeeDoorLockSetDoorLockPin_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: { + ZigbeeDoorLockSetDoorLock_t *req = NULL; + + req = (ZigbeeDoorLockSetDoorLock_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: { + ZigbeeDoorLockGetDoorLock_t *req = NULL; + + req = (ZigbeeDoorLockGetDoorLock_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + default: + break; + } +} + +static void __zblib_request_free_fan_control_request_data(ZigBeeRequest *request, + guint request_type) +{ + guint ops_id; + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE: { + ZigbeeFanControlSetFanMode_t *req = NULL; + + req = (ZigbeeFanControlSetFanMode_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: { + ZigbeeFanControlGetFanMode_t *req = NULL; + + req = (ZigbeeFanControlGetFanMode_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: { + ZigbeeFanControlSetFanModeSequence_t *req = NULL; + + req = (ZigbeeFanControlSetFanModeSequence_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: { + ZigbeeFanControlGetFanModeSequence_t *req = NULL; + + req = (ZigbeeFanControlGetFanModeSequence_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + default: + break; + } +} + +static void __zblib_request_free_level_control_request_data(ZigBeeRequest *request, + guint request_type) +{ + guint ops_id; + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: { + ZigbeeLevelControlMoveToLevel_t *req = NULL; + + req = (ZigbeeLevelControlMoveToLevel_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_MOVE: { + ZigbeeLevelControlMove_t *req = NULL; + + req = (ZigbeeLevelControlMove_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_STEP: { + ZigbeeLevelControlStep_t *req = NULL; + + req = (ZigbeeLevelControlStep_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: { + ZigbeeLevelControlMoveToLevelWithOnOff_t *req = NULL; + + req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: { + ZigbeeLevelControlMoveOnOff_t *req = NULL; + + req = (ZigbeeLevelControlMoveOnOff_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: { + ZigbeeLevelControlStepWithOnOff_t *req = NULL; + + req = (ZigbeeLevelControlStepWithOnOff_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_LEVEL_CONTROL_OPS_STOP: { + ZigbeeLevelControlStop_t *req = NULL; + + req = (ZigbeeLevelControlStop_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + default: + break; + } +} + +static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *request, + guint request_type) +{ + guint ops_id; + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_MFGLIB_CONTROL_OPS_START: { + ZigbeeMfglibControlStart_t *req = NULL; + + req = (ZigbeeMfglibControlStart_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_END: { + ZigbeeMfglibControlEnd_t *req = NULL; + + req = (ZigbeeMfglibControlEnd_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: { + ZigbeeMfglibControlStartTone_t *req = NULL; + + req = (ZigbeeMfglibControlStartTone_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: { + ZigbeeMfglibControlStopTone_t *req = NULL; + + req = (ZigbeeMfglibControlStopTone_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: { + ZigbeeMfglibControlStartStream_t *req = NULL; + + req = (ZigbeeMfglibControlStartStream_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: { + ZigbeeMfglibControlStopStream_t *req = NULL; + + req = (ZigbeeMfglibControlStopStream_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: { + ZigbeeMfglibControlSendPacket_t *req = NULL; + + req = (ZigbeeMfglibControlSendPacket_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: { + ZigbeeMfglibControlSetChannel_t *req = NULL; + + req = (ZigbeeMfglibControlSetChannel_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: { + ZigbeeMfglibControlGetChannel_t *req = NULL; + + req = (ZigbeeMfglibControlGetChannel_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: { + ZigbeeMfglibControlSetPower_t *req = NULL; + + req = (ZigbeeMfglibControlSetPower_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: { + ZigbeeMfglibControlGetPower_t *req = NULL; + + req = (ZigbeeMfglibControlGetPower_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: { + ZigbeeMfglibControlSetSynOffset_t *req = NULL; + + req = (ZigbeeMfglibControlSetSynOffset_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: { + ZigbeeMfglibControlGetSynOffset_t *req = NULL; + + req = (ZigbeeMfglibControlGetSynOffset_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: { + ZigbeeMfglibControlRxStart_t *req = NULL; + + req = (ZigbeeMfglibControlRxStart_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: { + ZigbeeMfglibControlRxStop_t *req = NULL; + + req = (ZigbeeMfglibControlRxStop_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: { + ZigbeeMfglibControlRxVerify_t *req = NULL; + + req = (ZigbeeMfglibControlRxVerify_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: { + ZigbeeMfglibControlGetRssi_t *req = NULL; + + req = (ZigbeeMfglibControlGetRssi_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + default: + break; + } +} + +static void __zblib_request_free_on_off_request_data(ZigBeeRequest *request, + guint request_type) +{ + guint ops_id; + + /* Fetch ops ID */ + ops_id = __zblib_request_get_ops_id(request_type); + switch (ops_id) { + case ZBLIB_ON_OFF_OPS_SET_ON_OFF: { + ZigbeeOnOffSetOnOff_t *req = NULL; + + req = (ZigbeeOnOffSetOnOff_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: { + ZigbeeOnOffGetOnOffState_t *req = NULL; + + req = (ZigbeeOnOffGetOnOffState_t *)request->request_data; + if (NULL != req) { + g_free(req); + } + } + break; + + default: + break; + } +} + +static void __zblib_request_free_service_request_data(ZigBeeRequest *request, + guint request_type) +{ guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { @@ -405,6 +3588,12 @@ static gpointer __zblib_request_create_service_request_data(guint request_type, break; case ZBLIB_SERVICE_OPS_COEX_START: { + ZigbeeServiceCoexStart_t *req = NULL; + + req = (ZigbeeServiceCoexStart_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; @@ -421,10 +3610,22 @@ static gpointer __zblib_request_create_service_request_data(guint request_type, break; case ZBLIB_SERVICE_OPS_PERMIT_JOIN: { + ZigbeeServicePermitJoin_t *req = NULL; + + req = (ZigbeeServicePermitJoin_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: { + ZigbeeServiceLeaveRequest_t *req = NULL; + + req = (ZigbeeServiceLeaveRequest_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; @@ -441,624 +3642,979 @@ static gpointer __zblib_request_create_service_request_data(guint request_type, break; case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: { + ZigbeeServiceGetEndpointList_t *req = NULL; + + req = (ZigbeeServiceGetEndpointList_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: { + ZigbeeServiceGetClusterList_t *req = NULL; + + req = (ZigbeeServiceGetClusterList_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: { + ZigbeeServiceGetNodeType_t *req = NULL; + + req = (ZigbeeServiceGetNodeType_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return service_request_data; } -static gpointer __zblib_request_create_thermostat_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_thermostat_request_data(ZigBeeRequest *request, + guint request_type) { - gpointer thermostat_request_data = NULL; guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP: { + ZigbeeThermostatGetLocalTemp_t *req = NULL; + + req = (ZigbeeThermostatGetLocalTemp_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: { + ZigbeeThermostatGetWeeklySchedule_t *req = NULL; + + req = (ZigbeeThermostatGetWeeklySchedule_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: { + ZigbeeThermostatSetWeeklySchedule_t *req = NULL; + + req = (ZigbeeThermostatSetWeeklySchedule_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: { + ZigbeeThermostatClearWeeklySchedule_t *req = NULL; + + req = (ZigbeeThermostatClearWeeklySchedule_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: { + ZigbeeThermostatSetpointRaiseLower_t *req = NULL; + + req = (ZigbeeThermostatSetpointRaiseLower_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return thermostat_request_data; } -static gpointer __zblib_request_create_zclbasic_control_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_zclbasic_control_request_data(ZigBeeRequest *request, + guint request_type) { - gpointer zclbasic_control_request_data = NULL; guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT: { + ZigbeeZclbasicControlResetFactoryDefault_t *req = NULL; + + req = (ZigbeeZclbasicControlResetFactoryDefault_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return zclbasic_control_request_data; } -static gpointer __zblib_request_create_zclglobal_control_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *request, + guint request_type) { - gpointer zclglobal_control_request_data = NULL; guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: { + ZigbeeZclglobalControlReadAttributesRequest_t *req = NULL; + + req = (ZigbeeZclglobalControlReadAttributesRequest_t *)request->request_data; + if (NULL != req) { + g_free(req->attribute_id); + g_free(req); + } } break; case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: { + ZigbeeZclglobalControlWriteAttributesRequest_t *req = NULL; + + req = (ZigbeeZclglobalControlWriteAttributesRequest_t *)request->request_data; + if (NULL != req) { + g_free(req->write_records); + g_free(req); + } } break; case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: { + ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *req = NULL; + + req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *)request->request_data; + if (NULL != req) { + g_free(req->write_records); + g_free(req); + } } break; case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: { + ZigbeeZclglobalControlWriteAttributesNoResponse_t *req = NULL; + + req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *)request->request_data; + if (NULL != req) { + g_free(req->write_records); + g_free(req); + } } break; case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: { + ZigbeeZclglobalControlWriteAttributesStructed_t *req = NULL; + + req = (ZigbeeZclglobalControlWriteAttributesStructed_t *)request->request_data; + if (NULL != req) { + g_free(req->write_records); + g_free(req); + } } break; case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: { + ZigbeeZclglobalControlReadAttributesStructed_t *req = NULL; + + req = (ZigbeeZclglobalControlReadAttributesStructed_t *)request->request_data; + if (NULL != req) { + g_free(req->read_records); + g_free(req); + } } break; case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: { + ZigbeeZclglobalControlConfigureReportingReq_t *req = NULL; + + req = (ZigbeeZclglobalControlConfigureReportingReq_t *)request->request_data; + if (NULL != req) { + g_free(req->read_records); + g_free(req); + } } break; case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: { + ZigbeeZclglobalControlReadConfigureReporting_t *req = NULL; + + req = (ZigbeeZclglobalControlReadConfigureReporting_t *)request->request_data; + if (NULL != req) { + g_free(req->read_records); + g_free(req); + } } break; case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: { + ZigbeeZclglobalControlDiscoverAttributes_t *req = NULL; + + req = (ZigbeeZclglobalControlDiscoverAttributes_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: { + ZigbeeZclglobalControlDiscoverAttributesExtended_t *req = NULL; + + req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: { + ZigbeeZclglobalControlDiscoverCommandsReceived_t *req = NULL; + + req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: { + ZigbeeZclglobalControlDiscoverCommandsGenerated_t *req = NULL; + + req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return zclglobal_control_request_data; } -static gpointer __zblib_request_create_zclias_control_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_zclias_control_request_data(ZigBeeRequest *request, + guint request_type) { - gpointer zclias_control_request_data = NULL; guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE: { + ZigbeeZcliasControlEnrolResponse_t *req = NULL; + + req = (ZigbeeZcliasControlEnrolResponse_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return zclias_control_request_data; } -static gpointer __zblib_request_create_zclidentify_control_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_zclidentify_control_request_data(ZigBeeRequest *request, + guint request_type) { - gpointer zclidentify_control_request_data = NULL; guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY: { + ZigbeeZclidentifyControlIdentify_t *req = NULL; + + req = (ZigbeeZclidentifyControlIdentify_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: { + ZigbeeZclidentifyControlQuery_t *req = NULL; + + req = (ZigbeeZclidentifyControlQuery_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return zclidentify_control_request_data; } -static gpointer __zblib_request_create_zcl_color_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_zcl_color_request_data(ZigBeeRequest *request, + guint request_type) { - gpointer zcl_color_request_data = NULL; guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE: { + ZigbeeZclColorMoveToHue_t *req = NULL; + + req = (ZigbeeZclColorMoveToHue_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: { + ZigbeeZclColorMoveHue_t *req = NULL; + + req = (ZigbeeZclColorMoveHue_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: { + ZigbeeZclColorStepHue_t *req = NULL; + + req = (ZigbeeZclColorStepHue_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: { + ZigbeeZclColorMoveToSaturation_t *req = NULL; + + req = (ZigbeeZclColorMoveToSaturation_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: { + ZigbeeZclColorMoveSaturation_t *req = NULL; + + req = (ZigbeeZclColorMoveSaturation_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: { + ZigbeeZclColorStepSaturation_t *req = NULL; + + req = (ZigbeeZclColorStepSaturation_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: { + ZigbeeZclColorMoveToHueAndSaturation_t *req = NULL; + + req = (ZigbeeZclColorMoveToHueAndSaturation_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: { + ZigbeeZclColorMoveToColor_t *req = NULL; + + req = (ZigbeeZclColorMoveToColor_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: { + ZigbeeZclColorMoveColor_t *req = NULL; + + req = (ZigbeeZclColorMoveColor_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: { + ZigbeeZclColorStepColor_t *req = NULL; + + req = (ZigbeeZclColorStepColor_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: { + ZigbeeZclColorMoveColorTemperature_t *req = NULL; + + req = (ZigbeeZclColorMoveColorTemperature_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return zcl_color_request_data; } -static gpointer __zblib_request_create_zcl_group_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request, + guint request_type) { - gpointer zcl_group_request_data = NULL; guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: { + ZigbeeZclGroupAddGroup_t *req = NULL; + + req = (ZigbeeZclGroupAddGroup_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: { + ZigbeeZclGroupViewGroup_t *req = NULL; + + req = (ZigbeeZclGroupViewGroup_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: { + ZigbeeZclGroupGetGroupMembership_t *req = NULL; + + req = (ZigbeeZclGroupGetGroupMembership_t *)request->request_data; + if (NULL != req) { + g_free(req->group_list); + g_free(req); + } } break; case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: { + ZigbeeZclGroupRemoveGroup_t *req = NULL; + + req = (ZigbeeZclGroupRemoveGroup_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: { + ZigbeeZclGroupRemoveAllGroup_t *req = NULL; + + req = (ZigbeeZclGroupRemoveAllGroup_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: { + ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL; + + req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return zcl_group_request_data; } -static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *request, + guint request_type) { - gpointer zcl_poll_control_request_data = NULL; guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: { + ZigbeeZclPollControlCheckInResponse_t *req = NULL; + + req = (ZigbeeZclPollControlCheckInResponse_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: { + ZigbeeZclPollControlFastPollStop_t *req = NULL; + + req = (ZigbeeZclPollControlFastPollStop_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: { + ZigbeeZclPollControlSetLongPollInterval_t *req = NULL; + + req = (ZigbeeZclPollControlSetLongPollInterval_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: { + ZigbeeZclPollControlSetShortPollInterval_t *req = NULL; + + req = (ZigbeeZclPollControlSetShortPollInterval_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return zcl_poll_control_request_data; } -static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request, + guint request_type) { - gpointer zcl_scene_request_data = NULL; guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: { + ZigbeeZclSceneAddScene_t *req = NULL; + + req = (ZigbeeZclSceneAddScene_t *)request->request_data; + if (NULL != req) { + g_free(req->ext_field_set); + g_free(req); + } } break; case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: { + ZigbeeZclSceneViewScene_t *req = NULL; + + req = (ZigbeeZclSceneViewScene_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: { + ZigbeeZclSceneRemoveScene_t *req = NULL; + + req = (ZigbeeZclSceneRemoveScene_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: { + ZigbeeZclSceneStoreScene_t *req = NULL; + + req = (ZigbeeZclSceneStoreScene_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: { + ZigbeeZclSceneRecallScene_t *req = NULL; + + req = (ZigbeeZclSceneRecallScene_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: { + ZigbeeZclSceneRemoveAllScene_t *req = NULL; + + req = (ZigbeeZclSceneRemoveAllScene_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: { + ZigbeeZclSceneGetSceneMembership_t *req = NULL; + + req = (ZigbeeZclSceneGetSceneMembership_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return zcl_scene_request_data; } -static gpointer __zblib_request_create_zdodev_control_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_zdodev_control_request_data(ZigBeeRequest *request, + guint request_type) { - gpointer zdodev_control_request_data = NULL; guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ: { + ZigbeeZdodevControlNwkAddrReq_t *req = NULL; + + req = (ZigbeeZdodevControlNwkAddrReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: { + ZigbeeZdodevControlMatchedDescriptorReq_t *req = NULL; + + req = (ZigbeeZdodevControlMatchedDescriptorReq_t *)request->request_data; + if (NULL != req) { + g_free(req->in_cl); + g_free(req->out_cl); + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: { + ZigbeeZdodevControlIeeeAddrReq_t *req = NULL; + + req = (ZigbeeZdodevControlIeeeAddrReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: { + ZigbeeZdodevControlActiveEpReq_t *req = NULL; + + req = (ZigbeeZdodevControlActiveEpReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: { + ZigbeeZdodevControlNodeDescriptorReq_t *req = NULL; + + req = (ZigbeeZdodevControlNodeDescriptorReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: { + ZigbeeZdodevControlPowerDescriptorReq_t *req = NULL; + + req = (ZigbeeZdodevControlPowerDescriptorReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: { + ZigbeeZdodevControlComplexDescriptorReq_t *req = NULL; + + req = (ZigbeeZdodevControlComplexDescriptorReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: { + ZigbeeZdodevControlUserDescriptorReq_t *req = NULL; + + req = (ZigbeeZdodevControlUserDescriptorReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: { + ZigbeeZdodevControlUserDescriptorSetReq_t *req = NULL; + + req = (ZigbeeZdodevControlUserDescriptorSetReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: { + ZigbeeZdodevControlDeviceAnnounce_t *req = NULL; + + req = (ZigbeeZdodevControlDeviceAnnounce_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: { + ZigbeeZdodevControlSimpleDescriptorReq_t *req = NULL; + + req = (ZigbeeZdodevControlSimpleDescriptorReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: { + ZigbeeZdodevControlMgmtLqiReq_t *req = NULL; + + req = (ZigbeeZdodevControlMgmtLqiReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: { + ZigbeeZdodevControlMgmtRtgReq_t *req = NULL; + + req = (ZigbeeZdodevControlMgmtRtgReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: { + ZigbeeZdodevControlMgmtBindReq_t *req = NULL; + + req = (ZigbeeZdodevControlMgmtBindReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: { + ZigbeeZdodevControlMgmtPermitJoinReq_t *req = NULL; + + req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: { + ZigbeeZdodevControlNwkUpdateReq_t *req = NULL; + + req = (ZigbeeZdodevControlNwkUpdateReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: { + ZigbeeZdodevControlNwkDescriptorReq_t *req = NULL; + + req = (ZigbeeZdodevControlNwkDescriptorReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return zdodev_control_request_data; } -static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_zdo_bind_request_data(ZigBeeRequest *request, + guint request_type) { - gpointer zdo_bind_request_data = NULL; guint ops_id; - NOT_USED(request_data); - NOT_USED(request_data_len); - /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { case ZBLIB_ZDO_BIND_OPS_BIND_REQ: { + ZigbeeZdoBindBindReq_t *req = NULL; + + req = (ZigbeeZdoBindBindReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: { + ZigbeeZdoBindUnbindReq_t *req = NULL; + + req = (ZigbeeZdoBindUnbindReq_t *)request->request_data; + if (NULL != req) { + g_free(req); + } } break; default: break; } - - return zdo_bind_request_data; } -static gpointer __zblib_request_create_request_data(guint request_type, - gpointer request_data, guint request_data_len) +static void __zblib_request_free_request_data(ZigBeeRequest *request) { - gpointer _request_data = NULL; + guint request_type; ZblibDriverType_e driver_type; + zblib_check_null_ret("request", request); + + request_type = request->request_type; + /* Fetch driver type */ driver_type = __zblib_request_get_driver_type(request_type); switch (driver_type) { case ZBLIB_DRIVER_TYPE_ALARM: { - _request_data = __zblib_request_create_alarm_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_alarm_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_CUSTOM: { - _request_data = __zblib_request_create_custom_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_custom_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_DOOR_LOCK: { - _request_data = __zblib_request_create_door_lock_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_door_lock_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_FAN_CONTROL: { - _request_data = __zblib_request_create_fan_control_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_fan_control_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_LEVEL_CONTROL: { - _request_data = __zblib_request_create_level_control_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_level_control_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: { - _request_data = __zblib_request_create_mfglib_control_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_mfglib_control_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_ON_OFF: { - _request_data = __zblib_request_create_on_off_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_on_off_request_data(request, request_type); } break; + case ZBLIB_DRIVER_TYPE_SERVICE: { - _request_data = __zblib_request_create_service_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_service_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_THERMOSTAT: { - _request_data = __zblib_request_create_thermostat_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_thermostat_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL: { - _request_data = __zblib_request_create_zclbasic_control_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_zclbasic_control_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL: { - _request_data = __zblib_request_create_zclglobal_control_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_zclglobal_control_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL: { - _request_data = __zblib_request_create_zclias_control_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_zclias_control_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL: { - _request_data = __zblib_request_create_zclidentify_control_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_zclidentify_control_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_ZCL_COLOR: { - _request_data = __zblib_request_create_zcl_color_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_zcl_color_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_ZCL_GROUP: { - _request_data = __zblib_request_create_zcl_group_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_zcl_group_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: { - _request_data = __zblib_request_create_zcl_poll_control_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_zcl_poll_control_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_ZCL_SCENE: { - _request_data = __zblib_request_create_zcl_scene_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_zcl_scene_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL: { - _request_data = __zblib_request_create_zdodev_control_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_zdodev_control_request_data(request, request_type); } break; case ZBLIB_DRIVER_TYPE_ZDO_BIND: { - _request_data = __zblib_request_create_zdo_bind_request_data(request_type, - request_data, request_data_len); + __zblib_request_free_zdo_bind_request_data(request, request_type); } break; @@ -1068,19 +4624,6 @@ static gpointer __zblib_request_create_request_data(guint request_type, } break; } - - return _request_data; -} - -static void __zblib_request_free_request_data(gpointer request_data) -{ - if (NULL == request_data) { - Z_LOGE("request_data is NULL"); - return; - } - - /* Free resources */ - g_free(request_data); } gint zblib_request_new(ZigBeeServiceInterface *service_interface, @@ -1090,16 +4633,10 @@ gint zblib_request_new(ZigBeeServiceInterface *service_interface, ZigBeeRequest *request = NULL; GHashTable *request_table = NULL; - if (NULL == service_interface) { - Z_LOGE("service_interface is NULL"); - return ZIGBEE_REQUEST_INVALID_REQUEST_ID; - } + zblib_check_null_ret_error("service_interface", service_interface, ZIGBEE_REQUEST_INVALID_REQUEST_ID); service = zblib_service_interface_ref_service(service_interface); - if (NULL == service) { - Z_LOGE("service is NULL"); - return ZIGBEE_REQUEST_INVALID_REQUEST_ID; - } + zblib_check_null_ret_error("service", service, ZIGBEE_REQUEST_INVALID_REQUEST_ID); /* Allocate ZigBee request memory */ request = g_malloc0(sizeof(ZigBeeRequest)); @@ -1141,24 +4678,28 @@ gint zblib_request_new(ZigBeeServiceInterface *service_interface, return request->request_id; } -void zblib_request_free(ZigBeeRequest *request) +void zblib_request_free(ZigBeeServiceInterface *service_interface, + guint request_id) { - if (NULL == request) { - Z_LOGE("request is NULL"); - return; - } + ZigBeeService *service = NULL; + ZigBeeRequest *request = NULL; + + zblib_check_null_ret("service_interface", service_interface); + + service = zblib_service_interface_ref_service(service_interface); + zblib_check_null_ret("service", service); + + request = __zblib_request_ref_request_by_request_id(service, request_id); + zblib_check_null_ret("request", request); /* Free resources */ - __zblib_request_free_request_data(request->request_data); + __zblib_request_free_request_data(request); g_free(request); } ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request) { - if (NULL == request) { - Z_LOGE("request is NULL"); - return request; - } + zblib_check_null_ret_error("request", request, NULL); request->ref_count++; @@ -1167,36 +4708,28 @@ ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request) void zblib_request_unref(ZigBeeRequest *request) { - if (NULL == request) { - Z_LOGE("request is NULL"); - return; - } + zblib_check_null_ret("request", request); request->ref_count--; if (0 == request->ref_count) { Z_LOGD("Reference count is ZERO!"); /* Free 'request' */ - zblib_request_free(request); + __zblib_request_free_request_data(request); + g_free(request); } } guint zblib_request_ref_request_type(ZigBeeRequest *request) { - if (NULL == request) { - Z_LOGE("request is NULL"); - return 0; - } + zblib_check_null_ret_error("request", request, 0); return request->request_type; } ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeRequest *request) { - if (NULL == request) { - Z_LOGE("request is NULL"); - return NULL; - } + zblib_check_null_ret_error("request", request, NULL); return request->service_interface; } @@ -1228,24 +4761,7 @@ guint zblib_request_generate_request_type(ZblibDriverType_e driver_type, gint zblib_request_ref_request_type_by_request_id(ZigBeeService *service, guint request_id) { - ZigBeeRequest *request = NULL; - GHashTable *request_table = NULL; - - /* Fetch request table from service */ - request_table = zblib_service_ref_request_hash_table(service); - if (NULL == request_table) { - Z_LOGE("zblib_service_ref_request_hash_table failed!"); - return -1; - } - - /* Look-up requets_id in request hash table */ - request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id); - if (NULL == request_table) { - Z_LOGE("No request availabel for request_id: [%d]", request_id); - return -1; - } - - return (gint)(request->request_type); + return __zblib_request_ref_request_type_by_request_id(service, request_id); } ZblibDriverType_e zblib_request_get_driver_type(guint request_type) -- 2.7.4