From: Suresh Kumar N Date: Wed, 28 Dec 2016 12:46:58 +0000 (+0530) Subject: Implement module dispatcher functions X-Git-Tag: submit/tizen/20170512.045637~61 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;ds=sidebyside;h=4bb3660ee581e83c6d5f2f19e42c7e9486f9f1dc;p=platform%2Fcore%2Fconnectivity%2Fzigbee-manager.git Implement module dispatcher functions Change-Id: I4138335f9f98a067cd6e90688fad9085c83e0466 Signed-off-by: Suresh Kumar N --- diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_alarm.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_alarm.c index 19b8bf9..a2f8796 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_alarm.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_alarm.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,26 +55,50 @@ static gboolean __zblib_driver_alarm_dispatcher(ZigBeeDriver *driver, guint requ 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; @@ -78,24 +106,20 @@ static gboolean __zblib_driver_alarm_dispatcher(ZigBeeDriver *driver, guint requ 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); @@ -109,17 +133,11 @@ ZigBeeDriver *zblib_driver_alarm_new(ZigBeePlugin *plugin, 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)); @@ -168,10 +186,7 @@ ZigBeeDriver *zblib_driver_alarm_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_custom.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_custom.c index 6957e1d..1e52591 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_custom.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_custom.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,14 +55,26 @@ static gboolean __zblib_driver_custom_dispatcher(ZigBeeDriver *driver, guint req 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; @@ -66,24 +82,20 @@ static gboolean __zblib_driver_custom_dispatcher(ZigBeeDriver *driver, guint req 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); @@ -97,17 +109,11 @@ ZigBeeDriver *zblib_driver_custom_new(ZigBeePlugin *plugin, 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)); @@ -156,10 +162,7 @@ ZigBeeDriver *zblib_driver_custom_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_door_lock.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_door_lock.c index c06350a..df4f3ae 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_door_lock.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_door_lock.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,18 +55,33 @@ static gboolean __zblib_driver_door_lock_dispatcher(ZigBeeDriver *driver, guint 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; @@ -70,24 +89,20 @@ static gboolean __zblib_driver_door_lock_dispatcher(ZigBeeDriver *driver, guint 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); @@ -101,17 +116,11 @@ ZigBeeDriver *zblib_driver_door_lock_new(ZigBeePlugin *plugin, 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)); @@ -160,10 +169,7 @@ ZigBeeDriver *zblib_driver_door_lock_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_fan_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_fan_control.c index b01117b..a9fe2ed 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_fan_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_fan_control.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,18 +55,34 @@ static gboolean __zblib_driver_fan_control_dispatcher(ZigBeeDriver *driver, guin 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; @@ -70,24 +90,20 @@ static gboolean __zblib_driver_fan_control_dispatcher(ZigBeeDriver *driver, guin 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); @@ -101,17 +117,11 @@ ZigBeeDriver *zblib_driver_fan_control_new(ZigBeePlugin *plugin, 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)); @@ -160,10 +170,7 @@ ZigBeeDriver *zblib_driver_fan_control_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_level_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_level_control.c index 69028f7..8aa9c22 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_level_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_level_control.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,30 +55,58 @@ static gboolean __zblib_driver_level_control_dispatcher(ZigBeeDriver *driver, gu 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; @@ -82,24 +114,20 @@ static gboolean __zblib_driver_level_control_dispatcher(ZigBeeDriver *driver, gu 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); @@ -113,17 +141,11 @@ ZigBeeDriver *zblib_driver_level_control_new(ZigBeePlugin *plugin, 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)); @@ -172,10 +194,7 @@ ZigBeeDriver *zblib_driver_level_control_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_mfglib_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_mfglib_control.c index b7a8846..95cf751 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_mfglib_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_mfglib_control.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,70 +55,138 @@ static gboolean __zblib_driver_mfglib_control_dispatcher(ZigBeeDriver *driver, g 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; @@ -122,24 +194,20 @@ static gboolean __zblib_driver_mfglib_control_dispatcher(ZigBeeDriver *driver, g 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); @@ -153,17 +221,11 @@ ZigBeeDriver *zblib_driver_mfglib_control_new(ZigBeePlugin *plugin, 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)); @@ -212,10 +274,7 @@ ZigBeeDriver *zblib_driver_mfglib_control_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_on_off.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_on_off.c index 643e2bc..737c836 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_on_off.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_on_off.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,10 +55,18 @@ static gboolean __zblib_driver_on_off_dispatcher(ZigBeeDriver *driver, guint req 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; @@ -62,24 +74,20 @@ static gboolean __zblib_driver_on_off_dispatcher(ZigBeeDriver *driver, guint req 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); @@ -93,17 +101,11 @@ ZigBeeDriver *zblib_driver_on_off_new(ZigBeePlugin *plugin, 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)); @@ -152,10 +154,7 @@ ZigBeeDriver *zblib_driver_on_off_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_service.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_service.c index fd7ff58..8f5e9a8 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_service.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_service.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,66 +55,130 @@ static gboolean __zblib_driver_service_dispatcher(ZigBeeDriver *driver, guint re 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; @@ -118,24 +186,20 @@ static gboolean __zblib_driver_service_dispatcher(ZigBeeDriver *driver, guint re 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); @@ -149,17 +213,11 @@ ZigBeeDriver *zblib_driver_service_new(ZigBeePlugin *plugin, 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)); @@ -208,10 +266,7 @@ ZigBeeDriver *zblib_driver_service_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_thermostat.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_thermostat.c index ea60480..310464a 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_thermostat.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_thermostat.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,22 +55,42 @@ static gboolean __zblib_driver_thermostat_dispatcher(ZigBeeDriver *driver, guint 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; @@ -74,24 +98,20 @@ static gboolean __zblib_driver_thermostat_dispatcher(ZigBeeDriver *driver, guint 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); @@ -105,17 +125,11 @@ ZigBeeDriver *zblib_driver_thermostat_new(ZigBeePlugin *plugin, 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)); @@ -164,10 +178,7 @@ ZigBeeDriver *zblib_driver_thermostat_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_color.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_color.c index 9f713bc..a52a53d 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_color.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_color.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,46 +55,90 @@ static gboolean __zblib_driver_zcl_color_dispatcher(ZigBeeDriver *driver, guint 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; @@ -98,24 +146,20 @@ static gboolean __zblib_driver_zcl_color_dispatcher(ZigBeeDriver *driver, guint 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); @@ -129,17 +173,11 @@ ZigBeeDriver *zblib_driver_zcl_color_new(ZigBeePlugin *plugin, 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)); @@ -188,10 +226,7 @@ ZigBeeDriver *zblib_driver_zcl_color_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_group.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_group.c index 8209366..5866faf 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_group.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_group.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,26 +55,50 @@ static gboolean __zblib_driver_zcl_group_dispatcher(ZigBeeDriver *driver, guint 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; @@ -78,24 +106,20 @@ static gboolean __zblib_driver_zcl_group_dispatcher(ZigBeeDriver *driver, guint 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); @@ -109,17 +133,11 @@ ZigBeeDriver *zblib_driver_zcl_group_new(ZigBeePlugin *plugin, 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)); @@ -168,10 +186,7 @@ ZigBeeDriver *zblib_driver_zcl_group_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_poll_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_poll_control.c index b1e60ad..a93ec00 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_poll_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_poll_control.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,18 +55,34 @@ static gboolean __zblib_driver_zcl_poll_control_dispatcher(ZigBeeDriver *driver, 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; @@ -70,24 +90,20 @@ static gboolean __zblib_driver_zcl_poll_control_dispatcher(ZigBeeDriver *driver, 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); @@ -101,17 +117,11 @@ ZigBeeDriver *zblib_driver_zcl_poll_control_new(ZigBeePlugin *plugin, 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)); @@ -160,10 +170,7 @@ ZigBeeDriver *zblib_driver_zcl_poll_control_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_scene.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_scene.c index 67139c2..0663447 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_scene.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zcl_scene.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,30 +55,58 @@ static gboolean __zblib_driver_zcl_scene_dispatcher(ZigBeeDriver *driver, guint 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; @@ -82,24 +114,20 @@ static gboolean __zblib_driver_zcl_scene_dispatcher(ZigBeeDriver *driver, guint 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); @@ -113,17 +141,11 @@ ZigBeeDriver *zblib_driver_zcl_scene_new(ZigBeePlugin *plugin, 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)); @@ -172,10 +194,7 @@ ZigBeeDriver *zblib_driver_zcl_scene_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclbasic_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclbasic_control.c index d8f4958..2eff222 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclbasic_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclbasic_control.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,6 +55,10 @@ static gboolean __zblib_driver_zclbasic_control_dispatcher(ZigBeeDriver *driver, 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; @@ -58,24 +66,20 @@ static gboolean __zblib_driver_zclbasic_control_dispatcher(ZigBeeDriver *driver, 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); @@ -89,17 +93,11 @@ ZigBeeDriver *zblib_driver_zclbasic_control_new(ZigBeePlugin *plugin, 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)); @@ -148,10 +146,7 @@ ZigBeeDriver *zblib_driver_zclbasic_control_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclglobal_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclglobal_control.c index 22cfbd1..0f96c11 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclglobal_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclglobal_control.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,50 +55,98 @@ static gboolean __zblib_driver_zclglobal_control_dispatcher(ZigBeeDriver *driver 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; @@ -102,24 +154,20 @@ static gboolean __zblib_driver_zclglobal_control_dispatcher(ZigBeeDriver *driver 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); @@ -133,17 +181,11 @@ ZigBeeDriver *zblib_driver_zclglobal_control_new(ZigBeePlugin *plugin, 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)); @@ -192,10 +234,7 @@ ZigBeeDriver *zblib_driver_zclglobal_control_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclias_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclias_control.c index 9702382..72f5ecd 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclias_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclias_control.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,6 +55,10 @@ static gboolean __zblib_driver_zclias_control_dispatcher(ZigBeeDriver *driver, g 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; @@ -58,24 +66,20 @@ static gboolean __zblib_driver_zclias_control_dispatcher(ZigBeeDriver *driver, g 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); @@ -89,17 +93,11 @@ ZigBeeDriver *zblib_driver_zclias_control_new(ZigBeePlugin *plugin, 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)); @@ -148,10 +146,7 @@ ZigBeeDriver *zblib_driver_zclias_control_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclidentify_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclidentify_control.c index 0644eb9..7d1ff91 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclidentify_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zclidentify_control.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,10 +55,18 @@ static gboolean __zblib_driver_zclidentify_control_dispatcher(ZigBeeDriver *driv 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; @@ -62,24 +74,20 @@ static gboolean __zblib_driver_zclidentify_control_dispatcher(ZigBeeDriver *driv 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); @@ -93,17 +101,11 @@ ZigBeeDriver *zblib_driver_zclidentify_control_new(ZigBeePlugin *plugin, 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)); @@ -152,10 +154,7 @@ ZigBeeDriver *zblib_driver_zclidentify_control_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdo_bind.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdo_bind.c index c844d59..bd76f87 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdo_bind.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdo_bind.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,10 +55,18 @@ static gboolean __zblib_driver_zdo_bind_dispatcher(ZigBeeDriver *driver, guint r 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; @@ -62,24 +74,20 @@ static gboolean __zblib_driver_zdo_bind_dispatcher(ZigBeeDriver *driver, guint r 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); @@ -93,17 +101,11 @@ ZigBeeDriver *zblib_driver_zdo_bind_new(ZigBeePlugin *plugin, 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)); diff --git a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdodev_control.c b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdodev_control.c index 9ad3696..451703a 100644 --- a/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdodev_control.c +++ b/zigbee-daemon/zigbee-lib/src/drivers/zblib_driver_zdodev_control.c @@ -30,19 +30,23 @@ typedef struct { 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); @@ -51,70 +55,138 @@ static gboolean __zblib_driver_zdodev_control_dispatcher(ZigBeeDriver *driver, g 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; @@ -122,24 +194,20 @@ static gboolean __zblib_driver_zdodev_control_dispatcher(ZigBeeDriver *driver, g 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); @@ -153,17 +221,11 @@ ZigBeeDriver *zblib_driver_zdodev_control_new(ZigBeePlugin *plugin, 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)); @@ -212,10 +274,7 @@ ZigBeeDriver *zblib_driver_zdodev_control_new(ZigBeePlugin *plugin, 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); diff --git a/zigbee-daemon/zigbee-lib/src/zblib_driver.c b/zigbee-daemon/zigbee-lib/src/zblib_driver.c index a14b779..b6d1538 100644 --- a/zigbee-daemon/zigbee-lib/src/zblib_driver.c +++ b/zigbee-daemon/zigbee-lib/src/zblib_driver.c @@ -54,10 +54,7 @@ ZigBeeDriver *zblib_driver_new(ZigBeePlugin *plugin, 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) @@ -71,30 +68,22 @@ void zblib_driver_free(ZigBeeDriver *driver) 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; @@ -103,32 +92,25 @@ gboolean zblib_driver_link_object(ZigBeeDriver *driver, gpointer 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; @@ -137,25 +119,18 @@ gboolean zblib_driver_set_free_hook(ZigBeeDriver *driver, ZblibDriverFreeHook_t 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);