guint ref_count; /* Reference count */
gpointer request_data; /**< Request data */
+ gpointer resp_cb; /**< Response callback */
+ gpointer resp_cb_data; /**< Response callback data */
ZigBeeServiceInterface *service_interface; /* Service interface */
};
return ops_id;
}
+static ZigBeeRequest *__zblib_request_ref_request_by_by_request_id(ZigBeeService *service,
+ guint request_id)
+{
+ ZigBeeRequest *request = NULL;
+ GHashTable *request_table = NULL;
+
+ /* Fetch request table from service */
+ request_table = zblib_service_ref_request_hash_table(service);
+ if (NULL == request_table) {
+ Z_LOGE("zblib_service_ref_request_hash_table failed!");
+ return NULL;
+ }
+
+ /* Look-up requets_id in request hash table */
+ request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id);
+ if (NULL == request) {
+ Z_LOGE("No request available for request_id: [%d]", request_id);
+ return NULL;
+ }
+
+ return request;
+}
+
+static gint __zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
+ guint request_id)
+{
+ ZigBeeRequest *request = NULL;
+
+ /* Fetch request based on request_id */
+ request = __zblib_request_ref_request_by_by_request_id(service, request_id);
+ if (NULL == request) {
+ Z_LOGE("No request available for request_id: [%d]", request_id);
+ return -1;
+ }
+
+ return (gint)(request->request_type);
+}
+
+static ZigBeeRequest *__zblib_request_ref_request_by_request_id(ZigBeeService *service,
+ guint request_id)
+{
+ ZigBeeRequest *request = NULL;
+ GHashTable *request_table = NULL;
+
+ /* Fetch request table from service */
+ request_table = zblib_service_ref_request_hash_table(service);
+ if (NULL == request_table) {
+ Z_LOGE("zblib_service_ref_request_hash_table failed!");
+ return NULL;
+ }
+
+ /* Look-up requets_id in request hash table */
+ request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id);
+ if (NULL == request_table) {
+ Z_LOGE("No request availabel for request_id: [%d]", request_id);
+ return NULL;
+ }
+
+ return request;
+}
+
static gpointer __zblib_request_create_alarm_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer alarm_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
NOT_USED(request_data_len);
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ALARM_OPS_GET_ALARM_COUNT: {
+ ZigbeeAlarmGetAlarmCount_t *in_req;
+ ZigbeeAlarmGetAlarmCount_t *req = NULL;
+
+ in_req = (ZigbeeAlarmGetAlarmCount_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeAlarmGetAlarmCount_t *)
+ g_malloc0(sizeof(ZigbeeAlarmGetAlarmCount_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ }
+
+ alarm_request_data = (gpointer)req;
}
break;
case ZBLIB_ALARM_OPS_RESET_ALARM: {
+ ZigbeeAlarmResetAlarm_t *in_req;
+ ZigbeeAlarmResetAlarm_t *req = NULL;
+
+ in_req = (ZigbeeAlarmResetAlarm_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeAlarmResetAlarm_t *)
+ g_malloc0(sizeof(ZigbeeAlarmResetAlarm_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ req->alarm_code = in_req->alarm_code;
+ req->cluster_id = in_req->cluster_id;
+ }
+
+ alarm_request_data = (gpointer)req;
}
break;
case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: {
+ ZigbeeAlarmResetAllAlarm_t *in_req;
+ ZigbeeAlarmResetAllAlarm_t *req = NULL;
+
+ in_req = (ZigbeeAlarmResetAllAlarm_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeAlarmResetAllAlarm_t *)
+ g_malloc0(sizeof(ZigbeeAlarmResetAllAlarm_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ }
+
+ alarm_request_data = (gpointer)req;
}
break;
case ZBLIB_ALARM_OPS_ALARM: {
+ ZigbeeAlarmAlarm_t *in_req;
+ ZigbeeAlarmAlarm_t *req = NULL;
+
+ in_req = (ZigbeeAlarmAlarm_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeAlarmAlarm_t *)
+ g_malloc0(sizeof(ZigbeeAlarmAlarm_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ req->alarm_code = in_req->alarm_code;
+ req->cluster_id = in_req->cluster_id;
+ }
+
+ alarm_request_data = (gpointer)req;
}
break;
case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: {
+ ZigbeeAlarmResetAlarmLogs_t *in_req;
+ ZigbeeAlarmResetAlarmLogs_t *req = NULL;
+
+ in_req = (ZigbeeAlarmResetAlarmLogs_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeAlarmResetAlarmLogs_t *)
+ g_malloc0(sizeof(ZigbeeAlarmResetAlarmLogs_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ }
+
+ alarm_request_data = (gpointer)req;
}
break;
case ZBLIB_ALARM_OPS_GET_ALARM: {
+ alarm_request_data = NULL;
}
break;
gpointer custom_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
NOT_USED(request_data_len);
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_CUSTOM_OPS_APS_SEND: {
+ ZigbeeCustomApsSend_t *in_req;
+ ZigbeeCustomApsSend_t *req = NULL;
+
+ in_req = (ZigbeeCustomApsSend_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeCustomApsSend_t *)
+ g_malloc0(sizeof(ZigbeeCustomApsSend_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->aps_frame_ctrl = in_req->aps_frame_ctrl;
+ req->src_ep = in_req->src_ep;
+ req->dest_ep = in_req->dest_ep;
+ req->cluster_id = in_req->cluster_id;
+ req->profile_id = in_req->profile_id;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->mfg_code = in_req->mfg_code;
+ memcpy(req->payload,
+ in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
+ }
+
+ custom_request_data = (gpointer)req;
}
break;
case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
+ ZigbeeCustomZclSend_t *in_req;
+ ZigbeeCustomZclSend_t *req = NULL;
+
+ in_req = (ZigbeeCustomZclSend_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeCustomZclSend_t *)
+ g_malloc0(sizeof(ZigbeeCustomZclSend_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->src_ep = in_req->src_ep;
+ req->dest_ep = in_req->dest_ep;
+ req->cluster_id = in_req->cluster_id;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->cmd_id = in_req->cmd_id;
+ memcpy(req->payload,
+ in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
+ }
+
+ custom_request_data = (gpointer)req;
}
break;
case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
+ ZigbeeCustomSendToLocal_t *in_req;
+ ZigbeeCustomSendToLocal_t *req = NULL;
+
+ in_req = (ZigbeeCustomSendToLocal_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeCustomSendToLocal_t *)
+ g_malloc0(sizeof(ZigbeeCustomSendToLocal_t));
+
+ /* Copy data */
+ memcpy(req->data,
+ in_req->data, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
+ }
+
+ custom_request_data = (gpointer)req;
}
break;
gpointer door_lock_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
NOT_USED(request_data_len);
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
+ ZigbeeDoorLockSubscriberLockEvent_t *in_req;
+ ZigbeeDoorLockSubscriberLockEvent_t *req = NULL;
+
+ in_req = (ZigbeeDoorLockSubscriberLockEvent_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeDoorLockSubscriberLockEvent_t *)
+ g_malloc0(sizeof(ZigbeeDoorLockSubscriberLockEvent_t));
+
+ /* Copy data */
+ memcpy(req->eui64,
+ in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ }
+
+ door_lock_request_data = (gpointer)req;
}
break;
case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
+ ZigbeeDoorLockSetDoorLockPin_t *in_req;
+ ZigbeeDoorLockSetDoorLockPin_t *req = NULL;
+
+ in_req = (ZigbeeDoorLockSetDoorLockPin_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeDoorLockSetDoorLockPin_t *)
+ g_malloc0(sizeof(ZigbeeDoorLockSetDoorLockPin_t));
+
+ /* Copy data */
+ req->uid = in_req->uid;
+ req->ustatus = in_req->ustatus;
+ req->utype = in_req->utype;
+ memcpy(req->eui64,
+ in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ memcpy(req->pin,
+ in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN);
+ }
+
+ door_lock_request_data = (gpointer)req;
}
break;
case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
+ ZigbeeDoorLockSetDoorLock_t *in_req;
+ ZigbeeDoorLockSetDoorLock_t *req = NULL;
+
+ in_req = (ZigbeeDoorLockSetDoorLock_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeDoorLockSetDoorLock_t *)
+ g_malloc0(sizeof(ZigbeeDoorLockSetDoorLock_t));
+
+ /* Copy data */
+ memcpy(req->eui64,
+ in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ memcpy(req->pin,
+ in_req->pin, ZIGBEE_DOOR_LOCK_MAX_PIN_LEN);
+ req->lock_unlock_type = in_req->lock_unlock_type;
+ }
+
+ door_lock_request_data = (gpointer)req;
}
break;
case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: {
+ ZigbeeDoorLockGetDoorLock_t *in_req;
+ ZigbeeDoorLockGetDoorLock_t *req = NULL;
+
+ in_req = (ZigbeeDoorLockGetDoorLock_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeDoorLockGetDoorLock_t *)
+ g_malloc0(sizeof(ZigbeeDoorLockGetDoorLock_t));
+
+ /* Copy data */
+ memcpy(req->eui64,
+ in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ }
+
+ door_lock_request_data = (gpointer)req;
}
break;
gpointer fan_control_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
NOT_USED(request_data_len);
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE: {
+ ZigbeeFanControlSetFanMode_t *in_req;
+ ZigbeeFanControlSetFanMode_t *req = NULL;
+
+ in_req = (ZigbeeFanControlSetFanMode_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeFanControlSetFanMode_t *)
+ g_malloc0(sizeof(ZigbeeFanControlSetFanMode_t));
+
+ /* Copy data */
+ memcpy(req->eui64,
+ in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ }
+
+ fan_control_request_data = (gpointer)req;
}
break;
case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: {
+ ZigbeeFanControlGetFanMode_t *in_req;
+ ZigbeeFanControlGetFanMode_t *req = NULL;
+
+ in_req = (ZigbeeFanControlGetFanMode_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeFanControlGetFanMode_t *)
+ g_malloc0(sizeof(ZigbeeFanControlGetFanMode_t));
+
+ /* Copy data */
+ memcpy(req->eui64,
+ in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ }
+
+ fan_control_request_data = (gpointer)req;
}
break;
case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
+ ZigbeeFanControlSetFanModeSequence_t *in_req;
+ ZigbeeFanControlSetFanModeSequence_t *req = NULL;
+
+ in_req = (ZigbeeFanControlSetFanModeSequence_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeFanControlSetFanModeSequence_t *)
+ g_malloc0(sizeof(ZigbeeFanControlSetFanModeSequence_t));
+
+ /* Copy data */
+ memcpy(req->eui64,
+ in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ }
+
+ fan_control_request_data = (gpointer)req;
}
break;
case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
+ ZigbeeFanControlGetFanModeSequence_t *in_req;
+ ZigbeeFanControlGetFanModeSequence_t *req = NULL;
+
+ in_req = (ZigbeeFanControlGetFanModeSequence_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeFanControlGetFanModeSequence_t *)
+ g_malloc0(sizeof(ZigbeeFanControlGetFanModeSequence_t));
+
+ /* Copy data */
+ memcpy(req->eui64,
+ in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ }
+
+ fan_control_request_data = (gpointer)req;
}
break;
gpointer level_control_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
NOT_USED(request_data_len);
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
+ ZigbeeLevelControlMoveToLevel_t *in_req;
+ ZigbeeLevelControlMoveToLevel_t *req = NULL;
+
+ in_req = (ZigbeeLevelControlMoveToLevel_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeLevelControlMoveToLevel_t *)
+ g_malloc0(sizeof(ZigbeeLevelControlMoveToLevel_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ req->level = in_req->level;
+ req->transition = in_req->transition;
+ }
+
+ level_control_request_data = (gpointer)req;
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_MOVE: {
+ ZigbeeLevelControlMove_t *in_req;
+ ZigbeeLevelControlMove_t *req = NULL;
+
+ in_req = (ZigbeeLevelControlMove_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeLevelControlMove_t *)
+ g_malloc0(sizeof(ZigbeeLevelControlMove_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ req->move_mode = in_req->move_mode;
+ req->rate = in_req->rate;
+ }
+
+ level_control_request_data = (gpointer)req;
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_STEP: {
+ ZigbeeLevelControlStep_t *in_req;
+ ZigbeeLevelControlStep_t *req = NULL;
+
+ in_req = (ZigbeeLevelControlStep_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeLevelControlStep_t *)
+ g_malloc0(sizeof(ZigbeeLevelControlStep_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ req->step_mode = in_req->step_mode;
+ req->move_mode = in_req->move_mode;
+ req->transition_time = in_req->transition_time;
+ }
+
+ level_control_request_data = (gpointer)req;
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
+ ZigbeeLevelControlMoveToLevelWithOnOff_t *in_req;
+ ZigbeeLevelControlMoveToLevelWithOnOff_t *req = NULL;
+
+ in_req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *)
+ g_malloc0(sizeof(ZigbeeLevelControlMoveToLevelWithOnOff_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ req->level = in_req->level;
+ req->transition = in_req->transition;
+ }
+
+ level_control_request_data = (gpointer)req;
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
+ ZigbeeLevelControlMoveWithOnOff_t *in_req;
+ ZigbeeLevelControlMoveWithOnOff_t *req = NULL;
+
+ in_req = (ZigbeeLevelControlMoveWithOnOff_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeLevelControlMoveWithOnOff_t *)
+ g_malloc0(sizeof(ZigbeeLevelControlMoveWithOnOff_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ req->move_mode = in_req->move_mode;
+ req->rate = in_req->rate;
+ }
+
+ level_control_request_data = (gpointer)req;
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
+ ZigbeeLevelControlStepWithOnOff_t *in_req;
+ ZigbeeLevelControlStepWithOnOff_t *req = NULL;
+
+ in_req = (ZigbeeLevelControlStepWithOnOff_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeLevelControlStepWithOnOff_t *)
+ g_malloc0(sizeof(ZigbeeLevelControlStepWithOnOff_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ req->step_mode = in_req->step_mode;
+ req->move_mode = in_req->move_mode;
+ req->transition_time = in_req->transition_time;
+ }
+
+ level_control_request_data = (gpointer)req;
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_STOP: {
+ ZigbeeLevelControlStop_t *in_req;
+ ZigbeeLevelControlStop_t *req = NULL;
+
+ in_req = (ZigbeeLevelControlStop_t *)request_data;
+ if (in_req) {
+ /* Allocate memory */
+ req = (ZigbeeLevelControlStop_t *)
+ g_malloc0(sizeof(ZigbeeLevelControlStop_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ }
+
+ level_control_request_data = (gpointer)req;
}
break;
gpointer mfglib_control_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
NOT_USED(request_data_len);
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_MFGLIB_CONTROL_OPS_START: {
+ ZigbeeMfglibControlStart_t *in_req;
+ ZigbeeMfglibControlStart_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlStart_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlStart_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlStart_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->mfglib_start = in_req->mfglib_start;
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_END: {
+ ZigbeeMfglibControlEnd_t *in_req;
+ ZigbeeMfglibControlEnd_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlEnd_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlEnd_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlEnd_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
+ ZigbeeMfglibControlStartTone_t *in_req;
+ ZigbeeMfglibControlStartTone_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlStartTone_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlStartTone_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlStartTone_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
+ ZigbeeMfglibControlStopTone_t *in_req;
+ ZigbeeMfglibControlStopTone_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlStopTone_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlStopTone_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlStopTone_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
+ ZigbeeMfglibControlStartStream_t *in_req;
+ ZigbeeMfglibControlStartStream_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlStartStream_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlStartStream_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlStartStream_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
+ ZigbeeMfglibControlStopStream_t *in_req;
+ ZigbeeMfglibControlStopStream_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlStopStream_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlStopStream_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlStopStream_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
+ ZigbeeMfglibControlSendPacket_t *in_req;
+ ZigbeeMfglibControlSendPacket_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlSendPacket_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlSendPacket_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlSendPacket_t));
+
+ /* Copy data */
+ memcpy(req->packet_content,
+ in_req->packet_content,
+ ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN);
+ req->packet_length = in_req->packet_length;
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
+ ZigbeeMfglibControlSetChannel_t *in_req;
+ ZigbeeMfglibControlSetChannel_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlSetChannel_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlSetChannel_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlSetChannel_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->channel = in_req->channel;
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
+ ZigbeeMfglibControlGetChannel_t *in_req;
+ ZigbeeMfglibControlGetChannel_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlGetChannel_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlGetChannel_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlGetChannel_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
+ ZigbeeMfglibControlSetPower_t *in_req;
+ ZigbeeMfglibControlSetPower_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlSetPower_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlSetPower_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlSetPower_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->tx_power_mode = in_req->tx_power_mode;
+ req->power = in_req->power;
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
+ ZigbeeMfglibControlGetPower_t *in_req;
+ ZigbeeMfglibControlGetPower_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlGetPower_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlGetPower_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlGetPower_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
+ ZigbeeMfglibControlSetSynOffset_t *in_req;
+ ZigbeeMfglibControlSetSynOffset_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlSetSynOffset_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlSetSynOffset_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlSetSynOffset_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->channel = in_req->channel;
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
+ ZigbeeMfglibControlGetSynOffset_t *in_req;
+ ZigbeeMfglibControlGetSynOffset_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlGetSynOffset_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlGetSynOffset_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlGetSynOffset_t));
+
+ /* Copy data */
+ memcpy(req->packet,
+ in_req->packet,
+ ZIGBEE_MFGLIB_CONTROL_PACKET_CONTENT_LEN);
+ req->packet_length = in_req->packet_length;
+ req->link_quality = in_req->link_quality;
+ req->rssi = in_req->rssi;
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
+ ZigbeeMfglibControlRxStart_t *in_req;
+ ZigbeeMfglibControlRxStart_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlRxStart_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlRxStart_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlRxStart_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
+ ZigbeeMfglibControlRxStop_t *in_req;
+ ZigbeeMfglibControlRxStop_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlRxStop_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlRxStop_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlRxStop_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
+ ZigbeeMfglibControlRxVerify_t *in_req;
+ ZigbeeMfglibControlRxVerify_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlRxVerify_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlRxVerify_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlRxVerify_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
+ ZigbeeMfglibControlGetRssi_t *in_req;
+ ZigbeeMfglibControlGetRssi_t *req = NULL;
+
+ in_req = (ZigbeeMfglibControlGetRssi_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeMfglibControlGetRssi_t *)
+ g_malloc0(sizeof(ZigbeeMfglibControlGetRssi_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ mfglib_control_request_data = (gpointer)req;
}
break;
gpointer on_off_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
NOT_USED(request_data_len);
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ON_OFF_OPS_SET_ON_OFF: {
+ ZigbeeOnOffSetOnOff_t *in_req;
+ ZigbeeOnOffSetOnOff_t *req = NULL;
+
+ in_req = (ZigbeeOnOffSetOnOff_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeOnOffSetOnOff_t *)
+ g_malloc0(sizeof(ZigbeeOnOffSetOnOff_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ req->on_off_type = in_req->on_off_type;
+ }
+
+ on_off_request_data = (gpointer)req;
}
break;
case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: {
+ ZigbeeOnOffGetOnOffState_t *in_req;
+ ZigbeeOnOffGetOnOffState_t *req = NULL;
+
+ in_req = (ZigbeeOnOffGetOnOffState_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeOnOffGetOnOffState_t *)
+ g_malloc0(sizeof(ZigbeeOnOffGetOnOffState_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ }
+
+ on_off_request_data = (gpointer)req;
}
break;
gpointer service_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
NOT_USED(request_data_len);
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_SERVICE_OPS_ENABLE: {
+ service_request_data = NULL;
}
break;
case ZBLIB_SERVICE_OPS_DISABLE: {
+ service_request_data = NULL;
}
break;
case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
+ service_request_data = NULL;
}
break;
case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
+ service_request_data = NULL;
}
break;
case ZBLIB_SERVICE_OPS_COEX_START: {
+ ZigbeeServiceCoexStart_t *in_req;
+ ZigbeeServiceCoexStart_t *req = NULL;
+
+ in_req = (ZigbeeServiceCoexStart_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeServiceCoexStart_t *)
+ g_malloc0(sizeof(ZigbeeServiceCoexStart_t));
+
+ /* Copy data */
+ req->channel = in_req->channel;
+ }
+
+ service_request_data = (gpointer)req;
}
break;
case ZBLIB_SERVICE_OPS_COEX_STOP: {
+ service_request_data = NULL;
}
break;
case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
+ service_request_data = NULL;
}
break;
case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
+ service_request_data = NULL;
}
break;
case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
+ ZigbeeServicePermitJoin_t *in_req;
+ ZigbeeServicePermitJoin_t *req = NULL;
+
+ in_req = (ZigbeeServicePermitJoin_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeServicePermitJoin_t *)
+ g_malloc0(sizeof(ZigbeeServicePermitJoin_t));
+
+ /* Copy data */
+ req->permit_join = in_req->permit_join;
+ req->duration = in_req->duration;
+ }
+
+ service_request_data = (gpointer)req;
}
break;
case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
+ ZigbeeServiceLeaveRequest_t *in_req;
+ ZigbeeServiceLeaveRequest_t *req = NULL;
+
+ in_req = (ZigbeeServiceLeaveRequest_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeServiceLeaveRequest_t *)
+ g_malloc0(sizeof(ZigbeeServiceLeaveRequest_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->remove_child = in_req->remove_child;
+ req->rejoin = in_req->rejoin;
+ }
+
+ service_request_data = (gpointer)req;
}
break;
case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
+ service_request_data = NULL;
}
break;
case ZBLIB_SERVICE_OPS_GET_MAC: {
+ service_request_data = NULL;
}
break;
case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
+ service_request_data = NULL;
}
break;
case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
+ ZigbeeServiceGetEndpointList_t *in_req;
+ ZigbeeServiceGetEndpointList_t *req = NULL;
+
+ in_req = (ZigbeeServiceGetEndpointList_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeServiceGetEndpointList_t *)
+ g_malloc0(sizeof(ZigbeeServiceGetEndpointList_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ service_request_data = (gpointer)req;
}
break;
case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
+ ZigbeeServiceGetClusterList_t *in_req;
+ ZigbeeServiceGetClusterList_t *req = NULL;
+
+ in_req = (ZigbeeServiceGetClusterList_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeServiceGetClusterList_t *)
+ g_malloc0(sizeof(ZigbeeServiceGetClusterList_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ }
+
+ service_request_data = (gpointer)req;
}
break;
case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
+ ZigbeeServiceGetNodeType_t *in_req;
+ ZigbeeServiceGetNodeType_t *req = NULL;
+
+ in_req = (ZigbeeServiceGetNodeType_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeServiceGetNodeType_t *)
+ g_malloc0(sizeof(ZigbeeServiceGetNodeType_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ }
+
+ service_request_data = (gpointer)req;
}
break;
gpointer thermostat_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
NOT_USED(request_data_len);
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
+ ZigbeeThermostatGetLocalTemp_t *in_req;
+ ZigbeeThermostatGetLocalTemp_t *req = NULL;
+
+ in_req = (ZigbeeThermostatGetLocalTemp_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeThermostatGetLocalTemp_t *)
+ g_malloc0(sizeof(ZigbeeThermostatGetLocalTemp_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ }
+
+ thermostat_request_data = (gpointer)req;
}
break;
case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
+ ZigbeeThermostatGetWeeklySchedule_t *in_req;
+ ZigbeeThermostatGetWeeklySchedule_t *req = NULL;
+
+ in_req = (ZigbeeThermostatGetWeeklySchedule_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeThermostatGetWeeklySchedule_t *)
+ g_malloc0(sizeof(ZigbeeThermostatGetWeeklySchedule_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ req->num_of_days = in_req->num_of_days;
+ req->mode = in_req->mode;
+ }
+
+ thermostat_request_data = (gpointer)req;
}
break;
case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
+ ZigbeeThermostatSetWeeklySchedule_t *in_req;
+ ZigbeeThermostatSetWeeklySchedule_t *req = NULL;
+
+ in_req = (ZigbeeThermostatSetWeeklySchedule_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeThermostatSetWeeklySchedule_t *)
+ g_malloc0(sizeof(ZigbeeThermostatSetWeeklySchedule_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ req->no_of_transitions = in_req->no_of_transitions;
+ req->num_of_days = in_req->num_of_days;
+ req->mode = in_req->mode;
+ memcpy(req->payload,
+ in_req->payload, ZIGBEE_THERMSTAT_PAYLOAD_MAX_LEN);
+ req->payload_len = in_req->payload_len;
+ }
+
+ thermostat_request_data = (gpointer)req;
}
break;
case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
+ ZigbeeThermostatClearWeeklySchedule_t *in_req;
+ ZigbeeThermostatClearWeeklySchedule_t *req = NULL;
+
+ in_req = (ZigbeeThermostatClearWeeklySchedule_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeThermostatClearWeeklySchedule_t *)
+ g_malloc0(sizeof(ZigbeeThermostatClearWeeklySchedule_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->endpoint = in_req->endpoint;
+ }
+
+ thermostat_request_data = (gpointer)req;
}
break;
case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
+ ZigbeeThermostatSetpointRaiseLower_t *in_req;
+ ZigbeeThermostatSetpointRaiseLower_t *req = NULL;
+
+ in_req = (ZigbeeThermostatSetpointRaiseLower_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeThermostatSetpointRaiseLower_t *)
+ g_malloc0(sizeof(ZigbeeThermostatSetpointRaiseLower_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ req->mode = in_req->mode;
+ req->amount = in_req->amount;
+ }
+
+ thermostat_request_data = (gpointer)req;
}
break;
return thermostat_request_data;
}
-static gpointer __zblib_request_create_zclbasic_control_request_data(guint request_type,
- gpointer request_data, guint request_data_len)
+static gpointer __zblib_request_create_zclbasic_control_request_data(guint request_type,
+ gpointer request_data, guint request_data_len)
+{
+ gpointer zclbasic_control_request_data = NULL;
+ guint ops_id;
+
+ NOT_USED(request_data_len);
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT: {
+ ZigbeeZclbasicControlResetFactoryDefault_t *in_req;
+ ZigbeeZclbasicControlResetFactoryDefault_t *req = NULL;
+
+ in_req = (ZigbeeZclbasicControlResetFactoryDefault_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclbasicControlResetFactoryDefault_t *)
+ g_malloc0(sizeof(ZigbeeZclbasicControlResetFactoryDefault_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zclbasic_control_request_data = (gpointer)req;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return zclbasic_control_request_data;
+}
+
+static gpointer __zblib_request_create_zclglobal_control_request_data(guint request_type,
+ gpointer request_data, guint request_data_len)
+{
+ gpointer zclglobal_control_request_data = NULL;
+ guint ops_id;
+
+ NOT_USED(request_data_len);
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
+ ZigbeeZclglobalControlReadAttributesRequest_t *in_req;
+ ZigbeeZclglobalControlReadAttributesRequest_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlReadAttributesRequest_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlReadAttributesRequest_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlReadAttributesRequest_t));
+
+ /* Copy data */
+ req->attribute_id = g_strdup(in_req->attribute_id);
+ req->attribute_id_len = in_req->attribute_id_len;
+ req->node_id = in_req->node_id;
+ req->cluster_id = in_req->cluster_id;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
+ ZigbeeZclglobalControlWriteAttributesRequest_t *in_req;
+ ZigbeeZclglobalControlWriteAttributesRequest_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlWriteAttributesRequest_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlWriteAttributesRequest_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesRequest_t));
+
+ /* Copy data */
+ req->write_records = g_strdup(in_req->write_records);
+ req->records_len = in_req->records_len;
+ req->node_id = in_req->node_id;
+ req->cluster_id = in_req->cluster_id;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->src_ep = in_req->src_ep;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
+ ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *in_req;
+ ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesUndividedRequest_t));
+
+ /* Copy data */
+ req->write_records = g_strdup(in_req->write_records);
+ req->records_len = in_req->records_len;
+ req->node_id = in_req->node_id;
+ req->cluster_id = in_req->cluster_id;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->src_ep = in_req->src_ep;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
+ ZigbeeZclglobalControlWriteAttributesNoResponse_t *in_req;
+ ZigbeeZclglobalControlWriteAttributesNoResponse_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesNoResponse_t));
+
+ /* Copy data */
+ req->write_records = g_strdup(in_req->write_records);
+ req->records_len = in_req->records_len;
+ req->node_id = in_req->node_id;
+ req->cluster_id = in_req->cluster_id;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->src_ep = in_req->src_ep;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
+ ZigbeeZclglobalControlWriteAttributesStructed_t *in_req;
+ ZigbeeZclglobalControlWriteAttributesStructed_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlWriteAttributesStructed_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlWriteAttributesStructed_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesStructed_t));
+
+ /* Copy data */
+ req->write_records = g_strdup(in_req->write_records);
+ req->records_len = in_req->records_len;
+ req->node_id = in_req->node_id;
+ req->cluster_id = in_req->cluster_id;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->src_ep = in_req->src_ep;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
+ ZigbeeZclglobalControlReadAttributesStructed_t *in_req;
+ ZigbeeZclglobalControlReadAttributesStructed_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlReadAttributesStructed_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlReadAttributesStructed_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlReadAttributesStructed_t));
+
+ /* Copy data */
+ req->read_records = g_strdup(in_req->read_records);
+ req->records_len = in_req->records_len;
+ req->node_id = in_req->node_id;
+ req->cluster_id = in_req->cluster_id;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->src_ep = in_req->src_ep;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
+ ZigbeeZclglobalControlConfigureReportingReq_t *in_req;
+ ZigbeeZclglobalControlConfigureReportingReq_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlConfigureReportingReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlConfigureReportingReq_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlConfigureReportingReq_t));
+
+ /* Copy data */
+ req->read_records = g_strdup(in_req->read_records);
+ req->records_len = in_req->records_len;
+ req->node_id = in_req->node_id;
+ req->cluster_id = in_req->cluster_id;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->src_ep = in_req->src_ep;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
+ ZigbeeZclglobalControlReadConfigureReporting_t *in_req;
+ ZigbeeZclglobalControlReadConfigureReporting_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlReadConfigureReporting_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlReadConfigureReporting_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlReadConfigureReporting_t));
+
+ /* Copy data */
+ req->read_records = g_strdup(in_req->read_records);
+ req->records_len = in_req->records_len;
+ req->node_id = in_req->node_id;
+ req->cluster_id = in_req->cluster_id;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->src_ep = in_req->src_ep;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
+ ZigbeeZclglobalControlDiscoverAttributes_t *in_req;
+ ZigbeeZclglobalControlDiscoverAttributes_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlDiscoverAttributes_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlDiscoverAttributes_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverAttributes_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->cluster_id = in_req->cluster_id;
+ req->start_attribute = in_req->start_attribute;
+ req->max = in_req->max;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
+ ZigbeeZclglobalControlDiscoverAttributesExtended_t *in_req;
+ ZigbeeZclglobalControlDiscoverAttributesExtended_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverAttributesExtended_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->cluster_id = in_req->cluster_id;
+ req->start_attribute = in_req->start_attribute;
+ req->max = in_req->max;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
+ ZigbeeZclglobalControlDiscoverCommandsReceived_t *in_req;
+ ZigbeeZclglobalControlDiscoverCommandsReceived_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverCommandsReceived_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->cluster_id = in_req->cluster_id;
+ req->start_attribute = in_req->start_attribute;
+ req->max = in_req->max;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
+ ZigbeeZclglobalControlDiscoverCommandsGenerated_t *in_req;
+ ZigbeeZclglobalControlDiscoverCommandsGenerated_t *req = NULL;
+
+ in_req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *)
+ g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverCommandsGenerated_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
+ req->cluster_id = in_req->cluster_id;
+ req->start_attribute = in_req->start_attribute;
+ req->max = in_req->max;
+ }
+
+ zclglobal_control_request_data = (gpointer)req;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return zclglobal_control_request_data;
+}
+
+static gpointer __zblib_request_create_zclias_control_request_data(guint request_type,
+ gpointer request_data, guint request_data_len)
+{
+ gpointer zclias_control_request_data = NULL;
+ guint ops_id;
+
+ NOT_USED(request_data_len);
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE: {
+ ZigbeeZcliasControlEnrolResponse_t *in_req;
+ ZigbeeZcliasControlEnrolResponse_t *req = NULL;
+
+ in_req = (ZigbeeZcliasControlEnrolResponse_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZcliasControlEnrolResponse_t *)
+ g_malloc0(sizeof(ZigbeeZcliasControlEnrolResponse_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->enroll_code = in_req->enroll_code;
+ req->zone_id = in_req->zone_id;
+ }
+
+ zclias_control_request_data = (gpointer)req;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return zclias_control_request_data;
+}
+
+static gpointer __zblib_request_create_zclidentify_control_request_data(guint request_type,
+ gpointer request_data, guint request_data_len)
+{
+ gpointer zclidentify_control_request_data = NULL;
+ guint ops_id;
+
+ NOT_USED(request_data_len);
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY: {
+ ZigbeeZclidentifyControlIdentify_t *in_req;
+ ZigbeeZclidentifyControlIdentify_t *req = NULL;
+
+ in_req = (ZigbeeZclidentifyControlIdentify_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclidentifyControlIdentify_t *)
+ g_malloc0(sizeof(ZigbeeZclidentifyControlIdentify_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->identify_time = in_req->identify_time;
+ }
+
+ zclidentify_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: {
+ ZigbeeZclidentifyControlQuery_t *in_req;
+ ZigbeeZclidentifyControlQuery_t *req = NULL;
+
+ in_req = (ZigbeeZclidentifyControlQuery_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclidentifyControlQuery_t *)
+ g_malloc0(sizeof(ZigbeeZclidentifyControlQuery_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ }
+
+ zclidentify_control_request_data = (gpointer)req;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return zclidentify_control_request_data;
+}
+
+static gpointer __zblib_request_create_zcl_color_request_data(guint request_type,
+ gpointer request_data, guint request_data_len)
+{
+ gpointer zcl_color_request_data = NULL;
+ guint ops_id;
+
+ NOT_USED(request_data_len);
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE: {
+ ZigbeeZclColorMoveToHue_t *in_req;
+ ZigbeeZclColorMoveToHue_t *req = NULL;
+
+ in_req = (ZigbeeZclColorMoveToHue_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclColorMoveToHue_t *)
+ g_malloc0(sizeof(ZigbeeZclColorMoveToHue_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->hue = in_req->hue;
+ req->direction = in_req->direction;
+ req->transition_time = in_req->transition_time;
+ }
+
+ zcl_color_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: {
+ ZigbeeZclColorMoveHue_t *in_req;
+ ZigbeeZclColorMoveHue_t *req = NULL;
+
+ in_req = (ZigbeeZclColorMoveHue_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclColorMoveHue_t *)
+ g_malloc0(sizeof(ZigbeeZclColorMoveHue_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->move_mode = in_req->move_mode;
+ req->rate = in_req->rate;
+ }
+
+ zcl_color_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: {
+ ZigbeeZclColorStepHue_t *in_req;
+ ZigbeeZclColorStepHue_t *req = NULL;
+
+ in_req = (ZigbeeZclColorStepHue_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclColorStepHue_t *)
+ g_malloc0(sizeof(ZigbeeZclColorStepHue_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->step_mode = in_req->step_mode;
+ req->step_size = in_req->step_size;
+ req->transition_time = in_req->transition_time;
+ }
+
+ zcl_color_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: {
+ ZigbeeZclColorMoveToSaturation_t *in_req;
+ ZigbeeZclColorMoveToSaturation_t *req = NULL;
+
+ in_req = (ZigbeeZclColorMoveToSaturation_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclColorMoveToSaturation_t *)
+ g_malloc0(sizeof(ZigbeeZclColorMoveToSaturation_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->saturation = in_req->saturation;
+ req->transition_time = in_req->transition_time;
+ }
+
+ zcl_color_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: {
+ ZigbeeZclColorMoveSaturation_t *in_req;
+ ZigbeeZclColorMoveSaturation_t *req = NULL;
+
+ in_req = (ZigbeeZclColorMoveSaturation_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclColorMoveSaturation_t *)
+ g_malloc0(sizeof(ZigbeeZclColorMoveSaturation_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->move_mode = in_req->move_mode;
+ req->rate = in_req->rate;
+ }
+
+ zcl_color_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: {
+ ZigbeeZclColorStepSaturation_t *in_req;
+ ZigbeeZclColorStepSaturation_t *req = NULL;
+
+ in_req = (ZigbeeZclColorStepSaturation_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclColorStepSaturation_t *)
+ g_malloc0(sizeof(ZigbeeZclColorStepSaturation_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->step_mode = in_req->step_mode;
+ req->step_size = in_req->step_size;
+ req->transition_time = in_req->transition_time;
+ }
+
+ zcl_color_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: {
+ ZigbeeZclColorMoveToHueAndSaturation_t *in_req;
+ ZigbeeZclColorMoveToHueAndSaturation_t *req = NULL;
+
+ in_req = (ZigbeeZclColorMoveToHueAndSaturation_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclColorMoveToHueAndSaturation_t *)
+ g_malloc0(sizeof(ZigbeeZclColorMoveToHueAndSaturation_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->hue = in_req->hue;
+ req->saturation = in_req->saturation;
+ req->transition_time = in_req->transition_time;
+ }
+
+ zcl_color_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: {
+ ZigbeeZclColorMoveToColor_t *in_req;
+ ZigbeeZclColorMoveToColor_t *req = NULL;
+
+ in_req = (ZigbeeZclColorMoveToColor_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclColorMoveToColor_t *)
+ g_malloc0(sizeof(ZigbeeZclColorMoveToColor_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->color_x = in_req->color_x;
+ req->color_y = in_req->color_y;
+ req->transition_time = in_req->transition_time;
+ }
+
+ zcl_color_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: {
+ ZigbeeZclColorMoveColor_t *in_req;
+ ZigbeeZclColorMoveColor_t *req = NULL;
+
+ in_req = (ZigbeeZclColorMoveColor_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclColorMoveColor_t *)
+ g_malloc0(sizeof(ZigbeeZclColorMoveColor_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->rate_x = in_req->rate_x;
+ req->rate_y = in_req->rate_y;
+ }
+
+ zcl_color_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: {
+ ZigbeeZclColorStepColor_t *in_req;
+ ZigbeeZclColorStepColor_t *req = NULL;
+
+ in_req = (ZigbeeZclColorStepColor_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclColorStepColor_t *)
+ g_malloc0(sizeof(ZigbeeZclColorStepColor_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->rate_x = in_req->rate_x;
+ req->rate_y = in_req->rate_y;
+ req->transition_time = in_req->transition_time;
+ }
+
+ zcl_color_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: {
+ ZigbeeZclColorMoveColorTemperature_t *in_req;
+ ZigbeeZclColorMoveColorTemperature_t *req = NULL;
+
+ in_req = (ZigbeeZclColorMoveColorTemperature_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclColorMoveColorTemperature_t *)
+ g_malloc0(sizeof(ZigbeeZclColorMoveColorTemperature_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->color_temperature = in_req->color_temperature;
+ req->transition_time = in_req->transition_time;
+ }
+
+ zcl_color_request_data = (gpointer)req;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return zcl_color_request_data;
+}
+
+static gpointer __zblib_request_create_zcl_group_request_data(guint request_type,
+ gpointer request_data, guint request_data_len)
+{
+ gpointer zcl_group_request_data = NULL;
+ guint ops_id;
+
+ NOT_USED(request_data_len);
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
+ ZigbeeZclGroupAddGroup_t *in_req;
+ ZigbeeZclGroupAddGroup_t *req = NULL;
+
+ in_req = (ZigbeeZclGroupAddGroup_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclGroupAddGroup_t *)
+ g_malloc0(sizeof(ZigbeeZclGroupAddGroup_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->group_id = in_req->group_id;
+ g_strlcpy(req->group_name,
+ in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
+ }
+
+ zcl_group_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
+ ZigbeeZclGroupViewGroup_t *in_req;
+ ZigbeeZclGroupViewGroup_t *req = NULL;
+
+ in_req = (ZigbeeZclGroupViewGroup_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclGroupViewGroup_t *)
+ g_malloc0(sizeof(ZigbeeZclGroupViewGroup_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zcl_group_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
+ ZigbeeZclGroupGetGroupMembership_t *in_req;
+ ZigbeeZclGroupGetGroupMembership_t *req = NULL;
+
+ in_req = (ZigbeeZclGroupGetGroupMembership_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclGroupGetGroupMembership_t *)
+ g_malloc0(sizeof(ZigbeeZclGroupGetGroupMembership_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->group_count = in_req->group_count;
+ req->group_list = (gshort *)g_memdup(in_req->group_list,
+ in_req->group_count);
+ }
+
+ zcl_group_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
+ ZigbeeZclGroupRemoveGroup_t *in_req;
+ ZigbeeZclGroupRemoveGroup_t *req = NULL;
+
+ in_req = (ZigbeeZclGroupRemoveGroup_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclGroupRemoveGroup_t *)
+ g_malloc0(sizeof(ZigbeeZclGroupRemoveGroup_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->group_id = in_req->group_id;
+ }
+
+ zcl_group_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
+ ZigbeeZclGroupRemoveAllGroup_t *in_req;
+ ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
+
+ in_req = (ZigbeeZclGroupRemoveAllGroup_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclGroupRemoveAllGroup_t *)
+ g_malloc0(sizeof(ZigbeeZclGroupRemoveAllGroup_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zcl_group_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
+ ZigbeeZclGroupAddGroupIfIdentifying_t *in_req;
+ ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
+
+ in_req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)
+ g_malloc0(sizeof(ZigbeeZclGroupAddGroupIfIdentifying_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->group_id = in_req->group_id;
+ g_strlcpy(req->group_name,
+ in_req->group_name, ZIGBEE_ZCL_GROUP_NAME_MAX_LEN + 1);
+ }
+
+ zcl_group_request_data = (gpointer)req;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return zcl_group_request_data;
+}
+
+static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type,
+ gpointer request_data, guint request_data_len)
+{
+ gpointer zcl_poll_control_request_data = NULL;
+ guint ops_id;
+
+ NOT_USED(request_data_len);
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
+ ZigbeeZclPollControlCheckInResponse_t *in_req;
+ ZigbeeZclPollControlCheckInResponse_t *req = NULL;
+
+ in_req = (ZigbeeZclPollControlCheckInResponse_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclPollControlCheckInResponse_t *)
+ g_malloc0(sizeof(ZigbeeZclPollControlCheckInResponse_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->start_fast_polling = in_req->start_fast_polling;
+ req->fast_poll_timeout = in_req->fast_poll_timeout;
+ }
+
+ zcl_poll_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
+ ZigbeeZclPollControlFastPollStop_t *in_req;
+ ZigbeeZclPollControlFastPollStop_t *req = NULL;
+
+ in_req = (ZigbeeZclPollControlFastPollStop_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclPollControlFastPollStop_t *)
+ g_malloc0(sizeof(ZigbeeZclPollControlFastPollStop_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ }
+
+ zcl_poll_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
+ ZigbeeZclPollControlSetLongPollInterval_t *in_req;
+ ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
+
+ in_req = (ZigbeeZclPollControlSetLongPollInterval_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclPollControlSetLongPollInterval_t *)
+ g_malloc0(sizeof(ZigbeeZclPollControlSetLongPollInterval_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->new_long_poll_interval = in_req->new_long_poll_interval;
+ }
+
+ zcl_poll_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
+ ZigbeeZclPollControlSetShortPollInterval_t *in_req;
+ ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
+
+ in_req = (ZigbeeZclPollControlSetShortPollInterval_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclPollControlSetShortPollInterval_t *)
+ g_malloc0(sizeof(ZigbeeZclPollControlSetShortPollInterval_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->new_short_poll_interval = in_req->new_short_poll_interval;
+ }
+
+ zcl_poll_control_request_data = (gpointer)req;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return zcl_poll_control_request_data;
+}
+
+static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type,
+ gpointer request_data, guint request_data_len)
+{
+ gpointer zcl_scene_request_data = NULL;
+ guint ops_id;
+
+ NOT_USED(request_data_len);
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
+ ZigbeeZclSceneAddScene_t *in_req;
+ ZigbeeZclSceneAddScene_t *req = NULL;
+
+ in_req = (ZigbeeZclSceneAddScene_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclSceneAddScene_t *)
+ g_malloc0(sizeof(ZigbeeZclSceneAddScene_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->group_id = in_req->group_id;
+ req->scene_id = in_req->scene_id;
+ req->transition_time = in_req->transition_time;
+ g_strlcpy(req->scene_name,
+ in_req->scene_name, ZIGBEE_ZCL_SCENE_NAME_MAX_LEN + 1);
+ req->ext_field_set_len = in_req->ext_field_set_len;
+ req->ext_field_set = (gshort *)g_memdup(in_req->ext_field_set,
+ in_req->ext_field_set_len);
+ }
+
+ zcl_scene_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
+ ZigbeeZclSceneViewScene_t *in_req;
+ ZigbeeZclSceneViewScene_t *req = NULL;
+
+ in_req = (ZigbeeZclSceneViewScene_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclSceneViewScene_t *)
+ g_malloc0(sizeof(ZigbeeZclSceneViewScene_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->group_id = in_req->group_id;
+ req->scene_id = in_req->scene_id;
+ }
+
+ zcl_scene_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
+ ZigbeeZclSceneRemoveScene_t *in_req;
+ ZigbeeZclSceneRemoveScene_t *req = NULL;
+
+ in_req = (ZigbeeZclSceneRemoveScene_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclSceneRemoveScene_t *)
+ g_malloc0(sizeof(ZigbeeZclSceneRemoveScene_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->group_id = in_req->group_id;
+ req->scene_id = in_req->scene_id;
+ }
+
+ zcl_scene_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
+ ZigbeeZclSceneStoreScene_t *in_req;
+ ZigbeeZclSceneStoreScene_t *req = NULL;
+
+ in_req = (ZigbeeZclSceneStoreScene_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclSceneStoreScene_t *)
+ g_malloc0(sizeof(ZigbeeZclSceneStoreScene_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->group_id = in_req->group_id;
+ req->scene_id = in_req->scene_id;
+ }
+
+ zcl_scene_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
+ ZigbeeZclSceneRecallScene_t *in_req;
+ ZigbeeZclSceneRecallScene_t *req = NULL;
+
+ in_req = (ZigbeeZclSceneRecallScene_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclSceneRecallScene_t *)
+ g_malloc0(sizeof(ZigbeeZclSceneRecallScene_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->group_id = in_req->group_id;
+ req->scene_id = in_req->scene_id;
+ }
+
+ zcl_scene_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
+ ZigbeeZclSceneRemoveAllScene_t *in_req;
+ ZigbeeZclSceneRemoveAllScene_t *req = NULL;
+
+ in_req = (ZigbeeZclSceneRemoveAllScene_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclSceneRemoveAllScene_t *)
+ g_malloc0(sizeof(ZigbeeZclSceneRemoveAllScene_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->group_id = in_req->group_id;
+ }
+
+ zcl_scene_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
+ ZigbeeZclSceneGetSceneMembership_t *in_req;
+ ZigbeeZclSceneGetSceneMembership_t *req = NULL;
+
+ in_req = (ZigbeeZclSceneGetSceneMembership_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZclSceneGetSceneMembership_t *)
+ g_malloc0(sizeof(ZigbeeZclSceneGetSceneMembership_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->dest_ep = in_req->dest_ep;
+ req->group_id = in_req->group_id;
+ }
+
+ zcl_scene_request_data = (gpointer)req;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return zcl_scene_request_data;
+}
+
+static gpointer __zblib_request_create_zdodev_control_request_data(guint request_type,
+ gpointer request_data, guint request_data_len)
+{
+ gpointer zdodev_control_request_data = NULL;
+ guint ops_id;
+
+ NOT_USED(request_data_len);
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ: {
+ ZigbeeZdodevControlNwkAddrReq_t *in_req;
+ ZigbeeZdodevControlNwkAddrReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlNwkAddrReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlNwkAddrReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlNwkAddrReq_t));
+
+ /* Copy data */
+ memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
+ req->request_type = in_req->request_type;
+ req->start_index = in_req->start_index;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
+ ZigbeeZdodevControlMatchedDescriptorReq_t *in_req;
+ ZigbeeZdodevControlMatchedDescriptorReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlMatchedDescriptorReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlMatchedDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlMatchedDescriptorReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->profile_id = in_req->profile_id;
+ req->num_in_cl = in_req->num_in_cl;
+ req->in_cl = g_strdup(in_req->in_cl);
+ req->num_out_cl = in_req->num_out_cl;
+ req->out_cl = g_strdup(in_req->out_cl);
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: {
+ ZigbeeZdodevControlIeeeAddrReq_t *in_req;
+ ZigbeeZdodevControlIeeeAddrReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlIeeeAddrReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlIeeeAddrReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlIeeeAddrReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: {
+ ZigbeeZdodevControlActiveEpReq_t *in_req;
+ ZigbeeZdodevControlActiveEpReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlActiveEpReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlActiveEpReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlActiveEpReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: {
+ ZigbeeZdodevControlNodeDescriptorReq_t *in_req;
+ ZigbeeZdodevControlNodeDescriptorReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlNodeDescriptorReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlNodeDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlNodeDescriptorReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: {
+ ZigbeeZdodevControlPowerDescriptorReq_t *in_req;
+ ZigbeeZdodevControlPowerDescriptorReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlPowerDescriptorReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlPowerDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlPowerDescriptorReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
+ ZigbeeZdodevControlComplexDescriptorReq_t *in_req;
+ ZigbeeZdodevControlComplexDescriptorReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlComplexDescriptorReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlComplexDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlComplexDescriptorReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: {
+ ZigbeeZdodevControlUserDescriptorReq_t *in_req;
+ ZigbeeZdodevControlUserDescriptorReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlUserDescriptorReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlUserDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlUserDescriptorReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: {
+ ZigbeeZdodevControlUserDescriptorSetReq_t *in_req;
+ ZigbeeZdodevControlUserDescriptorSetReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlUserDescriptorSetReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlUserDescriptorSetReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlUserDescriptorSetReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->user_descriptor_len = in_req->user_descriptor_len;
+ memcpy(req->user_descriptor,
+ in_req->user_descriptor, in_req->user_descriptor_len);
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
+ ZigbeeZdodevControlDeviceAnnounce_t *in_req;
+ ZigbeeZdodevControlDeviceAnnounce_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlDeviceAnnounce_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlDeviceAnnounce_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlDeviceAnnounce_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ memcpy(req->mac_addr, in_req->mac_addr, ZIGBEE_EUI64_SIZE);
+ req->capability = in_req->capability;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
+ ZigbeeZdodevControlSimpleDescriptorReq_t *in_req;
+ ZigbeeZdodevControlSimpleDescriptorReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlSimpleDescriptorReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlSimpleDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlSimpleDescriptorReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->endpoint = in_req->endpoint;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: {
+ ZigbeeZdodevControlMgmtLqiReq_t *in_req;
+ ZigbeeZdodevControlMgmtLqiReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlMgmtLqiReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlMgmtLqiReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlMgmtLqiReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->start_index = in_req->start_index;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: {
+ ZigbeeZdodevControlMgmtRtgReq_t *in_req;
+ ZigbeeZdodevControlMgmtRtgReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlMgmtRtgReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlMgmtRtgReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlMgmtRtgReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->start_index = in_req->start_index;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: {
+ ZigbeeZdodevControlMgmtBindReq_t *in_req;
+ ZigbeeZdodevControlMgmtBindReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlMgmtBindReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlMgmtBindReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlMgmtBindReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->start_index = in_req->start_index;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
+ ZigbeeZdodevControlMgmtPermitJoinReq_t *in_req;
+ ZigbeeZdodevControlMgmtPermitJoinReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlMgmtPermitJoinReq_t));
+
+ /* Copy data */
+ req->addr = in_req->addr;
+ req->duration = in_req->duration;
+ req->tc_significance = in_req->tc_significance;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: {
+ ZigbeeZdodevControlNwkUpdateReq_t *in_req;
+ ZigbeeZdodevControlNwkUpdateReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlNwkUpdateReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlNwkUpdateReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlNwkUpdateReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->scan_channel = in_req->scan_channel;
+ req->scan_duration = in_req->scan_duration;
+ req->scan_count = in_req->scan_count;
+ req->network_update_id = in_req->network_update_id;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: {
+ ZigbeeZdodevControlNwkDescriptorReq_t *in_req;
+ ZigbeeZdodevControlNwkDescriptorReq_t *req = NULL;
+
+ in_req = (ZigbeeZdodevControlNwkDescriptorReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdodevControlNwkDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdodevControlNwkDescriptorReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ req->scan_channel = in_req->scan_channel;
+ req->scan_duration = in_req->scan_duration;
+ req->scan_count = in_req->scan_count;
+ req->start_index = in_req->start_index;
+ }
+
+ zdodev_control_request_data = (gpointer)req;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return zdodev_control_request_data;
+}
+
+static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type,
+ gpointer request_data, guint request_data_len)
+{
+ gpointer zdo_bind_request_data = NULL;
+ guint ops_id;
+
+ NOT_USED(request_data_len);
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
+ ZigbeeZdoBindBindReq_t *in_req;
+ ZigbeeZdoBindBindReq_t *req = NULL;
+
+ in_req = (ZigbeeZdoBindBindReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdoBindBindReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoBindBindReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ g_strlcpy(req->src_addr,
+ in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
+ req->src_ep = in_req->src_ep;
+ req->cluster_id = in_req->cluster_id;
+ g_strlcpy(req->dst_addr,
+ in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
+ req->bind_type = in_req->bind_type;
+ req->group_addr = in_req->group_addr;
+ req->dst_ep = in_req->dst_ep;
+ }
+
+ zdo_bind_request_data = (gpointer)req;
+ }
+ break;
+
+ case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
+ ZigbeeZdoBindUnbindReq_t *in_req;
+ ZigbeeZdoBindUnbindReq_t *req = NULL;
+
+ in_req = (ZigbeeZdoBindUnbindReq_t *)request_data;
+ if (NULL != in_req) {
+ /* Allocate memory */
+ req = (ZigbeeZdoBindUnbindReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoBindUnbindReq_t));
+
+ /* Copy data */
+ req->node_id = in_req->node_id;
+ g_strlcpy(req->src_addr,
+ in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
+ req->src_ep = in_req->src_ep;
+ req->cluster_id = in_req->cluster_id;
+ g_strlcpy(req->dst_addr,
+ in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
+ req->bind_type = in_req->bind_type;
+ req->group_addr = in_req->group_addr;
+ req->dst_ep = in_req->dst_ep;
+ }
+
+ zdo_bind_request_data = (gpointer)req;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return zdo_bind_request_data;
+}
+
+
+static gpointer __zblib_request_create_request_data(guint request_type,
+ gpointer request_data, guint request_data_len)
+{
+ gpointer _request_data = NULL;
+ ZblibDriverType_e driver_type;
+
+ /* Fetch driver type */
+ driver_type = __zblib_request_get_driver_type(request_type);
+ switch (driver_type) {
+ case ZBLIB_DRIVER_TYPE_ALARM: {
+ _request_data = __zblib_request_create_alarm_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_CUSTOM: {
+ _request_data = __zblib_request_create_custom_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_DOOR_LOCK: {
+ _request_data = __zblib_request_create_door_lock_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_FAN_CONTROL: {
+ _request_data = __zblib_request_create_fan_control_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_LEVEL_CONTROL: {
+ _request_data = __zblib_request_create_level_control_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
+ _request_data = __zblib_request_create_mfglib_control_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_ON_OFF: {
+ _request_data = __zblib_request_create_on_off_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_SERVICE: {
+ _request_data = __zblib_request_create_service_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_THERMOSTAT: {
+ _request_data = __zblib_request_create_thermostat_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL: {
+ _request_data = __zblib_request_create_zclbasic_control_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL: {
+ _request_data = __zblib_request_create_zclglobal_control_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL: {
+ _request_data = __zblib_request_create_zclias_control_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL: {
+ _request_data = __zblib_request_create_zclidentify_control_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_ZCL_COLOR: {
+ _request_data = __zblib_request_create_zcl_color_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
+ _request_data = __zblib_request_create_zcl_group_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
+ _request_data = __zblib_request_create_zcl_poll_control_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
+ _request_data = __zblib_request_create_zcl_scene_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL: {
+ _request_data = __zblib_request_create_zdodev_control_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
+ _request_data = __zblib_request_create_zdo_bind_request_data(request_type,
+ request_data, request_data_len);
+ }
+ break;
+
+ case ZBLIB_DRIVER_TYPE_NONE: /* Fallthrough */
+ default: {
+ Z_LOGE("Unhandled driver type: [%d]", driver_type);
+ }
+ break;
+ }
+
+ return _request_data;
+}
+
+static void __zblib_request_free_alarm_request_data(ZigBeeRequest *request,
+ guint request_type)
+{
+ guint ops_id;
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ALARM_OPS_GET_ALARM_COUNT: {
+ ZigbeeAlarmGetAlarmCount_t *req = NULL;
+
+ req = (ZigbeeAlarmGetAlarmCount_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_ALARM_OPS_RESET_ALARM: {
+ ZigbeeAlarmResetAlarm_t *req = NULL;
+
+ req = (ZigbeeAlarmResetAlarm_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: {
+ ZigbeeAlarmResetAllAlarm_t *req = NULL;
+
+ req = (ZigbeeAlarmResetAllAlarm_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_ALARM_OPS_ALARM: {
+ ZigbeeAlarmAlarm_t *req = NULL;
+
+ req = (ZigbeeAlarmAlarm_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: {
+ ZigbeeAlarmResetAlarmLogs_t *req = NULL;
+
+ req = (ZigbeeAlarmResetAlarmLogs_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_ALARM_OPS_GET_ALARM: {
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void __zblib_request_free_custom_request_data(ZigBeeRequest *request,
+ guint request_type)
+{
+ guint ops_id;
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_CUSTOM_OPS_APS_SEND: {
+ ZigbeeCustomApsSend_t *req = NULL;
+
+ req = (ZigbeeCustomApsSend_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
+ ZigbeeCustomZclSend_t *req = NULL;
+
+ req = (ZigbeeCustomZclSend_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
+ ZigbeeCustomSendToLocal_t *req = NULL;
+
+ req = (ZigbeeCustomSendToLocal_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void __zblib_request_free_door_lock_request_data(ZigBeeRequest *request,
+ guint request_type)
+{
+ guint ops_id;
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
+ ZigbeeDoorLockSubscriberLockEvent_t *req = NULL;
+
+ req = (ZigbeeDoorLockSubscriberLockEvent_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
+ ZigbeeDoorLockSetDoorLockPin_t *req = NULL;
+
+ req = (ZigbeeDoorLockSetDoorLockPin_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
+ ZigbeeDoorLockSetDoorLock_t *req = NULL;
+
+ req = (ZigbeeDoorLockSetDoorLock_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: {
+ ZigbeeDoorLockGetDoorLock_t *req = NULL;
+
+ req = (ZigbeeDoorLockGetDoorLock_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void __zblib_request_free_fan_control_request_data(ZigBeeRequest *request,
+ guint request_type)
+{
+ guint ops_id;
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE: {
+ ZigbeeFanControlSetFanMode_t *req = NULL;
+
+ req = (ZigbeeFanControlSetFanMode_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: {
+ ZigbeeFanControlGetFanMode_t *req = NULL;
+
+ req = (ZigbeeFanControlGetFanMode_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
+ ZigbeeFanControlSetFanModeSequence_t *req = NULL;
+
+ req = (ZigbeeFanControlSetFanModeSequence_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
+ ZigbeeFanControlGetFanModeSequence_t *req = NULL;
+
+ req = (ZigbeeFanControlGetFanModeSequence_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void __zblib_request_free_level_control_request_data(ZigBeeRequest *request,
+ guint request_type)
+{
+ guint ops_id;
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
+ ZigbeeLevelControlMoveToLevel_t *req = NULL;
+
+ req = (ZigbeeLevelControlMoveToLevel_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_LEVEL_CONTROL_OPS_MOVE: {
+ ZigbeeLevelControlMove_t *req = NULL;
+
+ req = (ZigbeeLevelControlMove_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_LEVEL_CONTROL_OPS_STEP: {
+ ZigbeeLevelControlStep_t *req = NULL;
+
+ req = (ZigbeeLevelControlStep_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
+ ZigbeeLevelControlMoveToLevelWithOnOff_t *req = NULL;
+
+ req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
+ ZigbeeLevelControlMoveWithOnOff_t *req = NULL;
+
+ req = (ZigbeeLevelControlMoveWithOnOff_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
+ ZigbeeLevelControlStepWithOnOff_t *req = NULL;
+
+ req = (ZigbeeLevelControlStepWithOnOff_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_LEVEL_CONTROL_OPS_STOP: {
+ ZigbeeLevelControlStop_t *req = NULL;
+
+ req = (ZigbeeLevelControlStop_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void __zblib_request_free_mfglib_control_request_data(ZigBeeRequest *request,
+ guint request_type)
+{
+ guint ops_id;
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_MFGLIB_CONTROL_OPS_START: {
+ ZigbeeMfglibControlStart_t *req = NULL;
+
+ req = (ZigbeeMfglibControlStart_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_END: {
+ ZigbeeMfglibControlEnd_t *req = NULL;
+
+ req = (ZigbeeMfglibControlEnd_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
+ ZigbeeMfglibControlStartTone_t *req = NULL;
+
+ req = (ZigbeeMfglibControlStartTone_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
+ ZigbeeMfglibControlStopTone_t *req = NULL;
+
+ req = (ZigbeeMfglibControlStopTone_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
+ ZigbeeMfglibControlStartStream_t *req = NULL;
+
+ req = (ZigbeeMfglibControlStartStream_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
+ ZigbeeMfglibControlStopStream_t *req = NULL;
+
+ req = (ZigbeeMfglibControlStopStream_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
+ ZigbeeMfglibControlSendPacket_t *req = NULL;
+
+ req = (ZigbeeMfglibControlSendPacket_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
+ ZigbeeMfglibControlSetChannel_t *req = NULL;
+
+ req = (ZigbeeMfglibControlSetChannel_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
+ ZigbeeMfglibControlGetChannel_t *req = NULL;
+
+ req = (ZigbeeMfglibControlGetChannel_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
+ ZigbeeMfglibControlSetPower_t *req = NULL;
+
+ req = (ZigbeeMfglibControlSetPower_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
+ ZigbeeMfglibControlGetPower_t *req = NULL;
+
+ req = (ZigbeeMfglibControlGetPower_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
+ ZigbeeMfglibControlSetSynOffset_t *req = NULL;
+
+ req = (ZigbeeMfglibControlSetSynOffset_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
+ ZigbeeMfglibControlGetSynOffset_t *req = NULL;
+
+ req = (ZigbeeMfglibControlGetSynOffset_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
+ ZigbeeMfglibControlRxStart_t *req = NULL;
+
+ req = (ZigbeeMfglibControlRxStart_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
+ ZigbeeMfglibControlRxStop_t *req = NULL;
+
+ req = (ZigbeeMfglibControlRxStop_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
+ ZigbeeMfglibControlRxVerify_t *req = NULL;
+
+ req = (ZigbeeMfglibControlRxVerify_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
+ ZigbeeMfglibControlGetRssi_t *req = NULL;
+
+ req = (ZigbeeMfglibControlGetRssi_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void __zblib_request_free_on_off_request_data(ZigBeeRequest *request,
+ guint request_type)
+{
+ guint ops_id;
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_ON_OFF_OPS_SET_ON_OFF: {
+ ZigbeeOnOffSetOnOff_t *req = NULL;
+
+ req = (ZigbeeOnOffSetOnOff_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: {
+ ZigbeeOnOffGetOnOffState_t *req = NULL;
+
+ req = (ZigbeeOnOffGetOnOffState_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void __zblib_request_free_service_request_data(ZigBeeRequest *request,
+ guint request_type)
+{
+ guint ops_id;
+
+ /* 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;
+
+ case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_COEX_START: {
+ ZigbeeServiceCoexStart_t *req = NULL;
+
+ req = (ZigbeeServiceCoexStart_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_COEX_STOP: {
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
+ ZigbeeServicePermitJoin_t *req = NULL;
+
+ req = (ZigbeeServicePermitJoin_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
+ ZigbeeServiceLeaveRequest_t *req = NULL;
+
+ req = (ZigbeeServiceLeaveRequest_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_GET_MAC: {
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
+ ZigbeeServiceGetEndpointList_t *req = NULL;
+
+ req = (ZigbeeServiceGetEndpointList_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
+ ZigbeeServiceGetClusterList_t *req = NULL;
+
+ req = (ZigbeeServiceGetClusterList_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
+ ZigbeeServiceGetNodeType_t *req = NULL;
+
+ req = (ZigbeeServiceGetNodeType_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void __zblib_request_free_thermostat_request_data(ZigBeeRequest *request,
+ guint request_type)
+{
+ guint ops_id;
+
+ /* Fetch ops ID */
+ ops_id = __zblib_request_get_ops_id(request_type);
+ switch (ops_id) {
+ case ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
+ ZigbeeThermostatGetLocalTemp_t *req = NULL;
+
+ req = (ZigbeeThermostatGetLocalTemp_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
+ ZigbeeThermostatGetWeeklySchedule_t *req = NULL;
+
+ req = (ZigbeeThermostatGetWeeklySchedule_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
+ ZigbeeThermostatSetWeeklySchedule_t *req = NULL;
+
+ req = (ZigbeeThermostatSetWeeklySchedule_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
+ ZigbeeThermostatClearWeeklySchedule_t *req = NULL;
+
+ req = (ZigbeeThermostatClearWeeklySchedule_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
+ ZigbeeThermostatSetpointRaiseLower_t *req = NULL;
+
+ req = (ZigbeeThermostatSetpointRaiseLower_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void __zblib_request_free_zclbasic_control_request_data(ZigBeeRequest *request,
+ guint request_type)
{
- gpointer zclbasic_control_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
- NOT_USED(request_data_len);
-
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT: {
+ ZigbeeZclbasicControlResetFactoryDefault_t *req = NULL;
+
+ req = (ZigbeeZclbasicControlResetFactoryDefault_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
default:
break;
}
-
- return zclbasic_control_request_data;
}
-static gpointer __zblib_request_create_zclglobal_control_request_data(guint request_type,
- gpointer request_data, guint request_data_len)
+static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *request,
+ guint request_type)
{
- gpointer zclglobal_control_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
- NOT_USED(request_data_len);
-
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
+ ZigbeeZclglobalControlReadAttributesRequest_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlReadAttributesRequest_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req->attribute_id);
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
+ ZigbeeZclglobalControlWriteAttributesRequest_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlWriteAttributesRequest_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req->write_records);
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
+ ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req->write_records);
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
+ ZigbeeZclglobalControlWriteAttributesNoResponse_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req->write_records);
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
+ ZigbeeZclglobalControlWriteAttributesStructed_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlWriteAttributesStructed_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req->write_records);
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
+ ZigbeeZclglobalControlReadAttributesStructed_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlReadAttributesStructed_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req->read_records);
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
+ ZigbeeZclglobalControlConfigureReportingReq_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlConfigureReportingReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req->read_records);
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
+ ZigbeeZclglobalControlReadConfigureReporting_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlReadConfigureReporting_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req->read_records);
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
+ ZigbeeZclglobalControlDiscoverAttributes_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlDiscoverAttributes_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
+ ZigbeeZclglobalControlDiscoverAttributesExtended_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
+ ZigbeeZclglobalControlDiscoverCommandsReceived_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
+ ZigbeeZclglobalControlDiscoverCommandsGenerated_t *req = NULL;
+
+ req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
default:
break;
}
-
- return zclglobal_control_request_data;
}
-static gpointer __zblib_request_create_zclias_control_request_data(guint request_type,
- gpointer request_data, guint request_data_len)
+static void __zblib_request_free_zclias_control_request_data(ZigBeeRequest *request,
+ guint request_type)
{
- gpointer zclias_control_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
- NOT_USED(request_data_len);
-
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE: {
+ ZigbeeZcliasControlEnrolResponse_t *req = NULL;
+
+ req = (ZigbeeZcliasControlEnrolResponse_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
default:
break;
}
-
- return zclias_control_request_data;
}
-static gpointer __zblib_request_create_zclidentify_control_request_data(guint request_type,
- gpointer request_data, guint request_data_len)
+static void __zblib_request_free_zclidentify_control_request_data(ZigBeeRequest *request,
+ guint request_type)
{
- gpointer zclidentify_control_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
- NOT_USED(request_data_len);
-
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY: {
+ ZigbeeZclidentifyControlIdentify_t *req = NULL;
+
+ req = (ZigbeeZclidentifyControlIdentify_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: {
+ ZigbeeZclidentifyControlQuery_t *req = NULL;
+
+ req = (ZigbeeZclidentifyControlQuery_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
default:
break;
}
-
- return zclidentify_control_request_data;
}
-static gpointer __zblib_request_create_zcl_color_request_data(guint request_type,
- gpointer request_data, guint request_data_len)
+static void __zblib_request_free_zcl_color_request_data(ZigBeeRequest *request,
+ guint request_type)
{
- gpointer zcl_color_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
- NOT_USED(request_data_len);
-
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE: {
+ ZigbeeZclColorMoveToHue_t *req = NULL;
+
+ req = (ZigbeeZclColorMoveToHue_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: {
+ ZigbeeZclColorMoveHue_t *req = NULL;
+
+ req = (ZigbeeZclColorMoveHue_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: {
+ ZigbeeZclColorStepHue_t *req = NULL;
+
+ req = (ZigbeeZclColorStepHue_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: {
+ ZigbeeZclColorMoveToSaturation_t *req = NULL;
+
+ req = (ZigbeeZclColorMoveToSaturation_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: {
+ ZigbeeZclColorMoveSaturation_t *req = NULL;
+
+ req = (ZigbeeZclColorMoveSaturation_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: {
+ ZigbeeZclColorStepSaturation_t *req = NULL;
+
+ req = (ZigbeeZclColorStepSaturation_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: {
+ ZigbeeZclColorMoveToHueAndSaturation_t *req = NULL;
+
+ req = (ZigbeeZclColorMoveToHueAndSaturation_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: {
+ ZigbeeZclColorMoveToColor_t *req = NULL;
+
+ req = (ZigbeeZclColorMoveToColor_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: {
+ ZigbeeZclColorMoveColor_t *req = NULL;
+
+ req = (ZigbeeZclColorMoveColor_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: {
+ ZigbeeZclColorStepColor_t *req = NULL;
+
+ req = (ZigbeeZclColorStepColor_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: {
+ ZigbeeZclColorMoveColorTemperature_t *req = NULL;
+
+ req = (ZigbeeZclColorMoveColorTemperature_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
default:
break;
}
-
- return zcl_color_request_data;
}
-static gpointer __zblib_request_create_zcl_group_request_data(guint request_type,
- gpointer request_data, guint request_data_len)
+static void __zblib_request_free_zcl_group_request_data(ZigBeeRequest *request,
+ guint request_type)
{
- gpointer zcl_group_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
- NOT_USED(request_data_len);
-
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
+ ZigbeeZclGroupAddGroup_t *req = NULL;
+
+ req = (ZigbeeZclGroupAddGroup_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
+ ZigbeeZclGroupViewGroup_t *req = NULL;
+
+ req = (ZigbeeZclGroupViewGroup_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
+ ZigbeeZclGroupGetGroupMembership_t *req = NULL;
+
+ req = (ZigbeeZclGroupGetGroupMembership_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req->group_list);
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
+ ZigbeeZclGroupRemoveGroup_t *req = NULL;
+
+ req = (ZigbeeZclGroupRemoveGroup_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
+ ZigbeeZclGroupRemoveAllGroup_t *req = NULL;
+
+ req = (ZigbeeZclGroupRemoveAllGroup_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
+ ZigbeeZclGroupAddGroupIfIdentifying_t *req = NULL;
+
+ req = (ZigbeeZclGroupAddGroupIfIdentifying_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
default:
break;
}
-
- return zcl_group_request_data;
}
-static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type,
- gpointer request_data, guint request_data_len)
+static void __zblib_request_free_zcl_poll_control_request_data(ZigBeeRequest *request,
+ guint request_type)
{
- gpointer zcl_poll_control_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
- NOT_USED(request_data_len);
-
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
+ ZigbeeZclPollControlCheckInResponse_t *req = NULL;
+
+ req = (ZigbeeZclPollControlCheckInResponse_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
+ ZigbeeZclPollControlFastPollStop_t *req = NULL;
+
+ req = (ZigbeeZclPollControlFastPollStop_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
+ ZigbeeZclPollControlSetLongPollInterval_t *req = NULL;
+
+ req = (ZigbeeZclPollControlSetLongPollInterval_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
+ ZigbeeZclPollControlSetShortPollInterval_t *req = NULL;
+
+ req = (ZigbeeZclPollControlSetShortPollInterval_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
default:
break;
}
-
- return zcl_poll_control_request_data;
}
-static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type,
- gpointer request_data, guint request_data_len)
+static void __zblib_request_free_zcl_scene_request_data(ZigBeeRequest *request,
+ guint request_type)
{
- gpointer zcl_scene_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
- NOT_USED(request_data_len);
-
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
+ ZigbeeZclSceneAddScene_t *req = NULL;
+
+ req = (ZigbeeZclSceneAddScene_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req->ext_field_set);
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
+ ZigbeeZclSceneViewScene_t *req = NULL;
+
+ req = (ZigbeeZclSceneViewScene_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
+ ZigbeeZclSceneRemoveScene_t *req = NULL;
+
+ req = (ZigbeeZclSceneRemoveScene_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
+ ZigbeeZclSceneStoreScene_t *req = NULL;
+
+ req = (ZigbeeZclSceneStoreScene_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
+ ZigbeeZclSceneRecallScene_t *req = NULL;
+
+ req = (ZigbeeZclSceneRecallScene_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
+ ZigbeeZclSceneRemoveAllScene_t *req = NULL;
+
+ req = (ZigbeeZclSceneRemoveAllScene_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
+ ZigbeeZclSceneGetSceneMembership_t *req = NULL;
+
+ req = (ZigbeeZclSceneGetSceneMembership_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
default:
break;
}
-
- return zcl_scene_request_data;
}
-static gpointer __zblib_request_create_zdodev_control_request_data(guint request_type,
- gpointer request_data, guint request_data_len)
+static void __zblib_request_free_zdodev_control_request_data(ZigBeeRequest *request,
+ guint request_type)
{
- gpointer zdodev_control_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
- NOT_USED(request_data_len);
-
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ: {
+ ZigbeeZdodevControlNwkAddrReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlNwkAddrReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
+ ZigbeeZdodevControlMatchedDescriptorReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlMatchedDescriptorReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req->in_cl);
+ g_free(req->out_cl);
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: {
+ ZigbeeZdodevControlIeeeAddrReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlIeeeAddrReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: {
+ ZigbeeZdodevControlActiveEpReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlActiveEpReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: {
+ ZigbeeZdodevControlNodeDescriptorReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlNodeDescriptorReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: {
+ ZigbeeZdodevControlPowerDescriptorReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlPowerDescriptorReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
+ ZigbeeZdodevControlComplexDescriptorReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlComplexDescriptorReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: {
+ ZigbeeZdodevControlUserDescriptorReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlUserDescriptorReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: {
+ ZigbeeZdodevControlUserDescriptorSetReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlUserDescriptorSetReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
+ ZigbeeZdodevControlDeviceAnnounce_t *req = NULL;
+
+ req = (ZigbeeZdodevControlDeviceAnnounce_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
+ ZigbeeZdodevControlSimpleDescriptorReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlSimpleDescriptorReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: {
+ ZigbeeZdodevControlMgmtLqiReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlMgmtLqiReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: {
+ ZigbeeZdodevControlMgmtRtgReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlMgmtRtgReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: {
+ ZigbeeZdodevControlMgmtBindReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlMgmtBindReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
+ ZigbeeZdodevControlMgmtPermitJoinReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: {
+ ZigbeeZdodevControlNwkUpdateReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlNwkUpdateReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: {
+ ZigbeeZdodevControlNwkDescriptorReq_t *req = NULL;
+
+ req = (ZigbeeZdodevControlNwkDescriptorReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
default:
break;
}
-
- return zdodev_control_request_data;
}
-static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type,
- gpointer request_data, guint request_data_len)
+static void __zblib_request_free_zdo_bind_request_data(ZigBeeRequest *request,
+ guint request_type)
{
- gpointer zdo_bind_request_data = NULL;
guint ops_id;
- NOT_USED(request_data);
- NOT_USED(request_data_len);
-
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
+ ZigbeeZdoBindBindReq_t *req = NULL;
+
+ req = (ZigbeeZdoBindBindReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
+ ZigbeeZdoBindUnbindReq_t *req = NULL;
+
+ req = (ZigbeeZdoBindUnbindReq_t *)request->request_data;
+ if (NULL != req) {
+ g_free(req);
+ }
}
break;
default:
break;
}
-
- return zdo_bind_request_data;
}
-static gpointer __zblib_request_create_request_data(guint request_type,
- gpointer request_data, guint request_data_len)
+static void __zblib_request_free_request_data(ZigBeeRequest *request)
{
- gpointer _request_data = NULL;
+ guint request_type;
ZblibDriverType_e driver_type;
+ zblib_check_null_ret("request", request);
+
+ request_type = request->request_type;
+
/* Fetch driver type */
driver_type = __zblib_request_get_driver_type(request_type);
switch (driver_type) {
case ZBLIB_DRIVER_TYPE_ALARM: {
- _request_data = __zblib_request_create_alarm_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_alarm_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_CUSTOM: {
- _request_data = __zblib_request_create_custom_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_custom_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_DOOR_LOCK: {
- _request_data = __zblib_request_create_door_lock_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_door_lock_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_FAN_CONTROL: {
- _request_data = __zblib_request_create_fan_control_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_fan_control_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_LEVEL_CONTROL: {
- _request_data = __zblib_request_create_level_control_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_level_control_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
- _request_data = __zblib_request_create_mfglib_control_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_mfglib_control_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_ON_OFF: {
- _request_data = __zblib_request_create_on_off_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_on_off_request_data(request, request_type);
}
break;
+
case ZBLIB_DRIVER_TYPE_SERVICE: {
- _request_data = __zblib_request_create_service_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_service_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_THERMOSTAT: {
- _request_data = __zblib_request_create_thermostat_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_thermostat_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL: {
- _request_data = __zblib_request_create_zclbasic_control_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_zclbasic_control_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL: {
- _request_data = __zblib_request_create_zclglobal_control_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_zclglobal_control_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL: {
- _request_data = __zblib_request_create_zclias_control_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_zclias_control_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL: {
- _request_data = __zblib_request_create_zclidentify_control_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_zclidentify_control_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_ZCL_COLOR: {
- _request_data = __zblib_request_create_zcl_color_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_zcl_color_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
- _request_data = __zblib_request_create_zcl_group_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_zcl_group_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
- _request_data = __zblib_request_create_zcl_poll_control_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_zcl_poll_control_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
- _request_data = __zblib_request_create_zcl_scene_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_zcl_scene_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL: {
- _request_data = __zblib_request_create_zdodev_control_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_zdodev_control_request_data(request, request_type);
}
break;
case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
- _request_data = __zblib_request_create_zdo_bind_request_data(request_type,
- request_data, request_data_len);
+ __zblib_request_free_zdo_bind_request_data(request, request_type);
}
break;
}
break;
}
-
- return _request_data;
-}
-
-static void __zblib_request_free_request_data(gpointer request_data)
-{
- if (NULL == request_data) {
- Z_LOGE("request_data is NULL");
- return;
- }
-
- /* Free resources */
- g_free(request_data);
}
gint zblib_request_new(ZigBeeServiceInterface *service_interface,
ZigBeeRequest *request = NULL;
GHashTable *request_table = NULL;
- if (NULL == service_interface) {
- Z_LOGE("service_interface is NULL");
- return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
- }
+ zblib_check_null_ret_error("service_interface", service_interface, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
service = zblib_service_interface_ref_service(service_interface);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
- }
+ zblib_check_null_ret_error("service", service, ZIGBEE_REQUEST_INVALID_REQUEST_ID);
/* Allocate ZigBee request memory */
request = g_malloc0(sizeof(ZigBeeRequest));
Z_LOGE("zblib_service_genrate_request_id failed!");
/* Free resources */
+ __zblib_request_free_request_data(request);
g_free(request);
return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
Z_LOGE("zblib_service_ref_request_hash_table failed!");
/* Free resources */
+ __zblib_request_free_request_data(request);
g_free(request);
return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
return request->request_id;
}
-void zblib_request_free(ZigBeeRequest *request)
+void zblib_request_free(ZigBeeServiceInterface *service_interface,
+ guint request_id)
{
- if (NULL == request) {
- Z_LOGE("request is NULL");
- return;
- }
+ ZigBeeService *service = NULL;
+ ZigBeeRequest *request = NULL;
+
+ zblib_check_null_ret("service_interface", service_interface);
+
+ /* Fetch service */
+ service = zblib_service_interface_ref_service(service_interface);
+ zblib_check_null_ret("service", service);
+
+ /* Fetch request based on request_id */
+ request = __zblib_request_ref_request_by_request_id(service, request_id);
+ zblib_check_null_ret("request", request);
/* Free resources */
- __zblib_request_free_request_data(request->request_data);
+ __zblib_request_free_request_data(request);
g_free(request);
}
-ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request)
+gboolean zblib_request_set_response_cb(ZigBeeServiceInterface *service_interface,
+ guint request_id,
+ gpointer resp_cb, gpointer resp_cb_data)
+{
+ ZigBeeService *service = NULL;
+ ZigBeeRequest *request = NULL;
+
+ zblib_check_null_ret_error("request", request, FALSE);
+
+ /* Fetch service */
+ service = zblib_service_interface_ref_service(service_interface);
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch request based on request_id */
+ request = __zblib_request_ref_request_by_by_request_id(service, request_id);
+ if (NULL == request) {
+ Z_LOGE("No request available for request_id: [%d]", request_id);
+ return FALSE;
+ }
+
+ /* Update response callback and response callback data */
+ request->resp_cb = resp_cb;
+ request->resp_cb_data = resp_cb_data;
+
+ return TRUE;
+}
+
+gpointer zblib_request_ref_response_cb(ZigBeeServiceInterface *service_interface,
+ guint request_id, gpointer *resp_cb_data)
{
+ ZigBeeService *service = NULL;
+ ZigBeeRequest *request = NULL;
+
+ zblib_check_null_ret_error("request", request, NULL);
+
+ /* Fetch service */
+ service = zblib_service_interface_ref_service(service_interface);
+ zblib_check_null_ret_error("service", service, NULL);
+
+ /* Fetch request based on request_id */
+ request = __zblib_request_ref_request_by_by_request_id(service, request_id);
if (NULL == request) {
- Z_LOGE("request is NULL");
- return request;
+ Z_LOGE("No request available for request_id: [%d]", request_id);
+ return NULL;
}
+ /* Response callback data */
+ *resp_cb_data = request->resp_cb_data;
+
+ /* Return response callback */
+ return request->resp_cb;
+}
+
+ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request)
+{
+ zblib_check_null_ret_error("request", request, NULL);
+
request->ref_count++;
return request;
void zblib_request_unref(ZigBeeRequest *request)
{
- if (NULL == request) {
- Z_LOGE("request is NULL");
- return;
- }
+ zblib_check_null_ret("request", request);
request->ref_count--;
if (0 == request->ref_count) {
Z_LOGD("Reference count is ZERO!");
/* Free 'request' */
- zblib_request_free(request);
+ __zblib_request_free_request_data(request);
+ g_free(request);
}
}
guint zblib_request_ref_request_type(ZigBeeRequest *request)
{
- if (NULL == request) {
- Z_LOGE("request is NULL");
- return 0;
- }
+ zblib_check_null_ret_error("request", request, 0);
return request->request_type;
}
-ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeRequest *request)
+ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeService *service,
+ guint request_id)
{
+ ZigBeeRequest *request = NULL;
+
+ zblib_check_null_ret_error("service", service, NULL);
+
+ /* Fetch request based on request_id */
+ request = __zblib_request_ref_request_by_by_request_id(service, request_id);
if (NULL == request) {
- Z_LOGE("request is NULL");
+ Z_LOGE("No request available for request_id: [%d]", request_id);
return NULL;
}
gpointer zblib_request_ref_request_data(ZigBeeRequest *request)
{
- if (NULL == request) {
- Z_LOGE("request is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("request", request, NULL);
return request->request_data;
}
gint zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
guint request_id)
{
- ZigBeeRequest *request = NULL;
- GHashTable *request_table = NULL;
-
- /* Fetch request table from service */
- request_table = zblib_service_ref_request_hash_table(service);
- if (NULL == request_table) {
- Z_LOGE("zblib_service_ref_request_hash_table failed!");
- return -1;
- }
-
- /* Look-up requets_id in request hash table */
- request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id);
- if (NULL == request_table) {
- Z_LOGE("No request availabel for request_id: [%d]", request_id);
- return -1;
- }
-
- return (gint)(request->request_type);
+ return __zblib_request_ref_request_type_by_request_id(service, request_id);
}
ZblibDriverType_e zblib_request_get_driver_type(guint request_type)
projects / platform / core / connectivity / zigbee-manager.git / blobdiff