static gboolean __zblib_driver_alarm_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverAlarmPrivData_t *priv_data = NULL;
+ ZblibDriverAlarmOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ALARM_OPS_GET_ALARM_COUNT: {
+ zblib_check_null_ret_error("ops->get_alarm_count",
+ ops->get_alarm_count, FALSE);
+
+ ret = ops->get_alarm_count(driver, request_id);
}
break;
case ZBLIB_ALARM_OPS_RESET_ALARM: {
+ zblib_check_null_ret_error("ops->reset_alarm",
+ ops->reset_alarm, FALSE);
+
+ ret = ops->reset_alarm(driver, request_id);
}
break;
case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: {
+ zblib_check_null_ret_error("ops->reset_all_alarm",
+ ops->reset_all_alarm, FALSE);
+
+ ret = ops->reset_all_alarm(driver, request_id);
}
break;
case ZBLIB_ALARM_OPS_ALARM: {
+ zblib_check_null_ret_error("ops->alarm",
+ ops->alarm, FALSE);
+
+ ret = ops->alarm(driver, request_id);
}
break;
case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: {
+ zblib_check_null_ret_error("ops->reset_alarm_log",
+ ops->reset_alarm_log, FALSE);
+
+ ret = ops->reset_alarm_log(driver, request_id);
}
break;
case ZBLIB_ALARM_OPS_GET_ALARM: {
+ zblib_check_null_ret_error("ops->get_alarm",
+ ops->get_alarm, FALSE);
+
+ ret = ops->get_alarm(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_alarm_free_hook(ZigBeeDriver *driver)
{
ZblibDriverAlarmPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverAlarmPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ALARM);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverAlarmPrivData_t));
void zblib_driver_alarm_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_custom_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverCustomPrivData_t *priv_data = NULL;
+ ZblibDriverCustomOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_CUSTOM_OPS_APS_SEND: {
+ zblib_check_null_ret_error("ops->aps_send",
+ ops->aps_send, FALSE);
+
+ ret = ops->aps_send(driver, request_id);
}
break;
case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
+ zblib_check_null_ret_error("ops->zcl_send",
+ ops->zcl_send, FALSE);
+
+ ret = ops->zcl_send(driver, request_id);
}
break;
case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
+ zblib_check_null_ret_error("ops->send_to_local",
+ ops->send_to_local, FALSE);
+
+ ret = ops->send_to_local(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_custom_free_hook(ZigBeeDriver *driver)
{
ZblibDriverCustomPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverCustomPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_CUSTOM);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverCustomPrivData_t));
void zblib_driver_custom_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_door_lock_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverDoorLockPrivData_t *priv_data = NULL;
+ ZblibDriverDoorLockOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
+ zblib_check_null_ret_error("ops->subscribe_lock_event",
+ ops->subscribe_lock_event, FALSE);
+
+ ret = ops->subscribe_lock_event(driver, request_id);
}
break;
case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
+ zblib_check_null_ret_error("ops->set_door_lock_pin",
+ ops->set_door_lock_pin, FALSE);
+
+ ret = ops->set_door_lock_pin(driver, request_id);
}
break;
case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
+ zblib_check_null_ret_error("ops->set_door_lock",
+ ops->set_door_lock, FALSE);
+
+ ret = ops->set_door_lock(driver, request_id);
}
break;
case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: {
+ zblib_check_null_ret_error("ops->get_lock_state", ops->get_lock_state, FALSE);
+
+ ret = ops->get_lock_state(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_door_lock_free_hook(ZigBeeDriver *driver)
{
ZblibDriverDoorLockPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverDoorLockPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_DOOR_LOCK);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverDoorLockPrivData_t));
void zblib_driver_door_lock_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_fan_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverFanControlPrivData_t *priv_data = NULL;
+ ZblibDriverFanControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE: {
+ zblib_check_null_ret_error("ops->set_fan_mode",
+ ops->set_fan_mode, FALSE);
+
+ ret = ops->set_fan_mode(driver, request_id);
}
break;
case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: {
+ zblib_check_null_ret_error("ops->get_fan_mode",
+ ops->get_fan_mode, FALSE);
+
+ ret = ops->get_fan_mode(driver, request_id);
}
break;
case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
+ zblib_check_null_ret_error("ops->set_fan_mode_sequence",
+ ops->set_fan_mode_sequence, FALSE);
+
+ ret = ops->set_fan_mode_sequence(driver, request_id);
}
break;
case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
+ zblib_check_null_ret_error("ops->get_fan_mode_sequence",
+ ops->get_fan_mode_sequence, FALSE);
+
+ ret = ops->get_fan_mode_sequence(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_fan_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverFanControlPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverFanControlPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_FAN_CONTROL);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverFanControlPrivData_t));
void zblib_driver_fan_control_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_level_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverLevelControlPrivData_t *priv_data = NULL;
+ ZblibDriverLevelControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
+ zblib_check_null_ret_error("ops->move_to_level",
+ ops->move_to_level, FALSE);
+
+ ret = ops->move_to_level(driver, request_id);
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_MOVE: {
+ zblib_check_null_ret_error("ops->move",
+ ops->move, FALSE);
+
+ ret = ops->move(driver, request_id);
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_STEP: {
+ zblib_check_null_ret_error("ops->step",
+ ops->step, FALSE);
+
+ ret = ops->step(driver, request_id);
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
+ zblib_check_null_ret_error("ops->move_to_level_with_on_off",
+ ops->move_to_level_with_on_off, FALSE);
+
+ ret = ops->move_to_level_with_on_off(driver, request_id);
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
+ zblib_check_null_ret_error("ops->move_with_on_off",
+ ops->move_with_on_off, FALSE);
+
+ ret = ops->move_with_on_off(driver, request_id);
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
+ zblib_check_null_ret_error("ops->step_with_on_off",
+ ops->step_with_on_off, FALSE);
+
+ ret = ops->step_with_on_off(driver, request_id);
}
break;
case ZBLIB_LEVEL_CONTROL_OPS_STOP: {
+ zblib_check_null_ret_error("ops->stop",
+ ops->stop, FALSE);
+
+ ret = ops->stop(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_level_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverLevelControlPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverLevelControlPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_LEVEL_CONTROL);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverLevelControlPrivData_t));
void zblib_driver_level_control_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_mfglib_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverMfglibControlPrivData_t *priv_data = NULL;
+ ZblibDriverMfglibControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_MFGLIB_CONTROL_OPS_START: {
+ zblib_check_null_ret_error("ops->start",
+ ops->start, FALSE);
+
+ ret = ops->start(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_END: {
+ zblib_check_null_ret_error("ops->end",
+ ops->end, FALSE);
+
+ ret = ops->end(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
+ zblib_check_null_ret_error("ops->start_tone",
+ ops->start_tone, FALSE);
+
+ ret = ops->start_tone(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
+ zblib_check_null_ret_error("ops->stop_tone",
+ ops->stop_tone, FALSE);
+
+ ret = ops->stop_tone(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
+ zblib_check_null_ret_error("ops->start_stream",
+ ops->start_stream, FALSE);
+
+ ret = ops->start_stream(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
+ zblib_check_null_ret_error("ops->stop_stream",
+ ops->stop_stream, FALSE);
+
+ ret = ops->stop_stream(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
+ zblib_check_null_ret_error("ops->send_packet",
+ ops->send_packet, FALSE);
+
+ ret = ops->send_packet(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
+ zblib_check_null_ret_error("ops->set_channel",
+ ops->set_channel, FALSE);
+
+ ret = ops->set_channel(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
+ zblib_check_null_ret_error("ops->get_channel",
+ ops->get_channel, FALSE);
+
+ ret = ops->get_channel(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
+ zblib_check_null_ret_error("ops->set_power",
+ ops->set_power, FALSE);
+
+ ret = ops->set_power(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
+ zblib_check_null_ret_error("ops->get_power",
+ ops->get_power, FALSE);
+
+ ret = ops->get_power(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
+ zblib_check_null_ret_error("ops->set_synoffset",
+ ops->set_synoffset, FALSE);
+
+ ret = ops->set_synoffset(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
+ zblib_check_null_ret_error("ops->get_synoffset",
+ ops->get_synoffset, FALSE);
+
+ ret = ops->get_synoffset(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
+ zblib_check_null_ret_error("ops->rx_start",
+ ops->rx_start, FALSE);
+
+ ret = ops->rx_start(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
+ zblib_check_null_ret_error("ops->rx_stop",
+ ops->rx_stop, FALSE);
+
+ ret = ops->rx_stop(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
+ zblib_check_null_ret_error("ops->rx_verify",
+ ops->rx_verify, FALSE);
+
+ ret = ops->rx_verify(driver, request_id);
}
break;
case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
+ zblib_check_null_ret_error("ops->get_rssi",
+ ops->get_rssi, FALSE);
+
+ ret = ops->get_rssi(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_mfglib_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverMfglibControlPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverMfglibControlPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverMfglibControlPrivData_t));
void zblib_driver_mfglib_control_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_on_off_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverOnOffPrivData_t *priv_data = NULL;
+ ZblibDriverOnOffOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ON_OFF_OPS_SET_ON_OFF: {
+ zblib_check_null_ret_error("ops->set_on_off",
+ ops->set_on_off, FALSE);
+
+ ret = ops->set_on_off(driver, request_id);
}
break;
case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: {
+ zblib_check_null_ret_error("ops->get_on_off_state",
+ ops->get_on_off_state, FALSE);
+
+ ret = ops->get_on_off_state(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_on_off_free_hook(ZigBeeDriver *driver)
{
ZblibDriverOnOffPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverOnOffPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ON_OFF);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverOnOffPrivData_t));
void zblib_driver_on_off_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_service_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverServicePrivData_t *priv_data = NULL;
+ ZblibDriverServiceOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_SERVICE_OPS_ENABLE: {
+ zblib_check_null_ret_error("ops->enable",
+ ops->enable, FALSE);
+
+ ret = ops->enable(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_DISABLE: {
+ zblib_check_null_ret_error("ops->disable",
+ ops->disable, FALSE);
+
+ ret = ops->disable(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
+ zblib_check_null_ret_error("ops->zb_hw_reset",
+ ops->zb_hw_reset, FALSE);
+
+ ret = ops->zb_hw_reset(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
+ zblib_check_null_ret_error("ops->form_network",
+ ops->form_network, FALSE);
+
+ ret = ops->form_network(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_COEX_START: {
+ zblib_check_null_ret_error("ops->coex_start",
+ ops->coex_start, FALSE);
+
+ ret = ops->coex_start(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_COEX_STOP: {
+ zblib_check_null_ret_error("ops->coex_stop",
+ ops->coex_stop, FALSE);
+
+ ret = ops->coex_stop(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
+ zblib_check_null_ret_error("ops->leave_network",
+ ops->leave_network, FALSE);
+
+ ret = ops->leave_network(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
+ zblib_check_null_ret_error("ops->get_network_info",
+ ops->get_network_info, FALSE);
+
+ ret = ops->get_network_info(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
+ zblib_check_null_ret_error("ops->permit_join",
+ ops->permit_join, FALSE);
+
+ ret = ops->permit_join(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
+ zblib_check_null_ret_error("ops->leave_request",
+ ops->leave_request, FALSE);
+
+ ret = ops->leave_request(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
+ zblib_check_null_ret_error("ops->get_device_list",
+ ops->get_device_list, FALSE);
+
+ ret = ops->get_device_list(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_GET_MAC: {
+ zblib_check_null_ret_error("ops->get_mac",
+ ops->get_mac, FALSE);
+
+ ret = ops->get_mac(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
+ zblib_check_null_ret_error("ops->get_device_info",
+ ops->get_device_info, FALSE);
+
+ ret = ops->get_device_info(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
+ zblib_check_null_ret_error("ops->get_endpoint_list",
+ ops->get_endpoint_list, FALSE);
+
+ ret = ops->get_endpoint_list(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
+ zblib_check_null_ret_error("ops->get_cluster_list",
+ ops->get_cluster_list, FALSE);
+
+ ret = ops->get_cluster_list(driver, request_id);
}
break;
case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
+ zblib_check_null_ret_error("ops->get_node_type",
+ ops->get_node_type, FALSE);
+
+ ret = ops->get_node_type(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_service_free_hook(ZigBeeDriver *driver)
{
ZblibDriverServicePrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverServicePrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_SERVICE);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverServicePrivData_t));
void zblib_driver_service_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_thermostat_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverThermostatPrivData_t *priv_data = NULL;
+ ZblibDriverThermostatOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
+ zblib_check_null_ret_error("ops->get_local_temp",
+ ops->get_local_temp, FALSE);
+
+ ret = ops->get_local_temp(driver, request_id);
}
break;
case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
+ zblib_check_null_ret_error("ops->get_weekly_schedule",
+ ops->get_weekly_schedule, FALSE);
+
+ ret = ops->get_weekly_schedule(driver, request_id);
}
break;
case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
+ zblib_check_null_ret_error("ops->set_weekly_schedule",
+ ops->set_weekly_schedule, FALSE);
+
+ ret = ops->set_weekly_schedule(driver, request_id);
}
break;
case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
+ zblib_check_null_ret_error("ops->clear_weekly_schedule",
+ ops->clear_weekly_schedule, FALSE);
+
+ ret = ops->clear_weekly_schedule(driver, request_id);
}
break;
case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
+ zblib_check_null_ret_error("ops->setpoint_raise_lower",
+ ops->setpoint_raise_lower, FALSE);
+
+ ret = ops->setpoint_raise_lower(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_thermostat_free_hook(ZigBeeDriver *driver)
{
ZblibDriverThermostatPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverThermostatPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_THERMOSTAT);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverThermostatPrivData_t));
void zblib_driver_thermostat_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_zcl_color_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverZclColorPrivData_t *priv_data = NULL;
+ ZblibDriverZclColorOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE: {
+ zblib_check_null_ret_error("ops->move_to_hue",
+ ops->move_to_hue, FALSE);
+
+ ret = ops->move_to_hue(driver, request_id);
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: {
+ zblib_check_null_ret_error("ops->move_hue",
+ ops->move_hue, FALSE);
+
+ ret = ops->move_hue(driver, request_id);
}
break;
case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: {
+ zblib_check_null_ret_error("ops->step_hue",
+ ops->step_hue, FALSE);
+
+ ret = ops->step_hue(driver, request_id);
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: {
+ zblib_check_null_ret_error("ops->move_to_saturation",
+ ops->move_to_saturation, FALSE);
+
+ ret = ops->move_to_saturation(driver, request_id);
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: {
+ zblib_check_null_ret_error("ops->move_saturation",
+ ops->move_saturation, FALSE);
+
+ ret = ops->move_saturation(driver, request_id);
}
break;
case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: {
+ zblib_check_null_ret_error("ops->step_saturation",
+ ops->step_saturation, FALSE);
+
+ ret = ops->step_saturation(driver, request_id);
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: {
+ zblib_check_null_ret_error("ops->move_to_hue_and_saturation",
+ ops->move_to_hue_and_saturation, FALSE);
+
+ ret = ops->move_to_hue_and_saturation(driver, request_id);
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: {
+ zblib_check_null_ret_error("ops->move_to_color",
+ ops->move_to_color, FALSE);
+
+ ret = ops->move_to_color(driver, request_id);
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: {
+ zblib_check_null_ret_error("ops->move_color",
+ ops->move_color, FALSE);
+
+ ret = ops->move_color(driver, request_id);
}
break;
case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: {
+ zblib_check_null_ret_error("ops->step_color",
+ ops->step_color, FALSE);
+
+ ret = ops->step_color(driver, request_id);
}
break;
case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: {
+ zblib_check_null_ret_error("ops->move_color_temperature",
+ ops->move_color_temperature, FALSE);
+
+ ret = ops->move_color_temperature(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_zcl_color_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZclColorPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverZclColorPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_COLOR);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverZclColorPrivData_t));
void zblib_driver_zcl_color_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_zcl_group_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverZclGroupPrivData_t *priv_data = NULL;
+ ZblibDriverZclGroupOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
+ zblib_check_null_ret_error("ops->add_group",
+ ops->add_group, FALSE);
+
+ ret = ops->add_group(driver, request_id);
}
break;
case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
+ zblib_check_null_ret_error("ops->view_group",
+ ops->view_group, FALSE);
+
+ ret = ops->view_group(driver, request_id);
}
break;
case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
+ zblib_check_null_ret_error("ops->get_group_membership",
+ ops->get_group_membership, FALSE);
+
+ ret = ops->get_group_membership(driver, request_id);
}
break;
case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
+ zblib_check_null_ret_error("ops->remove_group",
+ ops->remove_group, FALSE);
+
+ ret = ops->remove_group(driver, request_id);
}
break;
case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
+ zblib_check_null_ret_error("ops->remove_all_group",
+ ops->remove_all_group, FALSE);
+
+ ret = ops->remove_all_group(driver, request_id);
}
break;
case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
+ zblib_check_null_ret_error("ops->add_group_if_identifying",
+ ops->add_group_if_identifying, FALSE);
+
+ ret = ops->add_group_if_identifying(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_zcl_group_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZclGroupPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverZclGroupPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_GROUP);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverZclGroupPrivData_t));
void zblib_driver_zcl_group_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_zcl_poll_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverZclPollControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclPollControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
+ zblib_check_null_ret_error("ops->check_in_response",
+ ops->check_in_response, FALSE);
+
+ ret = ops->check_in_response(driver, request_id);
}
break;
case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
+ zblib_check_null_ret_error("ops->fast_poll_stop",
+ ops->fast_poll_stop, FALSE);
+
+ ret = ops->fast_poll_stop(driver, request_id);
}
break;
case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
+ zblib_check_null_ret_error("ops->set_long_poll_interval",
+ ops->set_long_poll_interval, FALSE);
+
+ ret = ops->set_long_poll_interval(driver, request_id);
}
break;
case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
+ zblib_check_null_ret_error("ops->set_short_poll_interval",
+ ops->set_short_poll_interval, FALSE);
+
+ ret = ops->set_short_poll_interval(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_zcl_poll_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZclPollControlPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverZclPollControlPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverZclPollControlPrivData_t));
void zblib_driver_zcl_poll_control_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_zcl_scene_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverZclScenePrivData_t *priv_data = NULL;
+ ZblibDriverZclSceneOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
+ zblib_check_null_ret_error("ops->add_scene",
+ ops->add_scene, FALSE);
+
+ ret = ops->add_scene(driver, request_id);
}
break;
case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
+ zblib_check_null_ret_error("ops->view_scene",
+ ops->view_scene, FALSE);
+
+ ret = ops->view_scene(driver, request_id);
}
break;
case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
+ zblib_check_null_ret_error("ops->remove_scene",
+ ops->remove_scene, FALSE);
+
+ ret = ops->remove_scene(driver, request_id);
}
break;
case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
+ zblib_check_null_ret_error("ops->store_scene",
+ ops->store_scene, FALSE);
+
+ ret = ops->store_scene(driver, request_id);
}
break;
case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
+ zblib_check_null_ret_error("ops->recall_scene",
+ ops->recall_scene, FALSE);
+
+ ret = ops->recall_scene(driver, request_id);
}
break;
case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
+ zblib_check_null_ret_error("ops->remove_all_scene",
+ ops->remove_all_scene, FALSE);
+
+ ret = ops->remove_all_scene(driver, request_id);
}
break;
case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
+ zblib_check_null_ret_error("ops->get_scene_membership",
+ ops->get_scene_membership, FALSE);
+
+ ret = ops->get_scene_membership(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_zcl_scene_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZclScenePrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverZclScenePrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_SCENE);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverZclScenePrivData_t));
void zblib_driver_zcl_scene_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_zclbasic_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverZclbasicControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclbasicControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT: {
+ zblib_check_null_ret_error("ops->reset_factory_default",
+ ops->reset_factory_default, FALSE);
+
+ ret = ops->reset_factory_default(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_zclbasic_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZclbasicControlPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverZclbasicControlPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverZclbasicControlPrivData_t));
void zblib_driver_zclbasic_control_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_zclglobal_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverZclglobalControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclglobalControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
+ zblib_check_null_ret_error("ops->read_attributes_req",
+ ops->read_attributes_req, FALSE);
+
+ ret = ops->read_attributes_req(driver, request_id);
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
+ zblib_check_null_ret_error("ops->write_attributes_req",
+ ops->write_attributes_req, FALSE);
+
+ ret = ops->write_attributes_req(driver, request_id);
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
+ zblib_check_null_ret_error("ops->write_attributes_undivided_req",
+ ops->write_attributes_undivided_req, FALSE);
+
+ ret = ops->write_attributes_undivided_req(driver, request_id);
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
+ zblib_check_null_ret_error("ops->write_attributes_no_resp",
+ ops->write_attributes_no_resp, FALSE);
+
+ ret = ops->write_attributes_no_resp(driver, request_id);
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
+ zblib_check_null_ret_error("ops->write_attributes_structured",
+ ops->write_attributes_structured, FALSE);
+
+ ret = ops->write_attributes_structured(driver, request_id);
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
+ zblib_check_null_ret_error("ops->read_attributes_structured",
+ ops->read_attributes_structured, FALSE);
+
+ ret = ops->read_attributes_structured(driver, request_id);
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
+ zblib_check_null_ret_error("ops->configure_reporting_req",
+ ops->configure_reporting_req, FALSE);
+
+ ret = ops->configure_reporting_req(driver, request_id);
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
+ zblib_check_null_ret_error("ops->read_configure_reporting",
+ ops->read_configure_reporting, FALSE);
+
+ ret = ops->read_configure_reporting(driver, request_id);
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
+ zblib_check_null_ret_error("ops->discover_attributes",
+ ops->discover_attributes, FALSE);
+
+ ret = ops->discover_attributes(driver, request_id);
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
+ zblib_check_null_ret_error("ops->discover_attributes_extended",
+ ops->discover_attributes_extended, FALSE);
+
+ ret = ops->discover_attributes_extended(driver, request_id);
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
+ zblib_check_null_ret_error("ops->discover_commands_received",
+ ops->discover_commands_received, FALSE);
+
+ ret = ops->discover_commands_received(driver, request_id);
}
break;
case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
+ zblib_check_null_ret_error("ops->discover_commands_generated",
+ ops->discover_commands_generated, FALSE);
+
+ ret = ops->discover_commands_generated(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_zclglobal_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZclglobalControlPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverZclglobalControlPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverZclglobalControlPrivData_t));
void zblib_driver_zclglobal_control_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_zclias_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverZcliasControlPrivData_t *priv_data = NULL;
+ ZblibDriverZcliasControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE: {
+ zblib_check_null_ret_error("ops->enroll_response",
+ ops->enroll_response, FALSE);
+
+ ret = ops->enroll_response(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_zclias_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZcliasControlPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverZcliasControlPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverZcliasControlPrivData_t));
void zblib_driver_zclias_control_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_zclidentify_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverZclidentifyControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclidentifyControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY: {
+ zblib_check_null_ret_error("ops->identify",
+ ops->identify, FALSE);
+
+ ret = ops->identify(driver, request_id);
}
break;
case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: {
+ zblib_check_null_ret_error("ops->query",
+ ops->query, FALSE);
+
+ ret = ops->query(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_zclidentify_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZclidentifyControlPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverZclidentifyControlPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverZclidentifyControlPrivData_t));
void zblib_driver_zclidentify_control_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
static gboolean __zblib_driver_zdo_bind_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverZdoBindPrivData_t *priv_data = NULL;
+ ZblibDriverZdoBindOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
+ zblib_check_null_ret_error("ops->bind_req",
+ ops->bind_req, FALSE);
+
+ ret = ops->bind_req(driver, request_id);
}
break;
case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
+ zblib_check_null_ret_error("ops->unbind_req",
+ ops->unbind_req, FALSE);
+
+ ret = ops->unbind_req(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_zdo_bind_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZdoBindPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverZdoBindPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZDO_BIND);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverZdoBindPrivData_t));
static gboolean __zblib_driver_zdodev_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
+ ZblibDriverZdodevControlPrivData_t *priv_data = NULL;
+ ZblibDriverZdodevControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
+ gboolean ret = FALSE;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
service = zblib_driver_ref_service(driver);
- if (NULL == service) {
- Z_LOGE("service is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("service", service, FALSE);
+
+ /* Fetch private data */
+ priv_data = zblib_driver_ref_object(driver);
+ zblib_check_null_ret_error("priv_data", priv_data, FALSE);
+
+ ops = priv_data->ops;
+ zblib_check_null_ret_error("ops", ops, FALSE);
/* Fetch request_type using request_id */
request_type = zblib_request_ref_request_type_by_request_id(service, request_id);
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
case ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ: {
+ zblib_check_null_ret_error("ops->nwk_addr_req",
+ ops->nwk_addr_req, FALSE);
+
+ ret = ops->nwk_addr_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
+ zblib_check_null_ret_error("ops->matched_descriptor_req",
+ ops->matched_descriptor_req, FALSE);
+
+ ret = ops->matched_descriptor_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: {
+ zblib_check_null_ret_error("ops->ieee_addr_req",
+ ops->ieee_addr_req, FALSE);
+
+ ret = ops->ieee_addr_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: {
+ zblib_check_null_ret_error("ops->active_ep_req",
+ ops->active_ep_req, FALSE);
+
+ ret = ops->active_ep_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: {
+ zblib_check_null_ret_error("ops->node_desc_req",
+ ops->node_desc_req, FALSE);
+
+ ret = ops->node_desc_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: {
+ zblib_check_null_ret_error("ops->power_desc_req",
+ ops->power_desc_req, FALSE);
+
+ ret = ops->power_desc_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
+ zblib_check_null_ret_error("ops->complex_desc_req",
+ ops->complex_desc_req, FALSE);
+
+ ret = ops->complex_desc_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: {
+ zblib_check_null_ret_error("ops->user_desc_req",
+ ops->user_desc_req, FALSE);
+
+ ret = ops->user_desc_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: {
+ zblib_check_null_ret_error("ops->user_desc_set_req",
+ ops->user_desc_set_req, FALSE);
+
+ ret = ops->user_desc_set_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
+ zblib_check_null_ret_error("ops->device_announce",
+ ops->device_announce, FALSE);
+
+ ret = ops->device_announce(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
+ zblib_check_null_ret_error("ops->simple_desc_req",
+ ops->simple_desc_req, FALSE);
+
+ ret = ops->simple_desc_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: {
+ zblib_check_null_ret_error("ops->mgmt_lqi_req",
+ ops->mgmt_lqi_req, FALSE);
+
+ ret = ops->mgmt_lqi_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: {
+ zblib_check_null_ret_error("ops->mgmt_rtg_req",
+ ops->mgmt_rtg_req, FALSE);
+
+ ret = ops->mgmt_rtg_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: {
+ zblib_check_null_ret_error("ops->mgmt_bind_req",
+ ops->mgmt_bind_req, FALSE);
+
+ ret = ops->mgmt_bind_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
+ zblib_check_null_ret_error("ops->mgmt_permit_join_req",
+ ops->mgmt_permit_join_req, FALSE);
+
+ ret = ops->mgmt_permit_join_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: {
+ zblib_check_null_ret_error("ops->nwk_update_req",
+ ops->nwk_update_req, FALSE);
+
+ ret = ops->nwk_update_req(driver, request_id);
}
break;
case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: {
+ zblib_check_null_ret_error("ops->nwk_disc_req",
+ ops->nwk_disc_req, FALSE);
+
+ ret = ops->nwk_disc_req(driver, request_id);
}
break;
break;
}
- return TRUE;
+ Z_LOGD("ret: [%d]", ret);
+
+ return ret;
}
static void __zblib_driver_zdodev_control_free_hook(ZigBeeDriver *driver)
{
ZblibDriverZdodevControlPrivData_t *priv_data = NULL;
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Fetch private data */
priv_data = zblib_driver_ref_object(driver);
- if (NULL == priv_data) {
- Z_LOGE("priv_data is NULL");
- return;
- }
+ zblib_check_null_ret("priv_data", priv_data);
/* Free resources */
g_free(priv_data);
ZblibDriverZdodevControlPrivData_t *priv_data = NULL;
gboolean ret;
- if (NULL == plugin) {
- Z_LOGE("plugin is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL);
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
priv_data = g_malloc0(sizeof(ZblibDriverZdodevControlPrivData_t));
void zblib_driver_zdodev_control_free(ZigBeeDriver *driver)
{
- if (NULL == driver) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Free driver */
zblib_driver_free(driver);
void zblib_driver_free(ZigBeeDriver *driver)
{
- if (driver == NULL) {
- Z_LOGE("driver is NULL");
- return;
- }
+ zblib_check_null_ret("driver", driver);
/* Invoke free hook */
if (driver->free_hook_fn)
ZigBeeService *zblib_driver_ref_service(ZigBeeDriver *driver)
{
- if (driver == NULL) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
return driver->service;
}
ZigBeePlugin *zblib_driver_ref_plugin(ZigBeeDriver *driver)
{
- if (driver == NULL) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
return driver->plugin;
}
-gboolean zblib_driver_link_object(ZigBeeDriver *driver, gpointer object)
+gboolean zblib_driver_link_object(ZigBeeDriver *driver,
+ gpointer object)
{
- if (driver == NULL) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
driver->priv_object = object;
gpointer zblib_driver_ref_object(ZigBeeDriver *driver)
{
- if (driver == NULL) {
- Z_LOGE("driver is NULL");
- return NULL;
- }
+ zblib_check_null_ret_error("driver", driver, NULL);
return driver->priv_object;
}
-gboolean zblib_driver_set_dispatcher(ZigBeeDriver *driver, ZblibDriverDispatcher_t dispatcher_fn)
+gboolean zblib_driver_set_dispatcher(ZigBeeDriver *driver,
+ ZblibDriverDispatcher_t dispatcher_fn)
{
- if (driver == NULL) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
driver->dispatcher_fn = dispatcher_fn;
return TRUE;
}
-gboolean zblib_driver_set_free_hook(ZigBeeDriver *driver, ZblibDriverFreeHook_t free_hook_fn)
+gboolean zblib_driver_set_free_hook(ZigBeeDriver *driver,
+ ZblibDriverFreeHook_t free_hook_fn)
{
- if (driver == NULL) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
driver->free_hook_fn = free_hook_fn;
ZblibDriverType_e zblib_driver_ref_driver_type(ZigBeeDriver *driver)
{
- if (driver == NULL) {
- Z_LOGE("driver is NULL");
- return ZBLIB_DRIVER_TYPE_NONE;
- }
+ zblib_check_null_ret_error("driver",
+ driver, ZBLIB_DRIVER_TYPE_NONE);
return driver->driver_type;
}
-gboolean zblib_driver_dispatch_request(ZigBeeDriver *driver, guint request_id)
+gboolean zblib_driver_dispatch_request(ZigBeeDriver *driver,
+ guint request_id)
{
- if (driver == NULL) {
- Z_LOGE("driver is NULL");
- return FALSE;
- }
-
- if (NULL == driver->dispatcher_fn) {
- Z_LOGE("dispatcher_fn is NULL");
- return FALSE;
- }
+ zblib_check_null_ret_error("driver", driver, FALSE);
+ zblib_check_null_ret_error("driver->dispatcher_fn",
+ driver->dispatcher_fn, FALSE);
/* Dispatch request to driver dispatcher function */
return driver->dispatcher_fn(driver, request_id);
projects / platform / core / connectivity / zigbee-manager.git / commitdiff