gdbus: add check error in gdbus functions

 when gdbus request to daemon for open/close, it can receive return value TRUE with ret that it is not PERIPEHRAL_ERROR_NONE.
 In the case of requesting open to daemon, getting fd from list is meaningless.
 In the case of requesting close to daemon, proxy deinit function must not be run.

Change-Id: I6ca7b1c98a15ca17159123903cd9d8ebe57c353c
Signed-off-by: Segwon <segwon.han@samsung.com>

diff --git a/src/gdbus/peripheral_gdbus_gpio.c b/src/gdbus/peripheral_gdbus_gpio.c
index ca5badd11cae680b1654fe2cb3938383984b59c5..d03cedab85af03c9db56b03ac9d4e6889b3774c6 100644 (file)
--- a/src/gdbus/peripheral_gdbus_gpio.c
+++ b/src/gdbus/peripheral_gdbus_gpio.c
@@ -68,8 +68,8 @@ static void __gpio_proxy_deinit()
 
 int peripheral_gdbus_gpio_open(peripheral_gpio_h gpio)
 {
+       int ret;
        GError *error = NULL;
-       gint32 ret = PERIPHERAL_ERROR_NONE;
        GUnixFDList *fd_list = NULL;
 
        ret = __gpio_proxy_init();
@@ -85,11 +85,15 @@ int peripheral_gdbus_gpio_open(peripheral_gpio_h gpio)
                        &fd_list,
                        NULL,
                        &error) == FALSE) {
-               _E("Error in %s() : %s", __func__, error->message);
+               _E("Failed to request daemon to gpio open : %s", error->message);
                g_error_free(error);
                return PERIPHERAL_ERROR_UNKNOWN;
        }
 
+       // TODO : If ret is not PERIPHERAL_ERROR_NONE, fd list it NULL from daemon.
+       if (ret != PERIPHERAL_ERROR_NONE)
+               return ret;
+
        gpio->fd_direction = g_unix_fd_list_get(fd_list, GPIO_FD_INDEX_DIRECTION, &error);
        if (gpio->fd_direction < 0) {
                _E("Failed to get fd for gpio direction : %s", error->message);
@@ -118,8 +122,8 @@ int peripheral_gdbus_gpio_open(peripheral_gpio_h gpio)
 
 int peripheral_gdbus_gpio_close(peripheral_gpio_h gpio)
 {
+       int ret;
        GError *error = NULL;
-       peripheral_error_e ret = PERIPHERAL_ERROR_NONE;
 
        if (gpio_proxy == NULL) {
                _E("Can't try to gpio close because gpio proxy is NULL.");
@@ -132,12 +136,14 @@ int peripheral_gdbus_gpio_close(peripheral_gpio_h gpio)
                        &ret,
                        NULL,
                        &error) == FALSE) {
-               _E("Error in %s() : %s", __func__, error->message);
+               _E("Failed to request daemon to gpio close : %s", error->message);
                g_error_free(error);
                return PERIPHERAL_ERROR_UNKNOWN;
        }
 
-       __gpio_proxy_deinit();
+       // TODO : If the return value is not PERIPHERAL_ERROR_NONE, the daemon returns status before close request.
+       if (ret == PERIPHERAL_ERROR_NONE)
+               __gpio_proxy_deinit();
 
        return ret;
 }
\ No newline at end of file

diff --git a/src/gdbus/peripheral_gdbus_i2c.c b/src/gdbus/peripheral_gdbus_i2c.c
index b10b10fee0038ceb3986418eb2fffdf2c1b6885b..5ee89061f378366e0aa26f7f811870949ecf8fd4 100644 (file)
--- a/src/gdbus/peripheral_gdbus_i2c.c
+++ b/src/gdbus/peripheral_gdbus_i2c.c
@@ -66,8 +66,8 @@ static void __i2c_proxy_deinit()
 
 int peripheral_gdbus_i2c_open(peripheral_i2c_h i2c, int bus, int address)
 {
+       int ret;
        GError *error = NULL;
-       peripheral_error_e ret = PERIPHERAL_ERROR_NONE;
        GUnixFDList *fd_list = NULL;
 
        ret = __i2c_proxy_init();
@@ -84,16 +84,19 @@ int peripheral_gdbus_i2c_open(peripheral_i2c_h i2c, int bus, int address)
                        &fd_list,
                        NULL,
                        &error) == FALSE) {
-               _E("Error in %s() : %s", __func__, error->message);
+               _E("Failed to request daemon to i2c open : %s", error->message);
                g_error_free(error);
                return PERIPHERAL_ERROR_UNKNOWN;
        }
 
+       // TODO : If ret is not PERIPHERAL_ERROR_NONE, fd list it NULL from daemon.
+       if (ret != PERIPHERAL_ERROR_NONE)
+               return ret;
+
        i2c->fd = g_unix_fd_list_get(fd_list, I2C_FD_INDEX, &error);
        if (i2c->fd < 0) {
                _E("Failed to get fd for i2c : %s", error->message);
                g_error_free(error);
-               ret = PERIPHERAL_ERROR_UNKNOWN;
        }
 
        g_object_unref(fd_list);
