X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=zigbee-daemon%2Fzigbee-lib%2Fsrc%2Fzblib_request.c;h=f23f3e53bb2615262f19e4f059fda20437de3002;hb=refs%2Ftags%2Ftizen_4.0.m1_release;hp=43392a6412fa3655f902604cf2156cda2d2b1d0b;hpb=a0765c2d81a26721108c6bfc1ba109463a9f0067;p=platform%2Fcore%2Fconnectivity%2Fzigbee-manager.git diff --git a/zigbee-daemon/zigbee-lib/src/zblib_request.c b/zigbee-daemon/zigbee-lib/src/zblib_request.c index 43392a6..f23f3e5 100644 --- a/zigbee-daemon/zigbee-lib/src/zblib_request.c +++ b/zigbee-daemon/zigbee-lib/src/zblib_request.c @@ -22,25 +22,25 @@ #include #include -#include #include -#include -#include -#include #include -#include #include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include #include +#include +#include +#include +#include #include #include -#include +#include #include +#include /**< ZigBee Request object */ struct zblib_request_type { @@ -59,7 +59,7 @@ static ZblibDriverType_e __zblib_request_get_driver_type(guint request_type) { ZblibDriverType_e driver_type; - driver_type = ((request_type && 0xFF000000) >> 24); + driver_type = ((request_type & 0xFF000000) >> 24); return driver_type; } @@ -68,7 +68,7 @@ static ZblibDriverType_e __zblib_request_get_ops_id(guint request_type) { guint ops_id; - ops_id = (request_type && 0x000000FF); + ops_id = (request_type & 0x000000FF); return ops_id; } @@ -87,7 +87,7 @@ static ZigBeeRequest *__zblib_request_ref_request_by_by_request_id(ZigBeeService } /* Look-up requets_id in request hash table */ - request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id); + request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)GUINT_TO_POINTER(request_id)); if (NULL == request) { Z_LOGE("No request available for request_id: [%d]", request_id); return NULL; @@ -125,16 +125,16 @@ static ZigBeeRequest *__zblib_request_ref_request_by_request_id(ZigBeeService *s } /* 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); + request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)GUINT_TO_POINTER(request_id)); + if (NULL == request) { + Z_LOGE("No request available for request_id: [%d]", request_id); return NULL; } return request; } -static gpointer __zblib_request_create_alarm_request_data(guint request_type, +static gpointer __zblib_request_create_zcl_alarm_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer alarm_request_data = NULL; @@ -145,15 +145,15 @@ static gpointer __zblib_request_create_alarm_request_data(guint request_type, /* 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; + case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: { + ZigbeeZclAlarmGetAlarmCount_t *in_req; + ZigbeeZclAlarmGetAlarmCount_t *req = NULL; - in_req = (ZigbeeAlarmGetAlarmCount_t *)request_data; + in_req = (ZigbeeZclAlarmGetAlarmCount_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeAlarmGetAlarmCount_t *) - g_malloc0(sizeof(ZigbeeAlarmGetAlarmCount_t)); + req = (ZigbeeZclAlarmGetAlarmCount_t *) + g_malloc0(sizeof(ZigbeeZclAlarmGetAlarmCount_t)); /* Copy data */ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); @@ -164,15 +164,15 @@ static gpointer __zblib_request_create_alarm_request_data(guint request_type, } break; - case ZBLIB_ALARM_OPS_RESET_ALARM: { - ZigbeeAlarmResetAlarm_t *in_req; - ZigbeeAlarmResetAlarm_t *req = NULL; + case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: { + ZigbeeZclAlarmResetAlarm_t *in_req; + ZigbeeZclAlarmResetAlarm_t *req = NULL; - in_req = (ZigbeeAlarmResetAlarm_t *)request_data; + in_req = (ZigbeeZclAlarmResetAlarm_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeAlarmResetAlarm_t *) - g_malloc0(sizeof(ZigbeeAlarmResetAlarm_t)); + req = (ZigbeeZclAlarmResetAlarm_t *) + g_malloc0(sizeof(ZigbeeZclAlarmResetAlarm_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -185,15 +185,15 @@ static gpointer __zblib_request_create_alarm_request_data(guint request_type, } break; - case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: { - ZigbeeAlarmResetAllAlarm_t *in_req; - ZigbeeAlarmResetAllAlarm_t *req = NULL; + case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: { + ZigbeeZclAlarmResetAllAlarm_t *in_req; + ZigbeeZclAlarmResetAllAlarm_t *req = NULL; - in_req = (ZigbeeAlarmResetAllAlarm_t *)request_data; + in_req = (ZigbeeZclAlarmResetAllAlarm_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeAlarmResetAllAlarm_t *) - g_malloc0(sizeof(ZigbeeAlarmResetAllAlarm_t)); + req = (ZigbeeZclAlarmResetAllAlarm_t *) + g_malloc0(sizeof(ZigbeeZclAlarmResetAllAlarm_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -204,15 +204,15 @@ static gpointer __zblib_request_create_alarm_request_data(guint request_type, } break; - case ZBLIB_ALARM_OPS_ALARM: { - ZigbeeAlarmAlarm_t *in_req; - ZigbeeAlarmAlarm_t *req = NULL; + case ZBLIB_ZCL_ALARM_OPS_ALARM: { + ZigbeeZclAlarmAlarm_t *in_req; + ZigbeeZclAlarmAlarm_t *req = NULL; - in_req = (ZigbeeAlarmAlarm_t *)request_data; + in_req = (ZigbeeZclAlarmAlarm_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeAlarmAlarm_t *) - g_malloc0(sizeof(ZigbeeAlarmAlarm_t)); + req = (ZigbeeZclAlarmAlarm_t *) + g_malloc0(sizeof(ZigbeeZclAlarmAlarm_t)); /* Copy data */ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); @@ -225,15 +225,15 @@ static gpointer __zblib_request_create_alarm_request_data(guint request_type, } break; - case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: { - ZigbeeAlarmResetAlarmLogs_t *in_req; - ZigbeeAlarmResetAlarmLogs_t *req = NULL; + case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: { + ZigbeeZclAlarmResetAlarmLogs_t *in_req; + ZigbeeZclAlarmResetAlarmLogs_t *req = NULL; - in_req = (ZigbeeAlarmResetAlarmLogs_t *)request_data; + in_req = (ZigbeeZclAlarmResetAlarmLogs_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeAlarmResetAlarmLogs_t *) - g_malloc0(sizeof(ZigbeeAlarmResetAlarmLogs_t)); + req = (ZigbeeZclAlarmResetAlarmLogs_t *) + g_malloc0(sizeof(ZigbeeZclAlarmResetAlarmLogs_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -244,8 +244,22 @@ static gpointer __zblib_request_create_alarm_request_data(guint request_type, } break; - case ZBLIB_ALARM_OPS_GET_ALARM: { - alarm_request_data = NULL; + case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: { + ZigbeeZclAlarmGetAlarm_t *in_req; + ZigbeeZclAlarmGetAlarm_t *req = NULL; + + in_req = (ZigbeeZclAlarmGetAlarm_t *)request_data; + if (in_req) { + /* Allocate memory */ + req = (ZigbeeZclAlarmGetAlarm_t *) + g_malloc0(sizeof(ZigbeeZclAlarmGetAlarm_t)); + + /* Copy data */ + req->node_id = in_req->node_id; + req->endpoint = in_req->endpoint; + } + + alarm_request_data = (gpointer)req; } break; @@ -286,8 +300,10 @@ static gpointer __zblib_request_create_custom_request_data(guint request_type, req->profile_id = in_req->profile_id; req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; req->mfg_code = in_req->mfg_code; + req->cmd_id = in_req->cmd_id; + req->payload_len = in_req->payload_len; memcpy(req->payload, - in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN); + in_req->payload, req->payload_len); } custom_request_data = (gpointer)req; @@ -311,8 +327,9 @@ static gpointer __zblib_request_create_custom_request_data(guint request_type, req->cluster_id = in_req->cluster_id; req->zcl_frame_ctrl = in_req->zcl_frame_ctrl; req->cmd_id = in_req->cmd_id; + req->payload_len = in_req->payload_len; memcpy(req->payload, - in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN); + in_req->payload, req->payload_len); } custom_request_data = (gpointer)req; @@ -330,8 +347,9 @@ static gpointer __zblib_request_create_custom_request_data(guint request_type, g_malloc0(sizeof(ZigbeeCustomSendToLocal_t)); /* Copy data */ + req->length = in_req->length; memcpy(req->data, - in_req->data, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN); + in_req->data, req->length); } custom_request_data = (gpointer)req; @@ -345,7 +363,7 @@ static gpointer __zblib_request_create_custom_request_data(guint request_type, return custom_request_data; } -static gpointer __zblib_request_create_door_lock_request_data(guint request_type, +static gpointer __zblib_request_create_zcl_door_lock_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer door_lock_request_data = NULL; @@ -356,15 +374,15 @@ static gpointer __zblib_request_create_door_lock_request_data(guint request_type /* 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; + case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: { + ZigbeeZclDoorLockSubscriberLockEvent_t *in_req; + ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL; - in_req = (ZigbeeDoorLockSubscriberLockEvent_t *)request_data; + in_req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeDoorLockSubscriberLockEvent_t *) - g_malloc0(sizeof(ZigbeeDoorLockSubscriberLockEvent_t)); + req = (ZigbeeZclDoorLockSubscriberLockEvent_t *) + g_malloc0(sizeof(ZigbeeZclDoorLockSubscriberLockEvent_t)); /* Copy data */ memcpy(req->eui64, @@ -376,15 +394,15 @@ static gpointer __zblib_request_create_door_lock_request_data(guint request_type } break; - case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: { - ZigbeeDoorLockSetDoorLockPin_t *in_req; - ZigbeeDoorLockSetDoorLockPin_t *req = NULL; + case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: { + ZigbeeZclDoorLockSetDoorLockPin_t *in_req; + ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL; - in_req = (ZigbeeDoorLockSetDoorLockPin_t *)request_data; + in_req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeDoorLockSetDoorLockPin_t *) - g_malloc0(sizeof(ZigbeeDoorLockSetDoorLockPin_t)); + req = (ZigbeeZclDoorLockSetDoorLockPin_t *) + g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLockPin_t)); /* Copy data */ req->uid = in_req->uid; @@ -401,15 +419,15 @@ static gpointer __zblib_request_create_door_lock_request_data(guint request_type } break; - case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: { - ZigbeeDoorLockSetDoorLock_t *in_req; - ZigbeeDoorLockSetDoorLock_t *req = NULL; + case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: { + ZigbeeZclDoorLockSetDoorLock_t *in_req; + ZigbeeZclDoorLockSetDoorLock_t *req = NULL; - in_req = (ZigbeeDoorLockSetDoorLock_t *)request_data; + in_req = (ZigbeeZclDoorLockSetDoorLock_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeDoorLockSetDoorLock_t *) - g_malloc0(sizeof(ZigbeeDoorLockSetDoorLock_t)); + req = (ZigbeeZclDoorLockSetDoorLock_t *) + g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLock_t)); /* Copy data */ memcpy(req->eui64, @@ -424,15 +442,15 @@ static gpointer __zblib_request_create_door_lock_request_data(guint request_type } break; - case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: { - ZigbeeDoorLockGetDoorLock_t *in_req; - ZigbeeDoorLockGetDoorLock_t *req = NULL; + case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: { + ZigbeeZclDoorLockGetDoorLock_t *in_req; + ZigbeeZclDoorLockGetDoorLock_t *req = NULL; - in_req = (ZigbeeDoorLockGetDoorLock_t *)request_data; + in_req = (ZigbeeZclDoorLockGetDoorLock_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeDoorLockGetDoorLock_t *) - g_malloc0(sizeof(ZigbeeDoorLockGetDoorLock_t)); + req = (ZigbeeZclDoorLockGetDoorLock_t *) + g_malloc0(sizeof(ZigbeeZclDoorLockGetDoorLock_t)); /* Copy data */ memcpy(req->eui64, @@ -451,7 +469,7 @@ static gpointer __zblib_request_create_door_lock_request_data(guint request_type return door_lock_request_data; } -static gpointer __zblib_request_create_fan_control_request_data(guint request_type, +static gpointer __zblib_request_create_zcl_fan_control_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer fan_control_request_data = NULL; @@ -462,15 +480,15 @@ static gpointer __zblib_request_create_fan_control_request_data(guint request_ty /* 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; + case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: { + ZigbeeZclFanControlSetFanMode_t *in_req; + ZigbeeZclFanControlSetFanMode_t *req = NULL; - in_req = (ZigbeeFanControlSetFanMode_t *)request_data; + in_req = (ZigbeeZclFanControlSetFanMode_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeFanControlSetFanMode_t *) - g_malloc0(sizeof(ZigbeeFanControlSetFanMode_t)); + req = (ZigbeeZclFanControlSetFanMode_t *) + g_malloc0(sizeof(ZigbeeZclFanControlSetFanMode_t)); /* Copy data */ memcpy(req->eui64, @@ -482,15 +500,15 @@ static gpointer __zblib_request_create_fan_control_request_data(guint request_ty } break; - case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: { - ZigbeeFanControlGetFanMode_t *in_req; - ZigbeeFanControlGetFanMode_t *req = NULL; + case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: { + ZigbeeZclFanControlGetFanMode_t *in_req; + ZigbeeZclFanControlGetFanMode_t *req = NULL; - in_req = (ZigbeeFanControlGetFanMode_t *)request_data; + in_req = (ZigbeeZclFanControlGetFanMode_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeFanControlGetFanMode_t *) - g_malloc0(sizeof(ZigbeeFanControlGetFanMode_t)); + req = (ZigbeeZclFanControlGetFanMode_t *) + g_malloc0(sizeof(ZigbeeZclFanControlGetFanMode_t)); /* Copy data */ memcpy(req->eui64, @@ -502,15 +520,15 @@ static gpointer __zblib_request_create_fan_control_request_data(guint request_ty } break; - case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: { - ZigbeeFanControlSetFanModeSequence_t *in_req; - ZigbeeFanControlSetFanModeSequence_t *req = NULL; + case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: { + ZigbeeZclFanControlSetFanModeSequence_t *in_req; + ZigbeeZclFanControlSetFanModeSequence_t *req = NULL; - in_req = (ZigbeeFanControlSetFanModeSequence_t *)request_data; + in_req = (ZigbeeZclFanControlSetFanModeSequence_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeFanControlSetFanModeSequence_t *) - g_malloc0(sizeof(ZigbeeFanControlSetFanModeSequence_t)); + req = (ZigbeeZclFanControlSetFanModeSequence_t *) + g_malloc0(sizeof(ZigbeeZclFanControlSetFanModeSequence_t)); /* Copy data */ memcpy(req->eui64, @@ -522,15 +540,15 @@ static gpointer __zblib_request_create_fan_control_request_data(guint request_ty } break; - case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: { - ZigbeeFanControlGetFanModeSequence_t *in_req; - ZigbeeFanControlGetFanModeSequence_t *req = NULL; + case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: { + ZigbeeZclFanControlGetFanModeSequence_t *in_req; + ZigbeeZclFanControlGetFanModeSequence_t *req = NULL; - in_req = (ZigbeeFanControlGetFanModeSequence_t *)request_data; + in_req = (ZigbeeZclFanControlGetFanModeSequence_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeFanControlGetFanModeSequence_t *) - g_malloc0(sizeof(ZigbeeFanControlGetFanModeSequence_t)); + req = (ZigbeeZclFanControlGetFanModeSequence_t *) + g_malloc0(sizeof(ZigbeeZclFanControlGetFanModeSequence_t)); /* Copy data */ memcpy(req->eui64, @@ -549,7 +567,7 @@ static gpointer __zblib_request_create_fan_control_request_data(guint request_ty return fan_control_request_data; } -static gpointer __zblib_request_create_level_control_request_data(guint request_type, +static gpointer __zblib_request_create_zcl_level_control_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer level_control_request_data = NULL; @@ -560,15 +578,15 @@ static gpointer __zblib_request_create_level_control_request_data(guint request_ /* 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; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: { + ZigbeeZclLevelControlMoveToLevel_t *in_req; + ZigbeeZclLevelControlMoveToLevel_t *req = NULL; - in_req = (ZigbeeLevelControlMoveToLevel_t *)request_data; + in_req = (ZigbeeZclLevelControlMoveToLevel_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeLevelControlMoveToLevel_t *) - g_malloc0(sizeof(ZigbeeLevelControlMoveToLevel_t)); + req = (ZigbeeZclLevelControlMoveToLevel_t *) + g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevel_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -581,15 +599,15 @@ static gpointer __zblib_request_create_level_control_request_data(guint request_ } break; - case ZBLIB_LEVEL_CONTROL_OPS_MOVE: { - ZigbeeLevelControlMove_t *in_req; - ZigbeeLevelControlMove_t *req = NULL; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: { + ZigbeeZclLevelControlMove_t *in_req; + ZigbeeZclLevelControlMove_t *req = NULL; - in_req = (ZigbeeLevelControlMove_t *)request_data; + in_req = (ZigbeeZclLevelControlMove_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeLevelControlMove_t *) - g_malloc0(sizeof(ZigbeeLevelControlMove_t)); + req = (ZigbeeZclLevelControlMove_t *) + g_malloc0(sizeof(ZigbeeZclLevelControlMove_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -602,21 +620,21 @@ static gpointer __zblib_request_create_level_control_request_data(guint request_ } break; - case ZBLIB_LEVEL_CONTROL_OPS_STEP: { - ZigbeeLevelControlStep_t *in_req; - ZigbeeLevelControlStep_t *req = NULL; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: { + ZigbeeZclLevelControlStep_t *in_req; + ZigbeeZclLevelControlStep_t *req = NULL; - in_req = (ZigbeeLevelControlStep_t *)request_data; + in_req = (ZigbeeZclLevelControlStep_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeLevelControlStep_t *) - g_malloc0(sizeof(ZigbeeLevelControlStep_t)); + req = (ZigbeeZclLevelControlStep_t *) + g_malloc0(sizeof(ZigbeeZclLevelControlStep_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->step_size = in_req->step_size; req->transition_time = in_req->transition_time; } @@ -624,15 +642,15 @@ static gpointer __zblib_request_create_level_control_request_data(guint request_ } break; - case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: { - ZigbeeLevelControlMoveToLevelWithOnOff_t *in_req; - ZigbeeLevelControlMoveToLevelWithOnOff_t *req = NULL; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: { + ZigbeeZclLevelControlMoveToLevelWithOnOff_t *in_req; + ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL; - in_req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *)request_data; + in_req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *) - g_malloc0(sizeof(ZigbeeLevelControlMoveToLevelWithOnOff_t)); + req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *) + g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevelWithOnOff_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -645,15 +663,15 @@ static gpointer __zblib_request_create_level_control_request_data(guint request_ } break; - case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: { - ZigbeeLevelControlMoveWithOnOff_t *in_req; - ZigbeeLevelControlMoveWithOnOff_t *req = NULL; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: { + ZigbeeZclLevelControlMoveWithOnOff_t *in_req; + ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL; - in_req = (ZigbeeLevelControlMoveWithOnOff_t *)request_data; + in_req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeLevelControlMoveWithOnOff_t *) - g_malloc0(sizeof(ZigbeeLevelControlMoveWithOnOff_t)); + req = (ZigbeeZclLevelControlMoveWithOnOff_t *) + g_malloc0(sizeof(ZigbeeZclLevelControlMoveWithOnOff_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -666,21 +684,21 @@ static gpointer __zblib_request_create_level_control_request_data(guint request_ } break; - case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: { - ZigbeeLevelControlStepWithOnOff_t *in_req; - ZigbeeLevelControlStepWithOnOff_t *req = NULL; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: { + ZigbeeZclLevelControlStepWithOnOff_t *in_req; + ZigbeeZclLevelControlStepWithOnOff_t *req = NULL; - in_req = (ZigbeeLevelControlStepWithOnOff_t *)request_data; + in_req = (ZigbeeZclLevelControlStepWithOnOff_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeLevelControlStepWithOnOff_t *) - g_malloc0(sizeof(ZigbeeLevelControlStepWithOnOff_t)); + req = (ZigbeeZclLevelControlStepWithOnOff_t *) + g_malloc0(sizeof(ZigbeeZclLevelControlStepWithOnOff_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->step_size = in_req->step_size; req->transition_time = in_req->transition_time; } @@ -688,15 +706,15 @@ static gpointer __zblib_request_create_level_control_request_data(guint request_ } break; - case ZBLIB_LEVEL_CONTROL_OPS_STOP: { - ZigbeeLevelControlStop_t *in_req; - ZigbeeLevelControlStop_t *req = NULL; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: { + ZigbeeZclLevelControlStop_t *in_req; + ZigbeeZclLevelControlStop_t *req = NULL; - in_req = (ZigbeeLevelControlStop_t *)request_data; + in_req = (ZigbeeZclLevelControlStop_t *)request_data; if (in_req) { /* Allocate memory */ - req = (ZigbeeLevelControlStop_t *) - g_malloc0(sizeof(ZigbeeLevelControlStop_t)); + req = (ZigbeeZclLevelControlStop_t *) + g_malloc0(sizeof(ZigbeeZclLevelControlStop_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1051,7 +1069,7 @@ static gpointer __zblib_request_create_mfglib_control_request_data(guint request return mfglib_control_request_data; } -static gpointer __zblib_request_create_on_off_request_data(guint request_type, +static gpointer __zblib_request_create_zcl_on_off_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer on_off_request_data = NULL; @@ -1062,15 +1080,15 @@ static gpointer __zblib_request_create_on_off_request_data(guint request_type, /* 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; + case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: { + ZigbeeZclOnOffSetOnOff_t *in_req; + ZigbeeZclOnOffSetOnOff_t *req = NULL; - in_req = (ZigbeeOnOffSetOnOff_t *)request_data; + in_req = (ZigbeeZclOnOffSetOnOff_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeOnOffSetOnOff_t *) - g_malloc0(sizeof(ZigbeeOnOffSetOnOff_t)); + req = (ZigbeeZclOnOffSetOnOff_t *) + g_malloc0(sizeof(ZigbeeZclOnOffSetOnOff_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1082,15 +1100,15 @@ static gpointer __zblib_request_create_on_off_request_data(guint request_type, } break; - case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: { - ZigbeeOnOffGetOnOffState_t *in_req; - ZigbeeOnOffGetOnOffState_t *req = NULL; + case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: { + ZigbeeZclOnOffGetOnOffState_t *in_req; + ZigbeeZclOnOffGetOnOffState_t *req = NULL; - in_req = (ZigbeeOnOffGetOnOffState_t *)request_data; + in_req = (ZigbeeZclOnOffGetOnOffState_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeOnOffGetOnOffState_t *) - g_malloc0(sizeof(ZigbeeOnOffGetOnOffState_t)); + req = (ZigbeeZclOnOffGetOnOffState_t *) + g_malloc0(sizeof(ZigbeeZclOnOffGetOnOffState_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1119,16 +1137,6 @@ static gpointer __zblib_request_create_service_request_data(guint request_type, /* 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; } @@ -1282,13 +1290,14 @@ static gpointer __zblib_request_create_service_request_data(guint request_type, break; default: + Z_LOGE("Unexpected operation [%x]", ops_id); break; } return service_request_data; } -static gpointer __zblib_request_create_thermostat_request_data(guint request_type, +static gpointer __zblib_request_create_zcl_thermostat_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer thermostat_request_data = NULL; @@ -1299,15 +1308,15 @@ static gpointer __zblib_request_create_thermostat_request_data(guint request_typ /* 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; + case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: { + ZigbeeZclThermostatGetLocalTemp_t *in_req; + ZigbeeZclThermostatGetLocalTemp_t *req = NULL; - in_req = (ZigbeeThermostatGetLocalTemp_t *)request_data; + in_req = (ZigbeeZclThermostatGetLocalTemp_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeThermostatGetLocalTemp_t *) - g_malloc0(sizeof(ZigbeeThermostatGetLocalTemp_t)); + req = (ZigbeeZclThermostatGetLocalTemp_t *) + g_malloc0(sizeof(ZigbeeZclThermostatGetLocalTemp_t)); /* Copy data */ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); @@ -1318,15 +1327,15 @@ static gpointer __zblib_request_create_thermostat_request_data(guint request_typ } break; - case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: { - ZigbeeThermostatGetWeeklySchedule_t *in_req; - ZigbeeThermostatGetWeeklySchedule_t *req = NULL; + case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: { + ZigbeeZclThermostatGetWeeklySchedule_t *in_req; + ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL; - in_req = (ZigbeeThermostatGetWeeklySchedule_t *)request_data; + in_req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeThermostatGetWeeklySchedule_t *) - g_malloc0(sizeof(ZigbeeThermostatGetWeeklySchedule_t)); + req = (ZigbeeZclThermostatGetWeeklySchedule_t *) + g_malloc0(sizeof(ZigbeeZclThermostatGetWeeklySchedule_t)); /* Copy data */ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); @@ -1339,15 +1348,15 @@ static gpointer __zblib_request_create_thermostat_request_data(guint request_typ } break; - case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: { - ZigbeeThermostatSetWeeklySchedule_t *in_req; - ZigbeeThermostatSetWeeklySchedule_t *req = NULL; + case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: { + ZigbeeZclThermostatSetWeeklySchedule_t *in_req; + ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL; - in_req = (ZigbeeThermostatSetWeeklySchedule_t *)request_data; + in_req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeThermostatSetWeeklySchedule_t *) - g_malloc0(sizeof(ZigbeeThermostatSetWeeklySchedule_t)); + req = (ZigbeeZclThermostatSetWeeklySchedule_t *) + g_malloc0(sizeof(ZigbeeZclThermostatSetWeeklySchedule_t)); /* Copy data */ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); @@ -1364,15 +1373,15 @@ static gpointer __zblib_request_create_thermostat_request_data(guint request_typ } break; - case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: { - ZigbeeThermostatClearWeeklySchedule_t *in_req; - ZigbeeThermostatClearWeeklySchedule_t *req = NULL; + case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: { + ZigbeeZclThermostatClearWeeklySchedule_t *in_req; + ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL; - in_req = (ZigbeeThermostatClearWeeklySchedule_t *)request_data; + in_req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeThermostatClearWeeklySchedule_t *) - g_malloc0(sizeof(ZigbeeThermostatClearWeeklySchedule_t)); + req = (ZigbeeZclThermostatClearWeeklySchedule_t *) + g_malloc0(sizeof(ZigbeeZclThermostatClearWeeklySchedule_t)); /* Copy data */ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); @@ -1383,15 +1392,15 @@ static gpointer __zblib_request_create_thermostat_request_data(guint request_typ } break; - case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: { - ZigbeeThermostatSetpointRaiseLower_t *in_req; - ZigbeeThermostatSetpointRaiseLower_t *req = NULL; + case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: { + ZigbeeZclThermostatSetpointRaiseLower_t *in_req; + ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL; - in_req = (ZigbeeThermostatSetpointRaiseLower_t *)request_data; + in_req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeThermostatSetpointRaiseLower_t *) - g_malloc0(sizeof(ZigbeeThermostatSetpointRaiseLower_t)); + req = (ZigbeeZclThermostatSetpointRaiseLower_t *) + g_malloc0(sizeof(ZigbeeZclThermostatSetpointRaiseLower_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1411,7 +1420,7 @@ static gpointer __zblib_request_create_thermostat_request_data(guint request_typ return thermostat_request_data; } -static gpointer __zblib_request_create_zclbasic_control_request_data(guint request_type, +static gpointer __zblib_request_create_zcl_basic_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer zclbasic_control_request_data = NULL; @@ -1422,15 +1431,15 @@ static gpointer __zblib_request_create_zclbasic_control_request_data(guint reque /* 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; + case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: { + ZigbeeZclBasicResetFactoryDefault_t *in_req; + ZigbeeZclBasicResetFactoryDefault_t *req = NULL; - in_req = (ZigbeeZclbasicControlResetFactoryDefault_t *)request_data; + in_req = (ZigbeeZclBasicResetFactoryDefault_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclbasicControlResetFactoryDefault_t *) - g_malloc0(sizeof(ZigbeeZclbasicControlResetFactoryDefault_t)); + req = (ZigbeeZclBasicResetFactoryDefault_t *) + g_malloc0(sizeof(ZigbeeZclBasicResetFactoryDefault_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1448,7 +1457,7 @@ static gpointer __zblib_request_create_zclbasic_control_request_data(guint reque return zclbasic_control_request_data; } -static gpointer __zblib_request_create_zclglobal_control_request_data(guint request_type, +static gpointer __zblib_request_create_zcl_global_control_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer zclglobal_control_request_data = NULL; @@ -1459,18 +1468,22 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ /* 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; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: { + ZigbeeZclGlobalControlReadAttributesRequest_t *in_req; + ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL; - in_req = (ZigbeeZclglobalControlReadAttributesRequest_t *)request_data; + in_req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request_data; if (NULL != in_req) { + guint i; /* Allocate memory */ - req = (ZigbeeZclglobalControlReadAttributesRequest_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlReadAttributesRequest_t)); + req = (ZigbeeZclGlobalControlReadAttributesRequest_t *) + g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t)); /* Copy data */ - req->attribute_id = g_strdup(in_req->attribute_id); + for (i = 0; i < (in_req->attribute_id_len * sizeof(short)); i++) + Z_LOGE("in_req->attribute_id[%d] = 0x%X", i, in_req->attribute_id[i]); + req->attribute_id = g_memdup(in_req->attribute_id, + in_req->attribute_id_len * sizeof(short)); req->attribute_id_len = in_req->attribute_id_len; req->node_id = in_req->node_id; req->cluster_id = in_req->cluster_id; @@ -1482,18 +1495,18 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: { - ZigbeeZclglobalControlWriteAttributesRequest_t *in_req; - ZigbeeZclglobalControlWriteAttributesRequest_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: { + ZigbeeZclGlobalControlWriteAttributesRequest_t *in_req; + ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL; - in_req = (ZigbeeZclglobalControlWriteAttributesRequest_t *)request_data; + in_req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclglobalControlWriteAttributesRequest_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesRequest_t)); + req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *) + g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesRequest_t)); /* Copy data */ - req->write_records = g_strdup(in_req->write_records); + req->write_records = g_memdup(in_req->write_records, in_req->records_len); req->records_len = in_req->records_len; req->node_id = in_req->node_id; req->cluster_id = in_req->cluster_id; @@ -1506,18 +1519,18 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: { - ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *in_req; - ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: { + ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *in_req; + ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL; - in_req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *)request_data; + in_req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesUndividedRequest_t)); + req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *) + g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t)); /* Copy data */ - req->write_records = g_strdup(in_req->write_records); + req->write_records = g_memdup(in_req->write_records, in_req->records_len); req->records_len = in_req->records_len; req->node_id = in_req->node_id; req->cluster_id = in_req->cluster_id; @@ -1530,18 +1543,18 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: { - ZigbeeZclglobalControlWriteAttributesNoResponse_t *in_req; - ZigbeeZclglobalControlWriteAttributesNoResponse_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: { + ZigbeeZclGlobalControlWriteAttributesNoResponse_t *in_req; + ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL; - in_req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *)request_data; + in_req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesNoResponse_t)); + req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *) + g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t)); /* Copy data */ - req->write_records = g_strdup(in_req->write_records); + req->write_records = g_memdup(in_req->write_records, in_req->records_len); req->records_len = in_req->records_len; req->node_id = in_req->node_id; req->cluster_id = in_req->cluster_id; @@ -1554,18 +1567,18 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: { - ZigbeeZclglobalControlWriteAttributesStructed_t *in_req; - ZigbeeZclglobalControlWriteAttributesStructed_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: { + ZigbeeZclGlobalControlWriteAttributesStructed_t *in_req; + ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL; - in_req = (ZigbeeZclglobalControlWriteAttributesStructed_t *)request_data; + in_req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclglobalControlWriteAttributesStructed_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesStructed_t)); + req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *) + g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t)); /* Copy data */ - req->write_records = g_strdup(in_req->write_records); + req->write_records = g_memdup(in_req->write_records, in_req->records_len); req->records_len = in_req->records_len; req->node_id = in_req->node_id; req->cluster_id = in_req->cluster_id; @@ -1578,18 +1591,18 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: { - ZigbeeZclglobalControlReadAttributesStructed_t *in_req; - ZigbeeZclglobalControlReadAttributesStructed_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: { + ZigbeeZclGlobalControlReadAttributesStructed_t *in_req; + ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL; - in_req = (ZigbeeZclglobalControlReadAttributesStructed_t *)request_data; + in_req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclglobalControlReadAttributesStructed_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlReadAttributesStructed_t)); + req = (ZigbeeZclGlobalControlReadAttributesStructed_t *) + g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t)); /* Copy data */ - req->read_records = g_strdup(in_req->read_records); + req->read_records = g_memdup(in_req->read_records, in_req->records_len); req->records_len = in_req->records_len; req->node_id = in_req->node_id; req->cluster_id = in_req->cluster_id; @@ -1602,18 +1615,18 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: { - ZigbeeZclglobalControlConfigureReportingReq_t *in_req; - ZigbeeZclglobalControlConfigureReportingReq_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: { + ZigbeeZclGlobalControlConfigureReportingReq_t *in_req; + ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL; - in_req = (ZigbeeZclglobalControlConfigureReportingReq_t *)request_data; + in_req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclglobalControlConfigureReportingReq_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlConfigureReportingReq_t)); + req = (ZigbeeZclGlobalControlConfigureReportingReq_t *) + g_malloc0(sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t)); /* Copy data */ - req->read_records = g_strdup(in_req->read_records); + req->read_records = g_memdup(in_req->read_records, in_req->records_len); req->records_len = in_req->records_len; req->node_id = in_req->node_id; req->cluster_id = in_req->cluster_id; @@ -1626,18 +1639,18 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: { - ZigbeeZclglobalControlReadConfigureReporting_t *in_req; - ZigbeeZclglobalControlReadConfigureReporting_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: { + ZigbeeZclGlobalControlReadConfigureReporting_t *in_req; + ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL; - in_req = (ZigbeeZclglobalControlReadConfigureReporting_t *)request_data; + in_req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclglobalControlReadConfigureReporting_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlReadConfigureReporting_t)); + req = (ZigbeeZclGlobalControlReadConfigureReporting_t *) + g_malloc0(sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t)); /* Copy data */ - req->read_records = g_strdup(in_req->read_records); + req->read_records = g_memdup(in_req->read_records, in_req->records_len); req->records_len = in_req->records_len; req->node_id = in_req->node_id; req->cluster_id = in_req->cluster_id; @@ -1650,15 +1663,15 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: { - ZigbeeZclglobalControlDiscoverAttributes_t *in_req; - ZigbeeZclglobalControlDiscoverAttributes_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: { + ZigbeeZclGlobalControlDiscoverAttributes_t *in_req; + ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL; - in_req = (ZigbeeZclglobalControlDiscoverAttributes_t *)request_data; + in_req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclglobalControlDiscoverAttributes_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverAttributes_t)); + req = (ZigbeeZclGlobalControlDiscoverAttributes_t *) + g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributes_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1666,22 +1679,22 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ 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; + req->max_attribute_count = in_req->max_attribute_count; } zclglobal_control_request_data = (gpointer)req; } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: { - ZigbeeZclglobalControlDiscoverAttributesExtended_t *in_req; - ZigbeeZclglobalControlDiscoverAttributesExtended_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: { + ZigbeeZclGlobalControlDiscoverAttributesExtended_t *in_req; + ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL; - in_req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *)request_data; + in_req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverAttributesExtended_t)); + req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *) + g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributesExtended_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1689,53 +1702,53 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ 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; + req->max_attribute_count = in_req->max_attribute_count; } zclglobal_control_request_data = (gpointer)req; } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: { - ZigbeeZclglobalControlDiscoverCommandsReceived_t *in_req; - ZigbeeZclglobalControlDiscoverCommandsReceived_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: { + ZigbeeZclGlobalControlDiscoverCommandsReceived_t *in_req; + ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL; - in_req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *)request_data; + in_req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverCommandsReceived_t)); + 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; + req->start_command = in_req->start_command; + req->max_command_count = in_req->max_command_count; } zclglobal_control_request_data = (gpointer)req; } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: { - ZigbeeZclglobalControlDiscoverCommandsGenerated_t *in_req; - ZigbeeZclglobalControlDiscoverCommandsGenerated_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: { + ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *in_req; + ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL; - in_req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *)request_data; + in_req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *) - g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverCommandsGenerated_t)); + 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; + req->start_command = in_req->start_command; + req->max_command_count = in_req->max_command_count; } zclglobal_control_request_data = (gpointer)req; @@ -1749,7 +1762,7 @@ static gpointer __zblib_request_create_zclglobal_control_request_data(guint requ return zclglobal_control_request_data; } -static gpointer __zblib_request_create_zclias_control_request_data(guint request_type, +static gpointer __zblib_request_create_zcl_ias_zone_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer zclias_control_request_data = NULL; @@ -1760,15 +1773,15 @@ static gpointer __zblib_request_create_zclias_control_request_data(guint request /* 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; + case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: { + ZigbeeZclIasZoneEnrollResponse_t *in_req; + ZigbeeZclIasZoneEnrollResponse_t *req = NULL; - in_req = (ZigbeeZcliasControlEnrolResponse_t *)request_data; + in_req = (ZigbeeZclIasZoneEnrollResponse_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZcliasControlEnrolResponse_t *) - g_malloc0(sizeof(ZigbeeZcliasControlEnrolResponse_t)); + req = (ZigbeeZclIasZoneEnrollResponse_t *) + g_malloc0(sizeof(ZigbeeZclIasZoneEnrollResponse_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1788,7 +1801,7 @@ static gpointer __zblib_request_create_zclias_control_request_data(guint request return zclias_control_request_data; } -static gpointer __zblib_request_create_zclidentify_control_request_data(guint request_type, +static gpointer __zblib_request_create_zcl_identify_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer zclidentify_control_request_data = NULL; @@ -1799,15 +1812,15 @@ static gpointer __zblib_request_create_zclidentify_control_request_data(guint re /* 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; + case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: { + ZigbeeZclIdentifyIdentify_t *in_req; + ZigbeeZclIdentifyIdentify_t *req = NULL; - in_req = (ZigbeeZclidentifyControlIdentify_t *)request_data; + in_req = (ZigbeeZclIdentifyIdentify_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclidentifyControlIdentify_t *) - g_malloc0(sizeof(ZigbeeZclidentifyControlIdentify_t)); + req = (ZigbeeZclIdentifyIdentify_t *) + g_malloc0(sizeof(ZigbeeZclIdentifyIdentify_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1819,18 +1832,19 @@ static gpointer __zblib_request_create_zclidentify_control_request_data(guint re } break; - case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: { - ZigbeeZclidentifyControlQuery_t *in_req; - ZigbeeZclidentifyControlQuery_t *req = NULL; + case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: { + ZigbeeZclIdentifyQuery_t *in_req; + ZigbeeZclIdentifyQuery_t *req = NULL; - in_req = (ZigbeeZclidentifyControlQuery_t *)request_data; + in_req = (ZigbeeZclIdentifyQuery_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclidentifyControlQuery_t *) - g_malloc0(sizeof(ZigbeeZclidentifyControlQuery_t)); + req = (ZigbeeZclIdentifyQuery_t *) + g_malloc0(sizeof(ZigbeeZclIdentifyQuery_t)); /* Copy data */ req->node_id = in_req->node_id; + req->dest_ep = in_req->dest_ep; } zclidentify_control_request_data = (gpointer)req; @@ -1844,7 +1858,7 @@ static gpointer __zblib_request_create_zclidentify_control_request_data(guint re return zclidentify_control_request_data; } -static gpointer __zblib_request_create_zcl_color_request_data(guint request_type, +static gpointer __zblib_request_create_zcl_color_control_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer zcl_color_request_data = NULL; @@ -1855,15 +1869,15 @@ static gpointer __zblib_request_create_zcl_color_request_data(guint request_type /* 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; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: { + ZigbeeZclColorControlMoveToHue_t *in_req; + ZigbeeZclColorControlMoveToHue_t *req = NULL; - in_req = (ZigbeeZclColorMoveToHue_t *)request_data; + in_req = (ZigbeeZclColorControlMoveToHue_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclColorMoveToHue_t *) - g_malloc0(sizeof(ZigbeeZclColorMoveToHue_t)); + req = (ZigbeeZclColorControlMoveToHue_t *) + g_malloc0(sizeof(ZigbeeZclColorControlMoveToHue_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1877,15 +1891,15 @@ static gpointer __zblib_request_create_zcl_color_request_data(guint request_type } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: { - ZigbeeZclColorMoveHue_t *in_req; - ZigbeeZclColorMoveHue_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: { + ZigbeeZclColorControlMoveHue_t *in_req; + ZigbeeZclColorControlMoveHue_t *req = NULL; - in_req = (ZigbeeZclColorMoveHue_t *)request_data; + in_req = (ZigbeeZclColorControlMoveHue_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclColorMoveHue_t *) - g_malloc0(sizeof(ZigbeeZclColorMoveHue_t)); + req = (ZigbeeZclColorControlMoveHue_t *) + g_malloc0(sizeof(ZigbeeZclColorControlMoveHue_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1898,15 +1912,15 @@ static gpointer __zblib_request_create_zcl_color_request_data(guint request_type } break; - case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: { - ZigbeeZclColorStepHue_t *in_req; - ZigbeeZclColorStepHue_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: { + ZigbeeZclColorControlStepHue_t *in_req; + ZigbeeZclColorControlStepHue_t *req = NULL; - in_req = (ZigbeeZclColorStepHue_t *)request_data; + in_req = (ZigbeeZclColorControlStepHue_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclColorStepHue_t *) - g_malloc0(sizeof(ZigbeeZclColorStepHue_t)); + req = (ZigbeeZclColorControlStepHue_t *) + g_malloc0(sizeof(ZigbeeZclColorControlStepHue_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1920,15 +1934,15 @@ static gpointer __zblib_request_create_zcl_color_request_data(guint request_type } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: { - ZigbeeZclColorMoveToSaturation_t *in_req; - ZigbeeZclColorMoveToSaturation_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: { + ZigbeeZclColorControlMoveToSaturation_t *in_req; + ZigbeeZclColorControlMoveToSaturation_t *req = NULL; - in_req = (ZigbeeZclColorMoveToSaturation_t *)request_data; + in_req = (ZigbeeZclColorControlMoveToSaturation_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclColorMoveToSaturation_t *) - g_malloc0(sizeof(ZigbeeZclColorMoveToSaturation_t)); + req = (ZigbeeZclColorControlMoveToSaturation_t *) + g_malloc0(sizeof(ZigbeeZclColorControlMoveToSaturation_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1941,15 +1955,15 @@ static gpointer __zblib_request_create_zcl_color_request_data(guint request_type } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: { - ZigbeeZclColorMoveSaturation_t *in_req; - ZigbeeZclColorMoveSaturation_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: { + ZigbeeZclColorControlMoveSaturation_t *in_req; + ZigbeeZclColorControlMoveSaturation_t *req = NULL; - in_req = (ZigbeeZclColorMoveSaturation_t *)request_data; + in_req = (ZigbeeZclColorControlMoveSaturation_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclColorMoveSaturation_t *) - g_malloc0(sizeof(ZigbeeZclColorMoveSaturation_t)); + req = (ZigbeeZclColorControlMoveSaturation_t *) + g_malloc0(sizeof(ZigbeeZclColorControlMoveSaturation_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1962,15 +1976,15 @@ static gpointer __zblib_request_create_zcl_color_request_data(guint request_type } break; - case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: { - ZigbeeZclColorStepSaturation_t *in_req; - ZigbeeZclColorStepSaturation_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: { + ZigbeeZclColorControlStepSaturation_t *in_req; + ZigbeeZclColorControlStepSaturation_t *req = NULL; - in_req = (ZigbeeZclColorStepSaturation_t *)request_data; + in_req = (ZigbeeZclColorControlStepSaturation_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclColorStepSaturation_t *) - g_malloc0(sizeof(ZigbeeZclColorStepSaturation_t)); + req = (ZigbeeZclColorControlStepSaturation_t *) + g_malloc0(sizeof(ZigbeeZclColorControlStepSaturation_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -1984,15 +1998,15 @@ static gpointer __zblib_request_create_zcl_color_request_data(guint request_type } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: { - ZigbeeZclColorMoveToHueAndSaturation_t *in_req; - ZigbeeZclColorMoveToHueAndSaturation_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: { + ZigbeeZclColorControlMoveToHueAndSaturation_t *in_req; + ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL; - in_req = (ZigbeeZclColorMoveToHueAndSaturation_t *)request_data; + in_req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclColorMoveToHueAndSaturation_t *) - g_malloc0(sizeof(ZigbeeZclColorMoveToHueAndSaturation_t)); + req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *) + g_malloc0(sizeof(ZigbeeZclColorControlMoveToHueAndSaturation_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2006,15 +2020,15 @@ static gpointer __zblib_request_create_zcl_color_request_data(guint request_type } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: { - ZigbeeZclColorMoveToColor_t *in_req; - ZigbeeZclColorMoveToColor_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: { + ZigbeeZclColorControlMoveToColor_t *in_req; + ZigbeeZclColorControlMoveToColor_t *req = NULL; - in_req = (ZigbeeZclColorMoveToColor_t *)request_data; + in_req = (ZigbeeZclColorControlMoveToColor_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclColorMoveToColor_t *) - g_malloc0(sizeof(ZigbeeZclColorMoveToColor_t)); + req = (ZigbeeZclColorControlMoveToColor_t *) + g_malloc0(sizeof(ZigbeeZclColorControlMoveToColor_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2028,15 +2042,15 @@ static gpointer __zblib_request_create_zcl_color_request_data(guint request_type } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: { - ZigbeeZclColorMoveColor_t *in_req; - ZigbeeZclColorMoveColor_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: { + ZigbeeZclColorControlMoveColor_t *in_req; + ZigbeeZclColorControlMoveColor_t *req = NULL; - in_req = (ZigbeeZclColorMoveColor_t *)request_data; + in_req = (ZigbeeZclColorControlMoveColor_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclColorMoveColor_t *) - g_malloc0(sizeof(ZigbeeZclColorMoveColor_t)); + req = (ZigbeeZclColorControlMoveColor_t *) + g_malloc0(sizeof(ZigbeeZclColorControlMoveColor_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2049,21 +2063,21 @@ static gpointer __zblib_request_create_zcl_color_request_data(guint request_type } break; - case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: { - ZigbeeZclColorStepColor_t *in_req; - ZigbeeZclColorStepColor_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: { + ZigbeeZclColorControlStepColor_t *in_req; + ZigbeeZclColorControlStepColor_t *req = NULL; - in_req = (ZigbeeZclColorStepColor_t *)request_data; + in_req = (ZigbeeZclColorControlStepColor_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclColorStepColor_t *) - g_malloc0(sizeof(ZigbeeZclColorStepColor_t)); + req = (ZigbeeZclColorControlStepColor_t *) + g_malloc0(sizeof(ZigbeeZclColorControlStepColor_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->step_x = in_req->step_x; + req->step_y = in_req->step_y; req->transition_time = in_req->transition_time; } @@ -2071,15 +2085,15 @@ static gpointer __zblib_request_create_zcl_color_request_data(guint request_type } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: { - ZigbeeZclColorMoveColorTemperature_t *in_req; - ZigbeeZclColorMoveColorTemperature_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: { + ZigbeeZclColorControlMoveColorTemperature_t *in_req; + ZigbeeZclColorControlMoveColorTemperature_t *req = NULL; - in_req = (ZigbeeZclColorMoveColorTemperature_t *)request_data; + in_req = (ZigbeeZclColorControlMoveColorTemperature_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZclColorMoveColorTemperature_t *) - g_malloc0(sizeof(ZigbeeZclColorMoveColorTemperature_t)); + req = (ZigbeeZclColorControlMoveColorTemperature_t *) + g_malloc0(sizeof(ZigbeeZclColorControlMoveColorTemperature_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2145,6 +2159,7 @@ static gpointer __zblib_request_create_zcl_group_request_data(guint request_type /* 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; @@ -2165,8 +2180,8 @@ static gpointer __zblib_request_create_zcl_group_request_data(guint request_type 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); + req->group_list = (gushort *)g_memdup(in_req->group_list, + sizeof(gushort) * in_req->group_count); } zcl_group_request_data = (gpointer)req; @@ -2369,7 +2384,7 @@ static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type 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, + req->ext_field_set = (guchar *)g_memdup(in_req->ext_field_set, in_req->ext_field_set_len); } @@ -2508,7 +2523,7 @@ static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type return zcl_scene_request_data; } -static gpointer __zblib_request_create_zdodev_control_request_data(guint request_type, +static gpointer __zblib_request_create_zdo_dev_control_request_data(guint request_type, gpointer request_data, guint request_data_len) { gpointer zdodev_control_request_data = NULL; @@ -2519,15 +2534,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request /* 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: { + ZigbeeZdoDevControlNwkAddrReq_t *in_req; + ZigbeeZdoDevControlNwkAddrReq_t *req = NULL; - in_req = (ZigbeeZdodevControlNwkAddrReq_t *)request_data; + in_req = (ZigbeeZdoDevControlNwkAddrReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlNwkAddrReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlNwkAddrReq_t)); + req = (ZigbeeZdoDevControlNwkAddrReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlNwkAddrReq_t)); /* Copy data */ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE); @@ -2539,38 +2554,46 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: { - ZigbeeZdodevControlMatchedDescriptorReq_t *in_req; - ZigbeeZdodevControlMatchedDescriptorReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: { + ZigbeeZdoDevControlMatchedDescriptorReq_t *in_req; + ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL; - in_req = (ZigbeeZdodevControlMatchedDescriptorReq_t *)request_data; + in_req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlMatchedDescriptorReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlMatchedDescriptorReq_t)); + 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); + if (in_req->num_in_cl > 0) { + req->in_cl = g_malloc0_n(in_req->num_in_cl, sizeof(unsigned short)); + memcpy(req->in_cl, in_req->in_cl, + in_req->num_in_cl * sizeof(unsigned short)); + } req->num_out_cl = in_req->num_out_cl; - req->out_cl = g_strdup(in_req->out_cl); + if (in_req->num_out_cl > 0) { + req->out_cl = g_malloc0_n(in_req->num_out_cl, sizeof(unsigned short)); + memcpy(req->out_cl, in_req->out_cl, + in_req->num_out_cl * sizeof(unsigned short)); + } } zdodev_control_request_data = (gpointer)req; } break; - case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: { - ZigbeeZdodevControlIeeeAddrReq_t *in_req; - ZigbeeZdodevControlIeeeAddrReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: { + ZigbeeZdoDevControlIeeeAddrReq_t *in_req; + ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL; - in_req = (ZigbeeZdodevControlIeeeAddrReq_t *)request_data; + in_req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlIeeeAddrReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlIeeeAddrReq_t)); + req = (ZigbeeZdoDevControlIeeeAddrReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlIeeeAddrReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2580,15 +2603,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: { - ZigbeeZdodevControlActiveEpReq_t *in_req; - ZigbeeZdodevControlActiveEpReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: { + ZigbeeZdoDevControlActiveEpReq_t *in_req; + ZigbeeZdoDevControlActiveEpReq_t *req = NULL; - in_req = (ZigbeeZdodevControlActiveEpReq_t *)request_data; + in_req = (ZigbeeZdoDevControlActiveEpReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlActiveEpReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlActiveEpReq_t)); + req = (ZigbeeZdoDevControlActiveEpReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlActiveEpReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2598,15 +2621,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: { - ZigbeeZdodevControlNodeDescriptorReq_t *in_req; - ZigbeeZdodevControlNodeDescriptorReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: { + ZigbeeZdoDevControlNodeDescriptorReq_t *in_req; + ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL; - in_req = (ZigbeeZdodevControlNodeDescriptorReq_t *)request_data; + in_req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlNodeDescriptorReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlNodeDescriptorReq_t)); + req = (ZigbeeZdoDevControlNodeDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2616,15 +2639,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: { - ZigbeeZdodevControlPowerDescriptorReq_t *in_req; - ZigbeeZdodevControlPowerDescriptorReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: { + ZigbeeZdoDevControlPowerDescriptorReq_t *in_req; + ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL; - in_req = (ZigbeeZdodevControlPowerDescriptorReq_t *)request_data; + in_req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlPowerDescriptorReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlPowerDescriptorReq_t)); + req = (ZigbeeZdoDevControlPowerDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2634,15 +2657,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: { - ZigbeeZdodevControlComplexDescriptorReq_t *in_req; - ZigbeeZdodevControlComplexDescriptorReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: { + ZigbeeZdoDevControlComplexDescriptorReq_t *in_req; + ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL; - in_req = (ZigbeeZdodevControlComplexDescriptorReq_t *)request_data; + in_req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlComplexDescriptorReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlComplexDescriptorReq_t)); + req = (ZigbeeZdoDevControlComplexDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2652,15 +2675,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: { - ZigbeeZdodevControlUserDescriptorReq_t *in_req; - ZigbeeZdodevControlUserDescriptorReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: { + ZigbeeZdoDevControlUserDescriptorReq_t *in_req; + ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL; - in_req = (ZigbeeZdodevControlUserDescriptorReq_t *)request_data; + in_req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlUserDescriptorReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlUserDescriptorReq_t)); + req = (ZigbeeZdoDevControlUserDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2670,15 +2693,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: { - ZigbeeZdodevControlUserDescriptorSetReq_t *in_req; - ZigbeeZdodevControlUserDescriptorSetReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: { + ZigbeeZdoDevControlUserDescriptorSetReq_t *in_req; + ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL; - in_req = (ZigbeeZdodevControlUserDescriptorSetReq_t *)request_data; + in_req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlUserDescriptorSetReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlUserDescriptorSetReq_t)); + req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2691,15 +2714,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: { - ZigbeeZdodevControlDeviceAnnounce_t *in_req; - ZigbeeZdodevControlDeviceAnnounce_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: { + ZigbeeZdoDevControlDeviceAnnounce_t *in_req; + ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL; - in_req = (ZigbeeZdodevControlDeviceAnnounce_t *)request_data; + in_req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlDeviceAnnounce_t *) - g_malloc0(sizeof(ZigbeeZdodevControlDeviceAnnounce_t)); + req = (ZigbeeZdoDevControlDeviceAnnounce_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlDeviceAnnounce_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2711,15 +2734,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: { - ZigbeeZdodevControlSimpleDescriptorReq_t *in_req; - ZigbeeZdodevControlSimpleDescriptorReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: { + ZigbeeZdoDevControlSimpleDescriptorReq_t *in_req; + ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL; - in_req = (ZigbeeZdodevControlSimpleDescriptorReq_t *)request_data; + in_req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlSimpleDescriptorReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlSimpleDescriptorReq_t)); + req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2730,15 +2753,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: { - ZigbeeZdodevControlMgmtLqiReq_t *in_req; - ZigbeeZdodevControlMgmtLqiReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: { + ZigbeeZdoDevControlMgmtLqiReq_t *in_req; + ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL; - in_req = (ZigbeeZdodevControlMgmtLqiReq_t *)request_data; + in_req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlMgmtLqiReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlMgmtLqiReq_t)); + req = (ZigbeeZdoDevControlMgmtLqiReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlMgmtLqiReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2749,15 +2772,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: { - ZigbeeZdodevControlMgmtRtgReq_t *in_req; - ZigbeeZdodevControlMgmtRtgReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: { + ZigbeeZdoDevControlMgmtRtgReq_t *in_req; + ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL; - in_req = (ZigbeeZdodevControlMgmtRtgReq_t *)request_data; + in_req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlMgmtRtgReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlMgmtRtgReq_t)); + req = (ZigbeeZdoDevControlMgmtRtgReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlMgmtRtgReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2768,15 +2791,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: { - ZigbeeZdodevControlMgmtBindReq_t *in_req; - ZigbeeZdodevControlMgmtBindReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: { + ZigbeeZdoDevControlMgmtBindReq_t *in_req; + ZigbeeZdoDevControlMgmtBindReq_t *req = NULL; - in_req = (ZigbeeZdodevControlMgmtBindReq_t *)request_data; + in_req = (ZigbeeZdoDevControlMgmtBindReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlMgmtBindReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlMgmtBindReq_t)); + req = (ZigbeeZdoDevControlMgmtBindReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlMgmtBindReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2787,18 +2810,18 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: { - ZigbeeZdodevControlMgmtPermitJoinReq_t *in_req; - ZigbeeZdodevControlMgmtPermitJoinReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: { + ZigbeeZdoDevControlMgmtPermitJoinReq_t *in_req; + ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL; - in_req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *)request_data; + in_req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlMgmtPermitJoinReq_t)); + req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t)); /* Copy data */ - req->addr = in_req->addr; + req->node_id = in_req->node_id; req->duration = in_req->duration; req->tc_significance = in_req->tc_significance; } @@ -2807,15 +2830,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: { - ZigbeeZdodevControlNwkUpdateReq_t *in_req; - ZigbeeZdodevControlNwkUpdateReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_UPDATE_REQ: { + ZigbeeZdoDevControlMgmtNwkUpdateReq_t *in_req; + ZigbeeZdoDevControlMgmtNwkUpdateReq_t *req = NULL; - in_req = (ZigbeeZdodevControlNwkUpdateReq_t *)request_data; + in_req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlNwkUpdateReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlNwkUpdateReq_t)); + req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlMgmtNwkUpdateReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2829,15 +2852,15 @@ static gpointer __zblib_request_create_zdodev_control_request_data(guint request } break; - case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: { - ZigbeeZdodevControlNwkDescriptorReq_t *in_req; - ZigbeeZdodevControlNwkDescriptorReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_DISC_REQ: { + ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *in_req; + ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *req = NULL; - in_req = (ZigbeeZdodevControlNwkDescriptorReq_t *)request_data; + in_req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *)request_data; if (NULL != in_req) { /* Allocate memory */ - req = (ZigbeeZdodevControlNwkDescriptorReq_t *) - g_malloc0(sizeof(ZigbeeZdodevControlNwkDescriptorReq_t)); + req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *) + g_malloc0(sizeof(ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t)); /* Copy data */ req->node_id = in_req->node_id; @@ -2881,12 +2904,10 @@ static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type, /* 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); + memcpy(req->src_addr, in_req->src_addr, ZIGBEE_EUI64_SIZE); 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); + memcpy(req->dst_addr, in_req->dst_addr, ZIGBEE_EUI64_SIZE); req->bind_type = in_req->bind_type; req->group_addr = in_req->group_addr; req->dst_ep = in_req->dst_ep; @@ -2908,12 +2929,10 @@ static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type, /* 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); + memcpy(req->src_addr, in_req->src_addr, ZIGBEE_EUI64_SIZE); 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); + memcpy(req->dst_addr, in_req->dst_addr, ZIGBEE_EUI64_SIZE); req->bind_type = in_req->bind_type; req->group_addr = in_req->group_addr; req->dst_ep = in_req->dst_ep; @@ -2940,8 +2959,8 @@ static gpointer __zblib_request_create_request_data(guint 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, + case ZBLIB_DRIVER_TYPE_ZCL_ALARM: { + _request_data = __zblib_request_create_zcl_alarm_request_data(request_type, request_data, request_data_len); } break; @@ -2952,20 +2971,20 @@ static gpointer __zblib_request_create_request_data(guint request_type, } break; - case ZBLIB_DRIVER_TYPE_DOOR_LOCK: { - _request_data = __zblib_request_create_door_lock_request_data(request_type, + case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: { + _request_data = __zblib_request_create_zcl_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, + case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: { + _request_data = __zblib_request_create_zcl_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, + case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: { + _request_data = __zblib_request_create_zcl_level_control_request_data(request_type, request_data, request_data_len); } break; @@ -2976,8 +2995,8 @@ static gpointer __zblib_request_create_request_data(guint request_type, } break; - case ZBLIB_DRIVER_TYPE_ON_OFF: { - _request_data = __zblib_request_create_on_off_request_data(request_type, + case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: { + _request_data = __zblib_request_create_zcl_on_off_request_data(request_type, request_data, request_data_len); } break; @@ -2988,38 +3007,38 @@ static gpointer __zblib_request_create_request_data(guint request_type, } break; - case ZBLIB_DRIVER_TYPE_THERMOSTAT: { - _request_data = __zblib_request_create_thermostat_request_data(request_type, + case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: { + _request_data = __zblib_request_create_zcl_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, + case ZBLIB_DRIVER_TYPE_ZCL_BASIC: { + _request_data = __zblib_request_create_zcl_basic_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, + case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: { + _request_data = __zblib_request_create_zcl_global_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, + case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: { + _request_data = __zblib_request_create_zcl_ias_zone_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, + case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: { + _request_data = __zblib_request_create_zcl_identify_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, + case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: { + _request_data = __zblib_request_create_zcl_color_control_request_data(request_type, request_data, request_data_len); } break; @@ -3042,8 +3061,8 @@ static gpointer __zblib_request_create_request_data(guint request_type, } break; - case ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL: { - _request_data = __zblib_request_create_zdodev_control_request_data(request_type, + case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: { + _request_data = __zblib_request_create_zdo_dev_control_request_data(request_type, request_data, request_data_len); } break; @@ -3054,7 +3073,7 @@ static gpointer __zblib_request_create_request_data(guint request_type, } break; - case ZBLIB_DRIVER_TYPE_NONE: /* Fallthrough */ + case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */ default: { Z_LOGE("Unhandled driver type: [%d]", driver_type); } @@ -3064,7 +3083,7 @@ static gpointer __zblib_request_create_request_data(guint request_type, return _request_data; } -static void __zblib_request_free_alarm_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zcl_alarm_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -3072,57 +3091,52 @@ static void __zblib_request_free_alarm_request_data(ZigBeeRequest *request, /* 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; + case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: { + ZigbeeZclAlarmGetAlarmCount_t *req = NULL; - req = (ZigbeeAlarmGetAlarmCount_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclAlarmGetAlarmCount_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ALARM_OPS_RESET_ALARM: { - ZigbeeAlarmResetAlarm_t *req = NULL; + case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: { + ZigbeeZclAlarmResetAlarm_t *req = NULL; - req = (ZigbeeAlarmResetAlarm_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclAlarmResetAlarm_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: { - ZigbeeAlarmResetAllAlarm_t *req = NULL; + case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: { + ZigbeeZclAlarmResetAllAlarm_t *req = NULL; - req = (ZigbeeAlarmResetAllAlarm_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclAlarmResetAllAlarm_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ALARM_OPS_ALARM: { - ZigbeeAlarmAlarm_t *req = NULL; + case ZBLIB_ZCL_ALARM_OPS_ALARM: { + ZigbeeZclAlarmAlarm_t *req = NULL; - req = (ZigbeeAlarmAlarm_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclAlarmAlarm_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: { - ZigbeeAlarmResetAlarmLogs_t *req = NULL; + case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: { + ZigbeeZclAlarmResetAlarmLogs_t *req = NULL; - req = (ZigbeeAlarmResetAlarmLogs_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclAlarmResetAlarmLogs_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ALARM_OPS_GET_ALARM: { + case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: { } break; @@ -3143,9 +3157,8 @@ static void __zblib_request_free_custom_request_data(ZigBeeRequest *request, ZigbeeCustomApsSend_t *req = NULL; req = (ZigbeeCustomApsSend_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3153,9 +3166,8 @@ static void __zblib_request_free_custom_request_data(ZigBeeRequest *request, ZigbeeCustomZclSend_t *req = NULL; req = (ZigbeeCustomZclSend_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3163,9 +3175,8 @@ static void __zblib_request_free_custom_request_data(ZigBeeRequest *request, ZigbeeCustomSendToLocal_t *req = NULL; req = (ZigbeeCustomSendToLocal_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3174,7 +3185,7 @@ static void __zblib_request_free_custom_request_data(ZigBeeRequest *request, } } -static void __zblib_request_free_door_lock_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zcl_door_lock_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -3182,43 +3193,39 @@ static void __zblib_request_free_door_lock_request_data(ZigBeeRequest *request, /* 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; + case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: { + ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL; - req = (ZigbeeDoorLockSubscriberLockEvent_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: { - ZigbeeDoorLockSetDoorLockPin_t *req = NULL; + case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: { + ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL; - req = (ZigbeeDoorLockSetDoorLockPin_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: { - ZigbeeDoorLockSetDoorLock_t *req = NULL; + case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: { + ZigbeeZclDoorLockSetDoorLock_t *req = NULL; - req = (ZigbeeDoorLockSetDoorLock_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclDoorLockSetDoorLock_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: { - ZigbeeDoorLockGetDoorLock_t *req = NULL; + case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: { + ZigbeeZclDoorLockGetDoorLock_t *req = NULL; - req = (ZigbeeDoorLockGetDoorLock_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclDoorLockGetDoorLock_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; @@ -3227,7 +3234,7 @@ static void __zblib_request_free_door_lock_request_data(ZigBeeRequest *request, } } -static void __zblib_request_free_fan_control_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zcl_fan_control_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -3235,43 +3242,39 @@ static void __zblib_request_free_fan_control_request_data(ZigBeeRequest *request /* 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; + case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: { + ZigbeeZclFanControlSetFanMode_t *req = NULL; - req = (ZigbeeFanControlSetFanMode_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclFanControlSetFanMode_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: { - ZigbeeFanControlGetFanMode_t *req = NULL; + case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: { + ZigbeeZclFanControlGetFanMode_t *req = NULL; - req = (ZigbeeFanControlGetFanMode_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclFanControlGetFanMode_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: { - ZigbeeFanControlSetFanModeSequence_t *req = NULL; + case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: { + ZigbeeZclFanControlSetFanModeSequence_t *req = NULL; - req = (ZigbeeFanControlSetFanModeSequence_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclFanControlSetFanModeSequence_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: { - ZigbeeFanControlGetFanModeSequence_t *req = NULL; + case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: { + ZigbeeZclFanControlGetFanModeSequence_t *req = NULL; - req = (ZigbeeFanControlGetFanModeSequence_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclFanControlGetFanModeSequence_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; @@ -3280,7 +3283,7 @@ static void __zblib_request_free_fan_control_request_data(ZigBeeRequest *request } } -static void __zblib_request_free_level_control_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zcl_level_control_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -3288,73 +3291,66 @@ static void __zblib_request_free_level_control_request_data(ZigBeeRequest *reque /* 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; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: { + ZigbeeZclLevelControlMoveToLevel_t *req = NULL; - req = (ZigbeeLevelControlMoveToLevel_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclLevelControlMoveToLevel_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_LEVEL_CONTROL_OPS_MOVE: { - ZigbeeLevelControlMove_t *req = NULL; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: { + ZigbeeZclLevelControlMove_t *req = NULL; - req = (ZigbeeLevelControlMove_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclLevelControlMove_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_LEVEL_CONTROL_OPS_STEP: { - ZigbeeLevelControlStep_t *req = NULL; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: { + ZigbeeZclLevelControlStep_t *req = NULL; - req = (ZigbeeLevelControlStep_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclLevelControlStep_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; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: { + ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL; - req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: { - ZigbeeLevelControlMoveWithOnOff_t *req = NULL; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: { + ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL; - req = (ZigbeeLevelControlMoveWithOnOff_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: { - ZigbeeLevelControlStepWithOnOff_t *req = NULL; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: { + ZigbeeZclLevelControlStepWithOnOff_t *req = NULL; - req = (ZigbeeLevelControlStepWithOnOff_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclLevelControlStepWithOnOff_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_LEVEL_CONTROL_OPS_STOP: { - ZigbeeLevelControlStop_t *req = NULL; + case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: { + ZigbeeZclLevelControlStop_t *req = NULL; - req = (ZigbeeLevelControlStop_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclLevelControlStop_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; @@ -3375,9 +3371,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlStart_t *req = NULL; req = (ZigbeeMfglibControlStart_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3385,9 +3380,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlEnd_t *req = NULL; req = (ZigbeeMfglibControlEnd_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3395,9 +3389,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlStartTone_t *req = NULL; req = (ZigbeeMfglibControlStartTone_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3405,9 +3398,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlStopTone_t *req = NULL; req = (ZigbeeMfglibControlStopTone_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3415,9 +3407,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlStartStream_t *req = NULL; req = (ZigbeeMfglibControlStartStream_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3425,9 +3416,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlStopStream_t *req = NULL; req = (ZigbeeMfglibControlStopStream_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3435,9 +3425,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlSendPacket_t *req = NULL; req = (ZigbeeMfglibControlSendPacket_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3445,9 +3434,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlSetChannel_t *req = NULL; req = (ZigbeeMfglibControlSetChannel_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3455,9 +3443,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlGetChannel_t *req = NULL; req = (ZigbeeMfglibControlGetChannel_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3465,9 +3452,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlSetPower_t *req = NULL; req = (ZigbeeMfglibControlSetPower_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3475,9 +3461,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlGetPower_t *req = NULL; req = (ZigbeeMfglibControlGetPower_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3485,9 +3470,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlSetSynOffset_t *req = NULL; req = (ZigbeeMfglibControlSetSynOffset_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3495,9 +3479,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlGetSynOffset_t *req = NULL; req = (ZigbeeMfglibControlGetSynOffset_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3505,9 +3488,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlRxStart_t *req = NULL; req = (ZigbeeMfglibControlRxStart_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3515,9 +3497,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlRxStop_t *req = NULL; req = (ZigbeeMfglibControlRxStop_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3525,9 +3506,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlRxVerify_t *req = NULL; req = (ZigbeeMfglibControlRxVerify_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3535,9 +3515,8 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ ZigbeeMfglibControlGetRssi_t *req = NULL; req = (ZigbeeMfglibControlGetRssi_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3546,7 +3525,7 @@ static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *requ } } -static void __zblib_request_free_on_off_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zcl_on_off_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -3554,23 +3533,21 @@ static void __zblib_request_free_on_off_request_data(ZigBeeRequest *request, /* 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; + case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: { + ZigbeeZclOnOffSetOnOff_t *req = NULL; - req = (ZigbeeOnOffSetOnOff_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclOnOffSetOnOff_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: { - ZigbeeOnOffGetOnOffState_t *req = NULL; + case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: { + ZigbeeZclOnOffGetOnOffState_t *req = NULL; - req = (ZigbeeOnOffGetOnOffState_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclOnOffGetOnOffState_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; @@ -3587,14 +3564,6 @@ static void __zblib_request_free_service_request_data(ZigBeeRequest *request, /* Fetch ops ID */ ops_id = __zblib_request_get_ops_id(request_type); switch (ops_id) { - case ZBLIB_SERVICE_OPS_ENABLE: { - } - break; - - case ZBLIB_SERVICE_OPS_DISABLE: { - } - break; - case ZBLIB_SERVICE_OPS_ZB_HW_RESET: { } break; @@ -3607,9 +3576,8 @@ static void __zblib_request_free_service_request_data(ZigBeeRequest *request, ZigbeeServiceCoexStart_t *req = NULL; req = (ZigbeeServiceCoexStart_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3629,9 +3597,8 @@ static void __zblib_request_free_service_request_data(ZigBeeRequest *request, ZigbeeServicePermitJoin_t *req = NULL; req = (ZigbeeServicePermitJoin_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3639,9 +3606,8 @@ static void __zblib_request_free_service_request_data(ZigBeeRequest *request, ZigbeeServiceLeaveRequest_t *req = NULL; req = (ZigbeeServiceLeaveRequest_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3661,9 +3627,8 @@ static void __zblib_request_free_service_request_data(ZigBeeRequest *request, ZigbeeServiceGetEndpointList_t *req = NULL; req = (ZigbeeServiceGetEndpointList_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3671,9 +3636,8 @@ static void __zblib_request_free_service_request_data(ZigBeeRequest *request, ZigbeeServiceGetClusterList_t *req = NULL; req = (ZigbeeServiceGetClusterList_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3681,9 +3645,8 @@ static void __zblib_request_free_service_request_data(ZigBeeRequest *request, ZigbeeServiceGetNodeType_t *req = NULL; req = (ZigbeeServiceGetNodeType_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -3692,7 +3655,7 @@ static void __zblib_request_free_service_request_data(ZigBeeRequest *request, } } -static void __zblib_request_free_thermostat_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zcl_thermostat_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -3700,53 +3663,48 @@ static void __zblib_request_free_thermostat_request_data(ZigBeeRequest *request, /* 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; + case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: { + ZigbeeZclThermostatGetLocalTemp_t *req = NULL; - req = (ZigbeeThermostatGetLocalTemp_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclThermostatGetLocalTemp_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: { - ZigbeeThermostatGetWeeklySchedule_t *req = NULL; + case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: { + ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL; - req = (ZigbeeThermostatGetWeeklySchedule_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: { - ZigbeeThermostatSetWeeklySchedule_t *req = NULL; + case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: { + ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL; - req = (ZigbeeThermostatSetWeeklySchedule_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: { - ZigbeeThermostatClearWeeklySchedule_t *req = NULL; + case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: { + ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL; - req = (ZigbeeThermostatClearWeeklySchedule_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: { - ZigbeeThermostatSetpointRaiseLower_t *req = NULL; + case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: { + ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL; - req = (ZigbeeThermostatSetpointRaiseLower_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; @@ -3755,7 +3713,7 @@ static void __zblib_request_free_thermostat_request_data(ZigBeeRequest *request, } } -static void __zblib_request_free_zclbasic_control_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zcl_basic_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -3763,13 +3721,12 @@ static void __zblib_request_free_zclbasic_control_request_data(ZigBeeRequest *re /* 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; + case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: { + ZigbeeZclBasicResetFactoryDefault_t *req = NULL; - req = (ZigbeeZclbasicControlResetFactoryDefault_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclBasicResetFactoryDefault_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; @@ -3778,7 +3735,7 @@ static void __zblib_request_free_zclbasic_control_request_data(ZigBeeRequest *re } } -static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zcl_global_control_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -3786,10 +3743,10 @@ static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *r /* 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; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: { + ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL; - req = (ZigbeeZclglobalControlReadAttributesRequest_t *)request->request_data; + req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request->request_data; if (NULL != req) { g_free(req->attribute_id); g_free(req); @@ -3797,10 +3754,10 @@ static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *r } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: { - ZigbeeZclglobalControlWriteAttributesRequest_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: { + ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL; - req = (ZigbeeZclglobalControlWriteAttributesRequest_t *)request->request_data; + req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request->request_data; if (NULL != req) { g_free(req->write_records); g_free(req); @@ -3808,10 +3765,10 @@ static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *r } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: { - ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: { + ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL; - req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *)request->request_data; + req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request->request_data; if (NULL != req) { g_free(req->write_records); g_free(req); @@ -3819,10 +3776,10 @@ static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *r } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: { - ZigbeeZclglobalControlWriteAttributesNoResponse_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: { + ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL; - req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *)request->request_data; + req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request->request_data; if (NULL != req) { g_free(req->write_records); g_free(req); @@ -3830,10 +3787,10 @@ static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *r } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: { - ZigbeeZclglobalControlWriteAttributesStructed_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: { + ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL; - req = (ZigbeeZclglobalControlWriteAttributesStructed_t *)request->request_data; + req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request->request_data; if (NULL != req) { g_free(req->write_records); g_free(req); @@ -3841,10 +3798,10 @@ static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *r } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: { - ZigbeeZclglobalControlReadAttributesStructed_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: { + ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL; - req = (ZigbeeZclglobalControlReadAttributesStructed_t *)request->request_data; + req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request->request_data; if (NULL != req) { g_free(req->read_records); g_free(req); @@ -3852,10 +3809,10 @@ static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *r } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: { - ZigbeeZclglobalControlConfigureReportingReq_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: { + ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL; - req = (ZigbeeZclglobalControlConfigureReportingReq_t *)request->request_data; + req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request->request_data; if (NULL != req) { g_free(req->read_records); g_free(req); @@ -3863,10 +3820,10 @@ static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *r } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: { - ZigbeeZclglobalControlReadConfigureReporting_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: { + ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL; - req = (ZigbeeZclglobalControlReadConfigureReporting_t *)request->request_data; + req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request->request_data; if (NULL != req) { g_free(req->read_records); g_free(req); @@ -3874,43 +3831,39 @@ static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *r } break; - case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: { - ZigbeeZclglobalControlDiscoverAttributes_t *req = NULL; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: { + ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL; - req = (ZigbeeZclglobalControlDiscoverAttributes_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: { + ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL; - req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: { + ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL; - req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: { + ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL; - req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; @@ -3919,7 +3872,7 @@ static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *r } } -static void __zblib_request_free_zclias_control_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zcl_ias_zone_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -3927,13 +3880,12 @@ static void __zblib_request_free_zclias_control_request_data(ZigBeeRequest *requ /* 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; + case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: { + ZigbeeZclIasZoneEnrollResponse_t *req = NULL; - req = (ZigbeeZcliasControlEnrolResponse_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclIasZoneEnrollResponse_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; @@ -3942,7 +3894,7 @@ static void __zblib_request_free_zclias_control_request_data(ZigBeeRequest *requ } } -static void __zblib_request_free_zclidentify_control_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zcl_identify_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -3950,23 +3902,21 @@ static void __zblib_request_free_zclidentify_control_request_data(ZigBeeRequest /* 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; + case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: { + ZigbeeZclIdentifyIdentify_t *req = NULL; - req = (ZigbeeZclidentifyControlIdentify_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclIdentifyIdentify_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: { - ZigbeeZclidentifyControlQuery_t *req = NULL; + case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: { + ZigbeeZclIdentifyQuery_t *req = NULL; - req = (ZigbeeZclidentifyControlQuery_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclIdentifyQuery_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; @@ -3975,7 +3925,7 @@ static void __zblib_request_free_zclidentify_control_request_data(ZigBeeRequest } } -static void __zblib_request_free_zcl_color_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zcl_color_control_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -3983,113 +3933,102 @@ static void __zblib_request_free_zcl_color_request_data(ZigBeeRequest *request, /* 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; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: { + ZigbeeZclColorControlMoveToHue_t *req = NULL; - req = (ZigbeeZclColorMoveToHue_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclColorControlMoveToHue_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: { - ZigbeeZclColorMoveHue_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: { + ZigbeeZclColorControlMoveHue_t *req = NULL; - req = (ZigbeeZclColorMoveHue_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclColorControlMoveHue_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: { - ZigbeeZclColorStepHue_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: { + ZigbeeZclColorControlStepHue_t *req = NULL; - req = (ZigbeeZclColorStepHue_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclColorControlStepHue_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: { - ZigbeeZclColorMoveToSaturation_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: { + ZigbeeZclColorControlMoveToSaturation_t *req = NULL; - req = (ZigbeeZclColorMoveToSaturation_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclColorControlMoveToSaturation_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: { - ZigbeeZclColorMoveSaturation_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: { + ZigbeeZclColorControlMoveSaturation_t *req = NULL; - req = (ZigbeeZclColorMoveSaturation_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclColorControlMoveSaturation_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: { - ZigbeeZclColorStepSaturation_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: { + ZigbeeZclColorControlStepSaturation_t *req = NULL; - req = (ZigbeeZclColorStepSaturation_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclColorControlStepSaturation_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; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: { + ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL; - req = (ZigbeeZclColorMoveToHueAndSaturation_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: { - ZigbeeZclColorMoveToColor_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: { + ZigbeeZclColorControlMoveToColor_t *req = NULL; - req = (ZigbeeZclColorMoveToColor_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclColorControlMoveToColor_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: { - ZigbeeZclColorMoveColor_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: { + ZigbeeZclColorControlMoveColor_t *req = NULL; - req = (ZigbeeZclColorMoveColor_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclColorControlMoveColor_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: { - ZigbeeZclColorStepColor_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: { + ZigbeeZclColorControlStepColor_t *req = NULL; - req = (ZigbeeZclColorStepColor_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclColorControlStepColor_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: { - ZigbeeZclColorMoveColorTemperature_t *req = NULL; + case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: { + ZigbeeZclColorControlMoveColorTemperature_t *req = NULL; - req = (ZigbeeZclColorMoveColorTemperature_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZclColorControlMoveColorTemperature_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; @@ -4110,9 +4049,8 @@ static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request, ZigbeeZclGroupAddGroup_t *req = NULL; req = (ZigbeeZclGroupAddGroup_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4120,9 +4058,8 @@ static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request, ZigbeeZclGroupViewGroup_t *req = NULL; req = (ZigbeeZclGroupViewGroup_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4141,9 +4078,8 @@ static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request, ZigbeeZclGroupRemoveGroup_t *req = NULL; req = (ZigbeeZclGroupRemoveGroup_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4151,9 +4087,8 @@ static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request, ZigbeeZclGroupRemoveAllGroup_t *req = NULL; req = (ZigbeeZclGroupRemoveAllGroup_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4161,9 +4096,8 @@ static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request, ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL; req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4184,9 +4118,8 @@ static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *re ZigbeeZclPollControlCheckInResponse_t *req = NULL; req = (ZigbeeZclPollControlCheckInResponse_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4194,9 +4127,8 @@ static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *re ZigbeeZclPollControlFastPollStop_t *req = NULL; req = (ZigbeeZclPollControlFastPollStop_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4204,9 +4136,8 @@ static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *re ZigbeeZclPollControlSetLongPollInterval_t *req = NULL; req = (ZigbeeZclPollControlSetLongPollInterval_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4214,9 +4145,8 @@ static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *re ZigbeeZclPollControlSetShortPollInterval_t *req = NULL; req = (ZigbeeZclPollControlSetShortPollInterval_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4248,9 +4178,8 @@ static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request, ZigbeeZclSceneViewScene_t *req = NULL; req = (ZigbeeZclSceneViewScene_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4258,9 +4187,8 @@ static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request, ZigbeeZclSceneRemoveScene_t *req = NULL; req = (ZigbeeZclSceneRemoveScene_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4268,9 +4196,8 @@ static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request, ZigbeeZclSceneStoreScene_t *req = NULL; req = (ZigbeeZclSceneStoreScene_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4278,9 +4205,8 @@ static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request, ZigbeeZclSceneRecallScene_t *req = NULL; req = (ZigbeeZclSceneRecallScene_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4288,9 +4214,8 @@ static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request, ZigbeeZclSceneRemoveAllScene_t *req = NULL; req = (ZigbeeZclSceneRemoveAllScene_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4298,9 +4223,8 @@ static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request, ZigbeeZclSceneGetSceneMembership_t *req = NULL; req = (ZigbeeZclSceneGetSceneMembership_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4309,7 +4233,7 @@ static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request, } } -static void __zblib_request_free_zdodev_control_request_data(ZigBeeRequest *request, +static void __zblib_request_free_zdo_dev_control_request_data(ZigBeeRequest *request, guint request_type) { guint ops_id; @@ -4317,20 +4241,19 @@ static void __zblib_request_free_zdodev_control_request_data(ZigBeeRequest *requ /* 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: { + ZigbeeZdoDevControlNwkAddrReq_t *req = NULL; - req = (ZigbeeZdodevControlNwkAddrReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: { + ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL; - req = (ZigbeeZdodevControlMatchedDescriptorReq_t *)request->request_data; + req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request->request_data; if (NULL != req) { g_free(req->in_cl); g_free(req->out_cl); @@ -4339,153 +4262,138 @@ static void __zblib_request_free_zdodev_control_request_data(ZigBeeRequest *requ } break; - case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: { - ZigbeeZdodevControlIeeeAddrReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: { + ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL; - req = (ZigbeeZdodevControlIeeeAddrReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: { + ZigbeeZdoDevControlActiveEpReq_t *req = NULL; - req = (ZigbeeZdodevControlActiveEpReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: { + ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL; - req = (ZigbeeZdodevControlNodeDescriptorReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: { + ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL; - req = (ZigbeeZdodevControlPowerDescriptorReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: { + ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL; - req = (ZigbeeZdodevControlComplexDescriptorReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: { + ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL; - req = (ZigbeeZdodevControlUserDescriptorReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: { + ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL; - req = (ZigbeeZdodevControlUserDescriptorSetReq_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: { - ZigbeeZdodevControlDeviceAnnounce_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: { + ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL; - req = (ZigbeeZdodevControlDeviceAnnounce_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: { + ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL; - req = (ZigbeeZdodevControlSimpleDescriptorReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: { + ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL; - req = (ZigbeeZdodevControlMgmtLqiReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: { + ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL; - req = (ZigbeeZdodevControlMgmtRtgReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: { + ZigbeeZdoDevControlMgmtBindReq_t *req = NULL; - req = (ZigbeeZdodevControlMgmtBindReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: { + ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL; - req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *)request->request_data; - if (NULL != req) { + 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; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_UPDATE_REQ: { + ZigbeeZdoDevControlMgmtNwkUpdateReq_t *req = NULL; - req = (ZigbeeZdodevControlNwkUpdateReq_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; - case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: { - ZigbeeZdodevControlNwkDescriptorReq_t *req = NULL; + case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_DISC_REQ: { + ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *req = NULL; - req = (ZigbeeZdodevControlNwkDescriptorReq_t *)request->request_data; - if (NULL != req) { + req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *)request->request_data; + if (NULL != req) g_free(req); - } } break; @@ -4506,9 +4414,8 @@ static void __zblib_request_free_zdo_bind_request_data(ZigBeeRequest *request, ZigbeeZdoBindBindReq_t *req = NULL; req = (ZigbeeZdoBindBindReq_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4516,9 +4423,8 @@ static void __zblib_request_free_zdo_bind_request_data(ZigBeeRequest *request, ZigbeeZdoBindUnbindReq_t *req = NULL; req = (ZigbeeZdoBindUnbindReq_t *)request->request_data; - if (NULL != req) { + if (NULL != req) g_free(req); - } } break; @@ -4539,8 +4445,8 @@ static void __zblib_request_free_request_data(ZigBeeRequest *request) /* Fetch driver type */ driver_type = __zblib_request_get_driver_type(request_type); switch (driver_type) { - case ZBLIB_DRIVER_TYPE_ALARM: { - __zblib_request_free_alarm_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZCL_ALARM: { + __zblib_request_free_zcl_alarm_request_data(request, request_type); } break; @@ -4549,18 +4455,18 @@ static void __zblib_request_free_request_data(ZigBeeRequest *request) } break; - case ZBLIB_DRIVER_TYPE_DOOR_LOCK: { - __zblib_request_free_door_lock_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: { + __zblib_request_free_zcl_door_lock_request_data(request, request_type); } break; - case ZBLIB_DRIVER_TYPE_FAN_CONTROL: { - __zblib_request_free_fan_control_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: { + __zblib_request_free_zcl_fan_control_request_data(request, request_type); } break; - case ZBLIB_DRIVER_TYPE_LEVEL_CONTROL: { - __zblib_request_free_level_control_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: { + __zblib_request_free_zcl_level_control_request_data(request, request_type); } break; @@ -4569,8 +4475,8 @@ static void __zblib_request_free_request_data(ZigBeeRequest *request) } break; - case ZBLIB_DRIVER_TYPE_ON_OFF: { - __zblib_request_free_on_off_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: { + __zblib_request_free_zcl_on_off_request_data(request, request_type); } break; @@ -4579,33 +4485,33 @@ static void __zblib_request_free_request_data(ZigBeeRequest *request) } break; - case ZBLIB_DRIVER_TYPE_THERMOSTAT: { - __zblib_request_free_thermostat_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: { + __zblib_request_free_zcl_thermostat_request_data(request, request_type); } break; - case ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL: { - __zblib_request_free_zclbasic_control_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZCL_BASIC: { + __zblib_request_free_zcl_basic_request_data(request, request_type); } break; - case ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL: { - __zblib_request_free_zclglobal_control_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: { + __zblib_request_free_zcl_global_control_request_data(request, request_type); } break; - case ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL: { - __zblib_request_free_zclias_control_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: { + __zblib_request_free_zcl_ias_zone_request_data(request, request_type); } break; - case ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL: { - __zblib_request_free_zclidentify_control_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: { + __zblib_request_free_zcl_identify_request_data(request, request_type); } break; - case ZBLIB_DRIVER_TYPE_ZCL_COLOR: { - __zblib_request_free_zcl_color_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: { + __zblib_request_free_zcl_color_control_request_data(request, request_type); } break; @@ -4624,8 +4530,8 @@ static void __zblib_request_free_request_data(ZigBeeRequest *request) } break; - case ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL: { - __zblib_request_free_zdodev_control_request_data(request, request_type); + case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: { + __zblib_request_free_zdo_dev_control_request_data(request, request_type); } break; @@ -4634,7 +4540,7 @@ static void __zblib_request_free_request_data(ZigBeeRequest *request) } break; - case ZBLIB_DRIVER_TYPE_NONE: /* Fallthrough */ + case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */ default: { Z_LOGE("Unhandled driver type: [%d]", driver_type); } @@ -4691,7 +4597,7 @@ gint zblib_request_new(ZigBeeServiceInterface *service_interface, } /* Insert request to request table */ - g_hash_table_insert(request_table, (gpointer)(request->request_id), request); + g_hash_table_insert(request_table, GINT_TO_POINTER(request->request_id), request); return request->request_id; } @@ -4724,7 +4630,7 @@ gboolean zblib_request_set_response_cb(ZigBeeServiceInterface *service_interface ZigBeeService *service = NULL; ZigBeeRequest *request = NULL; - zblib_check_null_ret_error("request", request, FALSE); + zblib_check_null_ret_error("service_interface", service_interface, FALSE); /* Fetch service */ service = zblib_service_interface_ref_service(service_interface); @@ -4750,7 +4656,7 @@ gpointer zblib_request_ref_response_cb(ZigBeeServiceInterface *service_interface ZigBeeService *service = NULL; ZigBeeRequest *request = NULL; - zblib_check_null_ret_error("request", request, NULL); + zblib_check_null_ret_error("service_interface", service_interface, NULL); /* Fetch service */ service = zblib_service_interface_ref_service(service_interface);