@@ -103,8 +106,8 @@ int peripheral_gdbus_i2c_open(peripheral_i2c_h i2c, int bus, int address)
 
 int peripheral_gdbus_i2c_close(peripheral_i2c_h i2c)
 {
+       int ret;
        GError *error = NULL;
-       peripheral_error_e ret = PERIPHERAL_ERROR_NONE;
 
        if (i2c_proxy == NULL) {
                _E("Can't try to i2c close because i2c proxy is NULL.");
@@ -117,12 +120,14 @@ int peripheral_gdbus_i2c_close(peripheral_i2c_h i2c)
                        &ret,
                        NULL,
                        &error) == FALSE) {
-               _E("Error in %s() : %s", __func__, error->message);
+               _E("Failed to request daemon to i2c close : %s", error->message);
                g_error_free(error);
                return PERIPHERAL_ERROR_UNKNOWN;
        }
 
-       __i2c_proxy_deinit();
+       // TODO : If the return value is not PERIPHERAL_ERROR_NONE, the daemon returns status before close request.
+       if (ret == PERIPHERAL_ERROR_NONE)
+               __i2c_proxy_deinit();
 
        return ret;
-}
\ No newline at end of file
+}

diff --git a/src/gdbus/peripheral_gdbus_pwm.c b/src/gdbus/peripheral_gdbus_pwm.c
index 3279d15364c58379803981902ab9bfbb707caf5c..eb26bf5be11985c9fbc0244407af57ef9076d546 100644 (file)
--- a/src/gdbus/peripheral_gdbus_pwm.c
+++ b/src/gdbus/peripheral_gdbus_pwm.c
@@ -69,8 +69,8 @@ static void __pwm_proxy_deinit()
 
 int peripheral_gdbus_pwm_open(peripheral_pwm_h pwm, int chip, int pin)
 {
+       int ret;
        GError *error = NULL;
-       peripheral_error_e ret = PERIPHERAL_ERROR_NONE;
        GUnixFDList *fd_list = NULL;
 
        ret = __pwm_proxy_init();
@@ -87,11 +87,15 @@ int peripheral_gdbus_pwm_open(peripheral_pwm_h pwm, int chip, int pin)
                        &fd_list,
                        NULL,
                        &error) == FALSE) {
-               _E("%s", error->message);
+               _E("Failed to request daemon to pwm open : %s", error->message);
                g_error_free(error);
                return PERIPHERAL_ERROR_UNKNOWN;
        }
 
+       // TODO : If ret is not PERIPHERAL_ERROR_NONE, fd list it NULL from daemon.
+       if (ret != PERIPHERAL_ERROR_NONE)
+               return ret;
+
        pwm->fd_period = g_unix_fd_list_get(fd_list, PWM_FD_INDEX_PERIOD, &error);
        if (pwm->fd_period < 0) {
                _E("Failed to get fd for pwm period : %s", error->message);
@@ -127,8 +131,8 @@ int peripheral_gdbus_pwm_open(peripheral_pwm_h pwm, int chip, int pin)
 
 int peripheral_gdbus_pwm_close(peripheral_pwm_h pwm)
 {
+       int ret;
        GError *error = NULL;
-       peripheral_error_e ret = PERIPHERAL_ERROR_NONE;
 
        if (pwm_proxy == NULL) {
                _E("Can't try to pwm close because pwm proxy is NULL.");
@@ -141,12 +145,14 @@ int peripheral_gdbus_pwm_close(peripheral_pwm_h pwm)
                        &ret,
                        NULL,
                        &error) == FALSE) {
-               _E("%s", error->message);
+               _E("Failed to request daemon to pwm close : %s", error->message);
                g_error_free(error);
                return PERIPHERAL_ERROR_UNKNOWN;
        }
 
-       __pwm_proxy_deinit();
+       // TODO : If the return value is not PERIPHERAL_ERROR_NONE, the daemon returns status before close request.
+       if (ret == PERIPHERAL_ERROR_NONE)
+               __pwm_proxy_deinit();
 
        return ret;
-}
\ No newline at end of file
+}

diff --git a/src/gdbus/peripheral_gdbus_spi.c b/src/gdbus/peripheral_gdbus_spi.c
index 80e267af88df5d66440def01eb4e273d4a236463..d58edfeb2797f59a49a0e851e72cbbf14af210b2 100644 (file)
--- a/src/gdbus/peripheral_gdbus_spi.c
+++ b/src/gdbus/peripheral_gdbus_spi.c
@@ -66,8 +66,8 @@ static void __spi_proxy_deinit()
 
 int peripheral_gdbus_spi_open(peripheral_spi_h spi, int bus, int cs)
 {
+       int ret;
        GError *error = NULL;
-       peripheral_error_e ret = PERIPHERAL_ERROR_NONE;
        GUnixFDList *fd_list = NULL;
 
        ret = __spi_proxy_init();
@@ -84,11 +84,15 @@ int peripheral_gdbus_spi_open(peripheral_spi_h spi, int bus, int cs)
                        &fd_list,
                        NULL,
                        &error) == FALSE) {
-               _E("%s", error->message);
+               _E("Failed to request daemon to spi open : %s", error->message);
                g_error_free(error);
                return PERIPHERAL_ERROR_UNKNOWN;
        }
 
+       // TODO : If ret is not PERIPHERAL_ERROR_NONE, fd list it NULL from daemon.
+       if (ret != PERIPHERAL_ERROR_NONE)
+               return ret;
+
        spi->fd = g_unix_fd_list_get(fd_list, SPI_FD_INDEX, &error);
        if (spi->fd < 0) {
                _E("Failed to get fd for spi : %s", error->message);
@@ -103,8 +107,8 @@ int peripheral_gdbus_spi_open(peripheral_spi_h spi, int bus, int cs)
 
 int peripheral_gdbus_spi_close(peripheral_spi_h spi)
 {
+       int ret;
        GError *error = NULL;
-       peripheral_error_e ret = PERIPHERAL_ERROR_NONE;
 
        if (spi_proxy == NULL) {
                _E("Can't try to spi close because spi proxy is NULL.");
@@ -117,12 +121,14 @@ int peripheral_gdbus_spi_close(peripheral_spi_h spi)
                        &ret,
                        NULL,
                        &error) == FALSE) {
-               _E("%s", error->message);
+               _E("Failed to request daemon to spi close : %s", error->message);
                g_error_free(error);
                return PERIPHERAL_ERROR_UNKNOWN;
        }
 
-       __spi_proxy_deinit();
+       // TODO : If the return value is not PERIPHERAL_ERROR_NONE, the daemon returns status before close request.
+       if (ret == PERIPHERAL_ERROR_NONE)
+               __spi_proxy_deinit();
 
        return ret;
-}
\ No newline at end of file
+}

diff --git a/src/gdbus/peripheral_gdbus_uart.c b/src/gdbus/peripheral_gdbus_uart.c
index 99620b6f2b46c921af01e0654cb6fd95e8ce6732..985f2b44508a8b66e4428d5288db3710a1ce509d 100644 (file)
--- a/src/gdbus/peripheral_gdbus_uart.c
+++ b/src/gdbus/peripheral_gdbus_uart.c
@@ -66,8 +66,8 @@ static void __uart_proxy_deinit()
 
 int peripheral_gdbus_uart_open(peripheral_uart_h uart, int port)
 {
+       int ret;
        GError *error = NULL;
-       peripheral_error_e ret = PERIPHERAL_ERROR_NONE;
        GUnixFDList *fd_list = NULL;
 
        ret = __uart_proxy_init();
@@ -83,11 +83,15 @@ int peripheral_gdbus_uart_open(peripheral_uart_h uart, int port)
                        &fd_list,
                        NULL,
                        &error) == FALSE) {
-               _E("Error in %s() : %s", __func__, error->message);
+               _E("Failed to request daemon to uart open : %s", error->message);
                g_error_free(error);
                return PERIPHERAL_ERROR_UNKNOWN;
        }
 
+       // TODO : If ret is not PERIPHERAL_ERROR_NONE, fd list it NULL from daemon.
+       if (ret != PERIPHERAL_ERROR_NONE)
+               return ret;
+
        uart->fd = g_unix_fd_list_get(fd_list, UART_FD_INDEX, &error);
        if (uart->fd < 0) {
                _E("Failed to get fd for uart : %s", error->message);
@@ -102,25 +106,28 @@ int peripheral_gdbus_uart_open(peripheral_uart_h uart, int port)
 
 int peripheral_gdbus_uart_close(peripheral_uart_h uart)
 {
+       int ret;
        GError *error = NULL;
-       peripheral_error_e ret = PERIPHERAL_ERROR_NONE;
 
        if (uart_proxy == NULL) {
                _E("Can't try to uart close because uart proxy is NULL.");
                return PERIPHERAL_ERROR_UNKNOWN;
        }
+
        if (peripheral_io_gdbus_uart_call_close_sync(
                        uart_proxy,
                        uart->handle,
                        &ret,
                        NULL,
                        &error) == FALSE) {
-               _E("Error in %s() : %s", __func__, error->message);
+               _E("Failed to request daemon to uart close : %s", error->message);
                g_error_free(error);
                return PERIPHERAL_ERROR_UNKNOWN;
        }
 
-       __uart_proxy_deinit();
+       // TODO : If the return value is not PERIPHERAL_ERROR_NONE, the daemon returns status before close request.
+       if (ret == PERIPHERAL_ERROR_NONE)
+               __uart_proxy_deinit();
 
        return ret;
-}
\ No newline at end of file
+}