Update the debug macro of glib

Change-Id: I7a269f7499bd004cb7526e366cc7395336315c19

diff --git a/client/src/muse_client.c b/client/src/muse_client.c
index 53893f4e2a5c2119195471e4b71ee2578a246975..dea0a93292397e64d78ca7d03613853ae9a0370e 100644 (file)
--- a/client/src/muse_client.c
+++ b/client/src/muse_client.c
@@ -141,7 +141,7 @@ static int _mc_new(muse_channel_e channel)
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
 
        LOGI("Enter");
-       g_return_val_if_fail(channel < MUSE_CHANNEL_MAX, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(channel < MUSE_CHANNEL_MAX, MM_ERROR_INVALID_ARGUMENT);
 
        /* create socket */
        sock_fd = socket(AF_UNIX, SOCK_STREAM, 0);
@@ -201,7 +201,7 @@ static void _mc_table_new(void)
 
 static gpointer _mc_get_fd_ptr(int sock_fd)
 {
-       g_return_val_if_fail(mc_table, NULL);
+       muse_return_val_if_fail(mc_table, NULL);
 
        return g_hash_table_lookup(mc_table, GINT_TO_POINTER(sock_fd));
 }
@@ -246,8 +246,8 @@ int muse_client_ipc_push_data(int sock_fd, const char *data, int size, uint64_t
        muse_recv_data_head_t header;
        int sended_len = 0;
 
-       g_return_val_if_fail(data, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(muse_core_fd_is_valid(sock_fd), MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(data, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(muse_core_fd_is_valid(sock_fd), MM_ERROR_INVALID_ARGUMENT);
 
        header.marker = MUSE_DATA_HEAD;
        header.size = size;
@@ -272,7 +272,7 @@ int muse_client_get_fd_id_value(int sock_fd)
 {
        gpointer sock_id_ptr = _mc_get_fd_ptr(sock_fd);
 
-       g_return_val_if_fail(sock_id_ptr, MUSE_ERR);
+       muse_return_val_if_fail(sock_id_ptr, MUSE_ERR);
 
        return GPOINTER_TO_INT(sock_id_ptr);
 }
@@ -281,7 +281,7 @@ bool muse_client_check_fd_id_value(int sock_fd, int sock_id)
 {
        gpointer sock_id_ptr = _mc_get_fd_ptr(sock_fd);
 
-       g_return_val_if_fail(sock_id_ptr, false);
+       muse_return_val_if_fail(sock_id_ptr, false);
 
        if (sock_id == GPOINTER_TO_INT(sock_id_ptr))
                return true;
@@ -299,13 +299,13 @@ int muse_client_get_module_index(char *module_name, int *module_index)
        bool module_name_matched = false;
        dictionary *mc_dict;
 
-       g_return_val_if_fail(module_name, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(module_index, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(module_name, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(module_index, MM_ERROR_INVALID_ARGUMENT);
 
        LOGD("Enter");
 
        mc_dict = iniparser_load(CONFFILE);
-       g_return_val_if_fail(mc_dict, PARSE_ERROR);
+       muse_return_val_if_fail(mc_dict, PARSE_ERROR);
 
        str = iniparser_getstring(mc_dict, MUSE_HOST, NULL);
        if (!str) {

diff --git a/core/include/muse_core_internal.h b/core/include/muse_core_internal.h
index 5c6bc4c165afead848dfdf769698e25beb4878b3..97016cf4eec038b0061bb7b08aeef9da1b723605 100644 (file)
--- a/core/include/muse_core_internal.h
+++ b/core/include/muse_core_internal.h
@@ -92,6 +92,18 @@ extern "C" {
 #define END_DELIM                                      '}'
 #define END_DELIM_STR                          " }"
 
+#define muse_return_if_fail(expr) \
+       if (!(expr)) { \
+               LOGE("failed [%s]", #expr); \
+               return; \
+       }
+
+#define muse_return_val_if_fail(expr, val) \
+       if (!(expr)) { \
+               LOGE("failed [%s]", #expr); \
+               return (val); \
+       }
+
 #define MUSE_FREE(src) \
        do { \
                if (src) { \

diff --git a/core/src/muse_core.c b/core/src/muse_core.c
index 7f4635e3f9d0e7af415cd077b43b34ae010ebb9a..8de92680c9084a0780d927c85a96318ed71d4451 100644 (file)
--- a/core/src/muse_core.c
+++ b/core/src/muse_core.c
@@ -74,7 +74,7 @@ static json_object *_muse_msg_json_tokener_parse_len(const char *str, int *len,
        struct json_tokener *tok = NULL;
        struct json_object *obj = NULL;
 
-       g_return_val_if_fail(str, NULL);
+       muse_return_val_if_fail(str, NULL);
 
        g_mutex_lock(&msg_lock);
 
@@ -166,9 +166,9 @@ static json_object *_muse_msg_json_find_obj(json_object *jobj, const char *find_
 {
        size_t key_len = 0;
 
-       g_return_val_if_fail(jobj, NULL);
+       muse_return_val_if_fail(jobj, NULL);
 
-       g_return_val_if_fail(find_key, NULL);
+       muse_return_val_if_fail(find_key, NULL);
 
        g_mutex_lock(&msg_lock);
 
@@ -190,7 +190,7 @@ static void _muse_log_get_cmd_info(char *cmd)
        FILE *fp;
        char buf[MUSE_MSG_LEN_MAX];
 
-       g_return_if_fail(cmd);
+       muse_return_if_fail(cmd);
 
        fp = popen(cmd, "r");
 
@@ -303,7 +303,7 @@ void muse_core_fd_close(int fd)
 /* message */
 int muse_core_msg_send(int sock_fd, const char *msg)
 {
-       g_return_val_if_fail(msg, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(msg, MM_ERROR_INVALID_ARGUMENT);
        return muse_core_msg_send_fd(sock_fd, NULL, msg);
 }
 
@@ -319,8 +319,8 @@ int muse_core_msg_send_fd(int sock_fd, int *fds, const char *buf)
        int *fdptr;
        int fd_cnt = 0;
 
-       g_return_val_if_fail(buf, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(muse_core_fd_is_valid(sock_fd), MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(buf, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(muse_core_fd_is_valid(sock_fd), MM_ERROR_INVALID_ARGUMENT);
 
        if (!fds)
                msg_info.type = MUSE_MSG_TYPE_NORMAL;
@@ -391,7 +391,7 @@ _MSG_SEND_DONE:
 
 int muse_core_msg_recv(int sock_fd, char *msg, int msg_len)
 {
-       g_return_val_if_fail(msg, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(msg, MM_ERROR_INVALID_ARGUMENT);
        return muse_core_msg_recv_fd(sock_fd, msg, msg_len, NULL);
 }
 
@@ -406,8 +406,8 @@ int muse_core_msg_recv_fd(int sock_fd, char *buf, int buf_len, int *out_fd)
        char data[CMSG_SPACE(sizeof(int) * MUSE_NUM_FD)];
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
 
-       g_return_val_if_fail(buf, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(muse_core_fd_is_valid(sock_fd), MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(buf, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(muse_core_fd_is_valid(sock_fd), MM_ERROR_INVALID_ARGUMENT);
 
        /* get the msg type and length */
        if (!muse_core_msg_recv_len(sock_fd, (char *)&msg_info, sizeof(muse_msg_info_t))) {
@@ -474,7 +474,7 @@ char *muse_core_msg_new(int api, ...)
 
        jobj = json_object_new_object();
 
-       g_return_val_if_fail(jobj, NULL);
+       muse_return_val_if_fail(jobj, NULL);
 
        json_object_object_add(jobj, MSG_KEY_API, json_object_new_int(api));
 
@@ -499,13 +499,13 @@ bool muse_core_msg_deserialize(const char *key, char *buf, int *parse_len, muse_
        int *int_data;
        json_object *val, *jobj;
 
-       g_return_val_if_fail(key, false);
-       g_return_val_if_fail(buf, false);
-       g_return_val_if_fail(m_type >= MUSE_TYPE_INT && m_type < MUSE_TYPE_MAX, false);
-       g_return_val_if_fail(data, false);
+       muse_return_val_if_fail(key, false);
+       muse_return_val_if_fail(buf, false);
+       muse_return_val_if_fail(m_type >= MUSE_TYPE_INT && m_type < MUSE_TYPE_MAX, false);
+       muse_return_val_if_fail(data, false);
 
        jobj = _muse_msg_json_tokener_parse_len(buf, parse_len, err);
-       g_return_val_if_fail(jobj, false);
+       muse_return_val_if_fail(jobj, false);
 
        val = _muse_msg_json_find_obj(jobj, key);
        if (!val) {
@@ -571,7 +571,7 @@ void muse_core_msg_free(char *msg)
 
 void *muse_core_msg_object_new(char *str, int *parse_len, muse_core_msg_parse_err_e *err)
 {
-       g_return_val_if_fail(str, NULL);
+       muse_return_val_if_fail(str, NULL);
        return (void *)_muse_msg_json_tokener_parse_len(str, parse_len, err);
 }
 
@@ -581,10 +581,10 @@ bool muse_core_msg_object_get_value(const char *key, void *jobj, muse_core_msg_t
        int *int_data;
        json_object *val;
 
-       g_return_val_if_fail(key, false);
-       g_return_val_if_fail(jobj, false);
-       g_return_val_if_fail(data, false);
-       g_return_val_if_fail(m_type >= MUSE_TYPE_INT && m_type < MUSE_TYPE_MAX, false);
+       muse_return_val_if_fail(key, false);
+       muse_return_val_if_fail(jobj, false);
+       muse_return_val_if_fail(data, false);
+       muse_return_val_if_fail(m_type >= MUSE_TYPE_INT && m_type < MUSE_TYPE_MAX, false);
 
        val = _muse_msg_json_find_obj((json_object *)jobj, key);
        if (!val) {
@@ -647,7 +647,7 @@ bool muse_core_msg_object_get_value(const char *key, void *jobj, muse_core_msg_t
 
 void muse_core_msg_object_free(void *jobj)
 {
-       g_return_if_fail(jobj);
+       muse_return_if_fail(jobj);
 
        g_mutex_lock(&msg_lock);
 
@@ -748,7 +748,7 @@ void muse_core_get_cur_time(char *time_buf)
        struct tm newtime;
        struct timeval tv;
 
-       g_return_if_fail(time_buf);
+       muse_return_if_fail(time_buf);
 
        gettimeofday(&tv, NULL);
        strftime(cur_time, MUSE_MSG_LEN, "%m-%d %H:%M:%S", localtime_r(&(tv.tv_sec), &newtime));

diff --git a/server/src/muse_server.c b/server/src/muse_server.c
index 74aa916635f001e2b56a0988c56ed7912224dbd6..3920c6e1df7595937f7f15f34bff9853cef2b7bf 100644 (file)
--- a/server/src/muse_server.c
+++ b/server/src/muse_server.c
@@ -96,7 +96,7 @@ static void _ms_gst_init(char **cmd)
        int gst_param_cnt = ms_config_get_gst_param_cnt();
 
        argc = malloc(sizeof(gint));
-       g_return_if_fail(argc);
+       muse_return_if_fail(argc);
 
        /* add gst_param */
        argv = malloc(sizeof(gchar *) * (gst_param_cnt + 1));
@@ -181,21 +181,21 @@ static int _ms_pidfile_create(const char *path, pid_t pid)
 
 void muse_server_set_dispatch_timeout(muse_module_h m, int disp_api, int timeout)
 {
-       g_return_if_fail(m);
+       muse_return_if_fail(m);
        ms_module_set_timeout(m->idx, disp_api, timeout);
 }
 
 int muse_server_get_dispatch_timeout(muse_module_h m, int disp_api)
 {
-       g_return_val_if_fail(m, MUSE_ERR);
+       muse_return_val_if_fail(m, MUSE_ERR);
        return ms_module_get_timeout(m->idx, disp_api);
 }
 
 /* module */
 int muse_server_module_set_value(muse_module_h m, const char *name, int value)
 {
-       g_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(name, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(name, MM_ERROR_INVALID_ARGUMENT);
        ms_module_set_dllsym_value(m->idx, name, GINT_TO_POINTER(value));
        return MM_ERROR_NONE;
 }
@@ -205,9 +205,9 @@ int muse_server_module_get_value(muse_module_h m, const char *name, int *value)
        int ret = MM_ERROR_NONE;
        gpointer ptr;
 
-       g_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(name, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(value, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(name, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(value, MM_ERROR_INVALID_ARGUMENT);
 
        ret = ms_module_get_dllsym_value(m->idx, name, &ptr);
        if (ret == MM_ERROR_NONE)
@@ -217,31 +217,31 @@ int muse_server_module_get_value(muse_module_h m, const char *name, int *value)
 
 int muse_server_module_get_msg_fd(muse_module_h m)
 {
-       g_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
        return m->ch[MUSE_CHANNEL_MSG].sock_fd;
 }
 
 int muse_server_module_get_data_fd(muse_module_h m)
 {
-       g_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
        return m->ch[MUSE_CHANNEL_DATA].sock_fd;
 }
 
 char *muse_server_module_get_msg(muse_module_h m)
 {
-       g_return_val_if_fail(m, NULL);
+       muse_return_val_if_fail(m, NULL);
        return (m->recv_msg + m->msg_offset);
 }
 
 void muse_server_set_user_data(muse_module_h m, void *data)
 {
-       g_return_if_fail(m);
+       muse_return_if_fail(m);
        m->user_data = data;
 }
 
 void *muse_server_get_user_data(muse_module_h m)
 {
-       g_return_val_if_fail(m, NULL);
+       muse_return_val_if_fail(m, NULL);
        return m->user_data;
 }
 
@@ -250,9 +250,9 @@ int muse_server_ipc_get_bufmgr(tbm_bufmgr *bufmgr)
 {
        LOGD("Enter");
 
-       g_return_val_if_fail(bufmgr, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(bufmgr, MM_ERROR_INVALID_ARGUMENT);
        if (!ms_get_instance()->bufmgr)
-               g_return_val_if_fail(ms_init_bufmgr(), MM_ERROR_INVALID_ARGUMENT);
+               muse_return_val_if_fail(ms_init_bufmgr(), MM_ERROR_INVALID_ARGUMENT);
 
        LOGD("bufmgr: %p", ms_get_instance()->bufmgr);
        *bufmgr = ms_get_instance()->bufmgr;
@@ -265,7 +265,7 @@ int muse_server_ipc_get_gdbus_connection(GDBusConnection **gdbus)
 {
        LOGD("Enter");
 
-       g_return_val_if_fail(gdbus, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(gdbus, MM_ERROR_INVALID_ARGUMENT);
        if (!ms_system_get_gdbus(gdbus))
                return MM_ERROR_UNKNOWN;
 
@@ -279,10 +279,10 @@ char *muse_server_ipc_get_data(muse_module_h m)
        char *raw_data = NULL;
 
        gint64 end_time = g_get_monotonic_time() + 100 * G_TIME_SPAN_MILLISECOND;
-       g_return_val_if_fail(m, NULL);
+       muse_return_val_if_fail(m, NULL);
 
        ch = &m->ch[MUSE_CHANNEL_DATA];
-       g_return_val_if_fail(ch->data_queue, NULL);
+       muse_return_val_if_fail(ch->data_queue, NULL);
 
        g_mutex_lock(&ch->data_mutex);
        while (!(raw_data = (char *)g_queue_pop_head(ch->data_queue))) {
@@ -305,10 +305,7 @@ void muse_server_ipc_delete_data(char *data)
 {
        char *raw_data = NULL;
 
-       if (!data) {
-               LOGE("NULL data");
-               return;
-       }
+       muse_return_if_fail(data);
 
        raw_data = data - sizeof(muse_recv_data_head_t);
 
@@ -319,7 +316,7 @@ bool muse_server_ipc_get_data_info(char *data, uint64_t *data_id, int *size)
 {
        muse_recv_data_t *qdata = NULL;
 
-       g_return_val_if_fail(data, false);
+       muse_return_val_if_fail(data, false);
 
        qdata = (muse_recv_data_t *)(data - sizeof(muse_recv_data_head_t));
        if (qdata && qdata->header.marker == MUSE_DATA_HEAD) {
@@ -336,16 +333,15 @@ bool muse_server_ipc_get_data_info(char *data, uint64_t *data_id, int *size)
 
 intptr_t muse_server_ipc_get_handle(muse_module_h m)
 {
-       g_return_val_if_fail(m, 0);
-       if (!m->handle)
-               return 0;
+       muse_return_val_if_fail(m, 0);
+       muse_return_val_if_fail(m->handle, 0);
 
        return m->handle;
 }
 
 int muse_server_ipc_set_handle(muse_module_h m, intptr_t handle)
 {
-       g_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
 
        m->handle = handle;
        return MM_ERROR_NONE;
@@ -353,8 +349,8 @@ int muse_server_ipc_set_handle(muse_module_h m, intptr_t handle)
 
 int muse_server_ipc_get_fd(muse_module_h m, int *fd)
 {
-       g_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(fd, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(fd, MM_ERROR_INVALID_ARGUMENT);
 
        *fd = m->ch[MUSE_CHANNEL_MSG].tbm_fd;
        return MM_ERROR_NONE;
@@ -362,7 +358,7 @@ int muse_server_ipc_get_fd(muse_module_h m, int *fd)
 
 int muse_server_ipc_set_fd(muse_module_h m, int fd)
 {
-       g_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
 
        if (!muse_core_fd_is_valid(fd)) {
                LOGE("invalid fd: %d", fd);
@@ -396,7 +392,7 @@ int muse_server_get_platform_info(const char *key, bool *value)
 int muse_server_get_module_instance_count(int idx)
 {
        ms_connection_t *connection = ms_get_instance()->connection;
-       g_return_val_if_fail(connection, MUSE_ERR);
+       muse_return_val_if_fail(connection, MUSE_ERR);
 
        return connection->instance_count[idx];
 }

diff --git a/server/src/muse_server_config.c b/server/src/muse_server_config.c
index 0bf3bf836ed68244ef3b92235aa876524e958046..d031effc56ba293a1d188ad00197b473b1ad4da9 100644 (file)
--- a/server/src/muse_server_config.c
+++ b/server/src/muse_server_config.c
@@ -29,8 +29,8 @@ static char *_ms_config_get_str(dictionary *d, const char *key, char *def)
 {
        char *str = NULL;
 
-       g_return_val_if_fail(d, NULL);
-       g_return_val_if_fail(key, NULL);
+       muse_return_val_if_fail(d, NULL);
+       muse_return_val_if_fail(key, NULL);
 
        str = iniparser_getstring(d, key, def);
        if (!str) {
@@ -43,8 +43,8 @@ static char *_ms_config_get_str(dictionary *d, const char *key, char *def)
 
 static int _ms_config_get_int(dictionary *d, const char *key, int def)
 {
-       g_return_val_if_fail(d, PARSE_ERROR);
-       g_return_val_if_fail(key, PARSE_ERROR);
+       muse_return_val_if_fail(d, PARSE_ERROR);
+       muse_return_val_if_fail(key, PARSE_ERROR);
 
        return iniparser_getint(d, key, def);
 }
@@ -58,10 +58,10 @@ static int _ms_config_parser(ms_config_t *conf)
        char *key = NULL;
        char gst_param_key[MUSE_MSG_LEN_MAX];
 
-       g_return_val_if_fail(conf, PARSE_ERROR);
+       muse_return_val_if_fail(conf, PARSE_ERROR);
 
        conf->muse_dict = iniparser_load(CONFFILE);
-       g_return_val_if_fail(conf->muse_dict, PARSE_ERROR);
+       muse_return_val_if_fail(conf->muse_dict, PARSE_ERROR);
 
        conf->hosts = _ms_config_get_str(conf->muse_dict, MUSE_HOST, NULL);
        if (!conf->hosts) {
@@ -185,7 +185,7 @@ out:
 
 void ms_config_init(ms_config_t *conf)
 {
-       g_return_if_fail(conf);
+       muse_return_if_fail(conf);
 
        if (_ms_config_parser(conf) != MM_ERROR_NONE)
                LOGE("parser() error");
@@ -197,7 +197,7 @@ void ms_config_deinit(ms_config_t *conf)
        char *host = NULL;
        char *ptr = NULL;
 
-       g_return_if_fail(conf);
+       muse_return_if_fail(conf);
 
        if (conf->muse_dict)
                iniparser_freedict(conf->muse_dict);
@@ -236,8 +236,8 @@ char *ms_config_get_host(int idx)
 {
        ms_config_t *conf = ms_get_instance()->conf;
 
-       g_return_val_if_fail(conf, NULL);
-       g_return_val_if_fail(conf->host, NULL);
+       muse_return_val_if_fail(conf, NULL);
+       muse_return_val_if_fail(conf->host, NULL);
 
        return conf->host[idx];
 }
@@ -246,7 +246,7 @@ int ms_config_get_host_cnt(void)
 {
        ms_config_t *conf = ms_get_instance()->conf;
 
-       g_return_val_if_fail(conf, MUSE_ERR);
+       muse_return_val_if_fail(conf, MUSE_ERR);
        return conf->host_cnt;
 }
 
@@ -254,7 +254,7 @@ int ms_config_get_gst_param_cnt(void)
 {
        ms_config_t *conf = ms_get_instance()->conf;
 
-       g_return_val_if_fail(conf, MUSE_ERR);
+       muse_return_val_if_fail(conf, MUSE_ERR);
 
        return conf->gst_param_cnt;
 }
@@ -263,8 +263,8 @@ char *ms_config_get_gst_param_str(int idx)
 {
        ms_config_t *conf = ms_get_instance()->conf;
 
-       g_return_val_if_fail(conf, NULL);
-       g_return_val_if_fail(conf->gst_param_str[idx], NULL);
+       muse_return_val_if_fail(conf, NULL);
+       muse_return_val_if_fail(conf->gst_param_str[idx], NULL);
        return conf->gst_param_str[idx];
 }
 
@@ -273,10 +273,10 @@ char *ms_config_get_path(int idx)
        char *path = NULL;
        ms_config_t *conf = ms_get_instance()->conf;
 
-       g_return_val_if_fail(conf, NULL);
+       muse_return_val_if_fail(conf, NULL);
 
        path = conf->host_infos[idx]->path;
-       g_return_val_if_fail(path, NULL);
+       muse_return_val_if_fail(path, NULL);
 
        LOGD("%s", path);
        return path;
@@ -287,10 +287,10 @@ char *ms_config_get_preloaded_value(int idx)
        char *value = NULL;
        ms_config_t *conf = ms_get_instance()->conf;
 
-       g_return_val_if_fail(conf, NULL);
+       muse_return_val_if_fail(conf, NULL);
 
        value = conf->host_infos[idx]->preloaded;
-       g_return_val_if_fail(value, NULL);
+       muse_return_val_if_fail(value, NULL);
 
        return value;
 }

diff --git a/server/src/muse_server_connection.c b/server/src/muse_server_connection.c
index 38598d35953763f4a99ba99b81d01af7bef3ef31..3f4896f9deebe359dd688987a8cd8f03c8c549c5 100644 (file)
--- a/server/src/muse_server_connection.c
+++ b/server/src/muse_server_connection.c
@@ -38,10 +38,10 @@ static void _ms_connection_module_instance_info(muse_module_h m, ms_connection_t
        int idx, len, caution_instance;
        ms_config_t *conf = ms_get_instance()->conf;
 
-       g_return_if_fail(m);
-       g_return_if_fail(connection);
-       g_return_if_fail(queue);
-       g_return_if_fail(conf);
+       muse_return_if_fail(m);
+       muse_return_if_fail(connection);
+       muse_return_if_fail(queue);
+       muse_return_if_fail(conf);
 
        len = g_queue_get_length(queue);
 
@@ -79,9 +79,9 @@ int ms_connection_register(muse_module_h m)
 
        LOGD("Enter");
 
-       g_return_val_if_fail(connection, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(connection->instance_queue, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(connection, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(connection->instance_queue, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
 
        ms_connection_lock(connection);
 
@@ -118,9 +118,9 @@ int ms_connection_unregister(muse_module_h m)
 
        LOGD("Enter");
 
-       g_return_val_if_fail(connection, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(connection->instance_queue, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(connection, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(connection->instance_queue, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
 
        ms_connection_lock(connection);
 
@@ -148,7 +148,7 @@ gboolean ms_connection_get_state(ms_connection_state_e *state)
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
        ms_connection_t *connection = ms_get_instance()->connection;
 
-       g_return_val_if_fail(connection, FALSE);
+       muse_return_val_if_fail(connection, FALSE);
 
        ep_fd = connection->epfd;
 
@@ -197,19 +197,19 @@ gboolean ms_connection_get_state(ms_connection_state_e *state)
 
 void ms_connection_lock(ms_connection_t *connection)
 {
-       g_return_if_fail(connection);
+       muse_return_if_fail(connection);
        g_mutex_lock(&connection->lock);
 }
 
 void ms_connection_unlock(ms_connection_t *connection)
 {
-       g_return_if_fail(connection);
+       muse_return_if_fail(connection);
        g_mutex_unlock(&connection->lock);
 }
 
 void ms_connection_deinit(ms_connection_t *connection)
 {
-       g_return_if_fail(connection);
+       muse_return_if_fail(connection);
 
        g_queue_free(connection->instance_queue);
 
@@ -222,13 +222,13 @@ void ms_connection_deinit(ms_connection_t *connection)
 
 void ms_connection_init(ms_connection_t *connection)
 {
-       g_return_if_fail(connection);
+       muse_return_if_fail(connection);
 
        connection->epfd = epoll_create(MS_EVENT_MAX);
-       g_return_if_fail(muse_core_fd_is_valid(connection->epfd));
+       muse_return_if_fail(muse_core_fd_is_valid(connection->epfd));
 
        connection->instance_queue = g_queue_new();
-       g_return_if_fail(connection->instance_queue);
+       muse_return_if_fail(connection->instance_queue);
 
        g_mutex_init(&connection->lock);
 }

diff --git a/server/src/muse_server_ipc.c b/server/src/muse_server_ipc.c
index 2fd0250fba603a48093bf3604c9c95f8eaa73250..7f702a021426704bdaec42ea9d8512a567b5494b 100644 (file)
--- a/server/src/muse_server_ipc.c
+++ b/server/src/muse_server_ipc.c
@@ -36,7 +36,7 @@ static gpointer _ms_ipc_data_worker(gpointer data);
 
 static void _ms_ipc_module_cleanup(muse_module_h m, void *jobj)
 {
-       g_return_if_fail(m);
+       muse_return_if_fail(m);
 
        g_mutex_lock(&m->ch[MUSE_CHANNEL_DATA].data_mutex);
        g_queue_free(m->ch[MUSE_CHANNEL_DATA].data_queue);
@@ -64,7 +64,7 @@ static gboolean _ms_ipc_module_instance_creation_is_allowed(int module_idx)
 {
        int max_instance, created_module_instance_count;
 
-       g_return_val_if_fail(ms_check_module_idx(module_idx), FALSE);
+       muse_return_val_if_fail(ms_check_module_idx(module_idx), FALSE);
 
        max_instance = ms_get_instance()->conf->host_infos[module_idx]->max_instance;
        created_module_instance_count = muse_server_get_module_instance_count(module_idx);
@@ -89,10 +89,10 @@ static gpointer _ms_ipc_dispatch_worker(gpointer data)
        int tbm_fd[MUSE_NUM_FD] = { MUSE_ERR, };
        int pid = MUSE_ERR;
 
-       g_return_val_if_fail(data, NULL);
+       muse_return_val_if_fail(data, NULL);
 
        m = (muse_module_h)data;
-       g_return_val_if_fail(m, NULL);
+       muse_return_val_if_fail(m, NULL);
 
        fd = m->ch[MUSE_CHANNEL_MSG].sock_fd;
 
@@ -272,7 +272,7 @@ static gpointer _ms_ipc_data_worker(gpointer data)
        muse_module_h m = NULL;
        muse_channel_info_t *ch = NULL;
 
-       g_return_val_if_fail(data, NULL);
+       muse_return_val_if_fail(data, NULL);
 
        m = (muse_module_h)data;
        SECURE_LOGW("module : %p", m);
@@ -301,10 +301,10 @@ int ms_ipc_get_module_idx_from_job(ms_workqueue_job_t *job)
        LOGD("Enter");
        muse_module_h m = NULL;
 
-       g_return_val_if_fail(job, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(job, MM_ERROR_INVALID_ARGUMENT);
 
        m = (muse_module_h)job->user_data;
-       g_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
 
        LOGD("Leave");
        return m->idx;
@@ -316,11 +316,11 @@ gboolean ms_ipc_job_function(ms_workqueue_job_t *job)
        GError *error = NULL;
 
        LOGD("Enter");
-       g_return_val_if_fail(job, FALSE);
-       g_return_val_if_fail(ms_is_running(), FALSE);
+       muse_return_val_if_fail(job, FALSE);
+       muse_return_val_if_fail(ms_is_running(), FALSE);
 
        m = (muse_module_h)job->user_data;
-       g_return_val_if_fail(m, FALSE);
+       muse_return_val_if_fail(m, FALSE);
 
        SECURE_LOGD("[%p] module's msg channel fd : %d", m, m->ch[MUSE_CHANNEL_MSG].sock_fd);
 
@@ -331,7 +331,7 @@ gboolean ms_ipc_job_function(ms_workqueue_job_t *job)
                ms_log_process_info(ms_get_instance()->pid);
        }
 
-       g_return_val_if_fail(m->ch[MUSE_CHANNEL_MSG].data_thread, FALSE);
+       muse_return_val_if_fail(m->ch[MUSE_CHANNEL_MSG].data_thread, FALSE);
        free(job);
 
        LOGD("Leave");
@@ -345,11 +345,11 @@ gboolean ms_ipc_data_job_function(ms_workqueue_job_t *job)
 
        LOGD("Enter");
 
-       g_return_val_if_fail(job, FALSE);
-       g_return_val_if_fail(ms_is_running(), FALSE);
+       muse_return_val_if_fail(job, FALSE);
+       muse_return_val_if_fail(ms_is_running(), FALSE);
 
        m = (muse_module_h)job->user_data;
-       g_return_val_if_fail(m, FALSE);
+       muse_return_val_if_fail(m, FALSE);
 
        m->ch[MUSE_CHANNEL_DATA].data_thread = g_thread_try_new(DATA_THREAD_NAME, _ms_ipc_data_worker, (gpointer)m, &error);
        if (!m->ch[MUSE_CHANNEL_DATA].data_thread && error) {
@@ -360,7 +360,7 @@ gboolean ms_ipc_data_job_function(ms_workqueue_job_t *job)
                muse_core_connection_close(m->ch[MUSE_CHANNEL_MSG].sock_fd);
        }
 
-       g_return_val_if_fail(m->ch[MUSE_CHANNEL_DATA].data_thread, FALSE);
+       muse_return_val_if_fail(m->ch[MUSE_CHANNEL_DATA].data_thread, FALSE);
        free(job);
 
        LOGD("Leave");

diff --git a/server/src/muse_server_log.c b/server/src/muse_server_log.c
index ee3d9c4df78afdb484d5e20136e95c33971c39ee..9307a230736209cd24ab7bca8de306d6af6d471c 100644 (file)
--- a/server/src/muse_server_log.c
+++ b/server/src/muse_server_log.c
@@ -46,7 +46,7 @@ static gboolean _ms_log_pid_is_valid(pid_t pid)
 {
        char log_buf[MUSE_MSG_LEN_MAX];
 
-       g_return_val_if_fail(ms_is_log_enabled(), FALSE);
+       muse_return_val_if_fail(ms_is_log_enabled(), FALSE);
 
        snprintf(log_buf, sizeof(log_buf), "/proc/%d", (int)pid);
 
@@ -62,8 +62,8 @@ static void _ms_log_latest_msgs(ms_log_t *log)
 {
        int idx = 0;
 
-       g_return_if_fail(ms_is_log_enabled());
-       g_return_if_fail(log);
+       muse_return_if_fail(ms_is_log_enabled());
+       muse_return_if_fail(log);
 
        g_mutex_lock(&log->lock);
 
@@ -83,10 +83,10 @@ static void _ms_log_pid_time(ms_log_t *log, int pid)
        char log_buf[MUSE_MSG_LEN_MAX];
        char time_buf[MUSE_LOG_MSG_LEN];
 
-       g_return_if_fail(ms_is_log_enabled());
-       g_return_if_fail(log);
-       g_return_if_fail(muse_core_fd_is_valid(log->fd));
-       g_return_if_fail(_ms_log_pid_is_valid(pid));
+       muse_return_if_fail(ms_is_log_enabled());
+       muse_return_if_fail(log);
+       muse_return_if_fail(muse_core_fd_is_valid(log->fd));
+       muse_return_if_fail(_ms_log_pid_is_valid(pid));
 
        muse_core_get_cur_time(time_buf);
        snprintf(log_buf, sizeof(log_buf), "[PID] %d %s", pid, time_buf);
@@ -99,10 +99,10 @@ static void _ms_log_cmdline(ms_log_t *log, int pid)
        char log_buf[MUSE_MSG_LEN_MAX];
        FILE *fp;
 
-       g_return_if_fail(ms_is_log_enabled());
-       g_return_if_fail(log);
-       g_return_if_fail(muse_core_fd_is_valid(log->fd));
-       g_return_if_fail(_ms_log_pid_is_valid(pid));
+       muse_return_if_fail(ms_is_log_enabled());
+       muse_return_if_fail(log);
+       muse_return_if_fail(muse_core_fd_is_valid(log->fd));
+       muse_return_if_fail(_ms_log_pid_is_valid(pid));
 
        snprintf(log_buf, sizeof(log_buf), "/proc/%d/cmdline", pid);
        fp = fopen(log_buf, "r");
@@ -120,10 +120,10 @@ static void _ms_log_process_info(ms_log_t *log, int pid)
        char log_buf[MUSE_MSG_LEN_MAX];
        FILE *fp;
 
-       g_return_if_fail(ms_is_log_enabled());
-       g_return_if_fail(log);
-       g_return_if_fail(muse_core_fd_is_valid(log->fd));
-       g_return_if_fail(_ms_log_pid_is_valid(pid));
+       muse_return_if_fail(ms_is_log_enabled());
+       muse_return_if_fail(log);
+       muse_return_if_fail(muse_core_fd_is_valid(log->fd));
+       muse_return_if_fail(_ms_log_pid_is_valid(pid));
 
        snprintf(log_buf, sizeof(log_buf), "/bin/ps -Lo pcpu,pmem,tid,comm -p %d", pid);
        fp = popen(log_buf, "r");
@@ -147,9 +147,9 @@ static void _ms_log_api_info(ms_log_t *log)
        gpointer ptr;
        int idx;
 
-       g_return_if_fail(ms_is_log_enabled());
-       g_return_if_fail(log);
-       g_return_if_fail(muse_core_fd_is_valid(log->fd));
+       muse_return_if_fail(ms_is_log_enabled());
+       muse_return_if_fail(log);
+       muse_return_if_fail(muse_core_fd_is_valid(log->fd));
 
        for (idx = 0; idx < ms_get_instance()->conf->host_cnt; idx++) {
                ms_module_get_dllsym_value(idx, DISPATCHER_PTR, &ptr);
@@ -169,12 +169,12 @@ static void _ms_log_binary_info(ms_log_t *log)
        char *value;
        char *ptr = NULL;
 
-       g_return_if_fail(ms_is_log_enabled());
-       g_return_if_fail(log);
-       g_return_if_fail(muse_core_fd_is_valid(log->fd));
+       muse_return_if_fail(ms_is_log_enabled());
+       muse_return_if_fail(log);
+       muse_return_if_fail(muse_core_fd_is_valid(log->fd));
 
        fp = fopen("/etc/tizen-release", "r");
-       g_return_if_fail(fp);
+       muse_return_if_fail(fp);
 
        while (fgets(log_buf, MUSE_MSG_LEN_MAX, fp)) {
                label = strtok_r(log_buf, delimiter, &ptr);
@@ -199,7 +199,7 @@ static int _ms_fd_set_block(int fd)
        int flags;
        int ret;
 
-       g_return_val_if_fail(ms_is_log_enabled(), MM_ERROR_NOT_SUPPORT_API);
+       muse_return_val_if_fail(ms_is_log_enabled(), MM_ERROR_NOT_SUPPORT_API);
 
        flags = fcntl(fd, F_GETFL);
        ret = fcntl(fd, F_SETFL, flags & (U32BITS ^ O_NONBLOCK));
@@ -221,8 +221,8 @@ static void _ms_log_create_fd(ms_log_t *log)
        struct stat st;
        char file[MAX_FILE_NUM][MUSE_MSG_LEN];
 
-       g_return_if_fail(ms_is_log_enabled());
-       g_return_if_fail(log);
+       muse_return_if_fail(ms_is_log_enabled());
+       muse_return_if_fail(log);
 
        for (idx = 0; idx < MAX_FILE_NUM; idx++)
                snprintf(file[idx], strlen(MUSE_LOG_FILE) + 3, "%s.%d", MUSE_LOG_FILE, idx);
@@ -262,11 +262,11 @@ static void _ms_log_set_fd(ms_log_t *log)
        if (!ms_is_log_enabled())
                return;
 
-       g_return_if_fail(log);
+       muse_return_if_fail(log);
 
        _ms_log_create_fd(log);
 
-       g_return_if_fail(muse_core_fd_is_valid(log->fd));
+       muse_return_if_fail(muse_core_fd_is_valid(log->fd));
 
        if (fcntl(log->fd, F_SETFD, FD_CLOEXEC) < 0) {
                strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
@@ -279,8 +279,8 @@ static void _ms_log_set_fd(ms_log_t *log)
 static void _ms_log_cache_latest_msg(ms_log_t *log, int pid, char *msg)
 {
        char time_buf[MUSE_LOG_MSG_LEN];
-       g_return_if_fail(msg);
-       g_return_if_fail(log);
+       muse_return_if_fail(msg);
+       muse_return_if_fail(log);
 
        g_mutex_lock(&log->lock);
 
@@ -294,7 +294,7 @@ static void _ms_log_cache_latest_msg(ms_log_t *log, int pid, char *msg)
 
 void ms_log_init(ms_log_t *log)
 {
-       g_return_if_fail(log);
+       muse_return_if_fail(log);
 
        g_mutex_init(&log->lock);
        _ms_log_set_fd(log);
@@ -304,9 +304,9 @@ void ms_log_deinit(ms_log_t *log)
 {
        LOGD("Enter");
 
-       g_return_if_fail(log);
+       muse_return_if_fail(log);
 
-       g_return_if_fail(ms_is_log_enabled());
+       muse_return_if_fail(ms_is_log_enabled());
        g_mutex_clear(&log->lock);
 
        MUSE_FREE(log);
@@ -318,8 +318,8 @@ void ms_log_save_addr_name(int pid, gpointer addr)
 {
        Dl_info info;
 
-       g_return_if_fail(ms_is_log_enabled());
-       g_return_if_fail(addr);
+       muse_return_if_fail(ms_is_log_enabled());
+       muse_return_if_fail(addr);
 
        memset(&info, 0, sizeof(info));
 
@@ -333,10 +333,10 @@ void ms_log_debug_pid_info(int pid)
 {
        ms_log_t *log;
 
-       g_return_if_fail(ms_is_log_enabled());
+       muse_return_if_fail(ms_is_log_enabled());
 
        log = ms_get_instance()->log;
-       g_return_if_fail(log);
+       muse_return_if_fail(log);
 
        /* pid */
        _ms_log_pid_time(log, pid);
@@ -361,10 +361,10 @@ void ms_log_write(char *buf)
 {
        ms_log_t *log = ms_get_instance()->log;
 
-       g_return_if_fail(ms_is_log_enabled());
-       g_return_if_fail(log);
-       g_return_if_fail(muse_core_fd_is_valid(log->fd));
-       g_return_if_fail(buf);
+       muse_return_if_fail(ms_is_log_enabled());
+       muse_return_if_fail(log);
+       muse_return_if_fail(muse_core_fd_is_valid(log->fd));
+       muse_return_if_fail(buf);
 
        if (write(log->fd, buf, strlen(buf)) == WRITE_FAIL)
                LOGE("There was an error writing module pid to logfile");
@@ -377,7 +377,7 @@ void ms_log_get_cmd_info(char *cmd)
        FILE *fp;
        char buf[MUSE_MSG_LEN_MAX];
 
-       g_return_if_fail(cmd);
+       muse_return_if_fail(cmd);
 
        fp = popen(cmd, "r");
 

diff --git a/server/src/muse_server_module.c b/server/src/muse_server_module.c
index 298482c9d8731a1c647c48dcf450fb290ceee25e..c0f8b42b3e1927f25a1d63acb03d263962de3017 100644 (file)
--- a/server/src/muse_server_module.c
+++ b/server/src/muse_server_module.c
@@ -56,7 +56,7 @@ static gboolean _ms_module_dispatch_timeout_callback(gpointer data)
 
 static gboolean _ms_module_enable_dispatch_timeout_callback(int cmd, muse_module_h m)
 {
-       g_return_val_if_fail(m, TRUE);
+       muse_return_val_if_fail(m, TRUE);
 
        if (cmd == ms_get_instance()->conf->host_infos[m->idx]->disable_watchdog_api)
                return FALSE;
@@ -68,7 +68,7 @@ static void _ms_module_set_loaded_dllsym(int idx, GModule *dllsym, gboolean valu
 {
        ms_module_t *module = ms_get_module_instance(idx);
 
-       g_return_if_fail(module);
+       muse_return_if_fail(module);
 
        module->loaded = value;
        module->dllsym = dllsym;
@@ -80,7 +80,7 @@ GModule *ms_module_open(int idx)
        GModule *dllsym = NULL;
        ms_module_t *module = ms_get_module_instance(idx);
 
-       g_return_val_if_fail(module, NULL);
+       muse_return_val_if_fail(module, NULL);
 
        g_mutex_lock(&module->lock);
 
@@ -103,13 +103,13 @@ GModule *ms_module_open(int idx)
 
 void ms_module_dispatch_lock(muse_module_h m)
 {
-       g_return_if_fail(m);
+       muse_return_if_fail(m);
        g_mutex_lock(&m->dispatch_lock);
 }
 
 void ms_module_dispatch_unlock(muse_module_h m)
 {
-       g_return_if_fail(m);
+       muse_return_if_fail(m);
        g_mutex_unlock(&m->dispatch_lock);
 }
 
@@ -122,11 +122,11 @@ int ms_module_dispatch(muse_module_h m, int cmd)
        muse_module_dispatchfunc *dispatcher = NULL;
        ms_module_t *module = NULL;
 
-       g_return_val_if_fail(m, MUSE_ERR);
+       muse_return_val_if_fail(m, MUSE_ERR);
 
        module = ms_get_module_instance(m->idx);
-       g_return_val_if_fail(module, MUSE_ERR);
-       g_return_val_if_fail(module->dllsym, MUSE_ERR);
+       muse_return_val_if_fail(module, MUSE_ERR);
+       muse_return_val_if_fail(module->dllsym, MUSE_ERR);
 
        g_mutex_lock(&module->lock);
        g_module_symbol(module->dllsym, DISPATCHER, (gpointer *)&dispatcher);
@@ -164,10 +164,10 @@ gboolean ms_module_close(muse_module_h m)
 {
        ms_module_t *module = NULL;
 
-       g_return_val_if_fail(m, FALSE);
+       muse_return_val_if_fail(m, FALSE);
 
        module = ms_get_module_instance(m->idx);
-       g_return_val_if_fail(module, FALSE);
+       muse_return_val_if_fail(module, FALSE);
 
        g_mutex_lock(&module->lock);
 
@@ -187,7 +187,7 @@ gboolean ms_module_close(muse_module_h m)
 GModule *ms_module_get_dllsym(int idx)
 {
        ms_module_t *module = ms_get_module_instance(idx);
-       g_return_val_if_fail(module, NULL);
+       muse_return_val_if_fail(module, NULL);
 
        return module->dllsym;
 }
@@ -195,7 +195,7 @@ GModule *ms_module_get_dllsym(int idx)
 gboolean ms_module_get_loaded_dllsym(int idx)
 {
        ms_module_t *module = ms_get_module_instance(idx);
-       g_return_val_if_fail(module, false);
+       muse_return_val_if_fail(module, false);
 
        return module->loaded;
 }
@@ -204,8 +204,8 @@ void ms_module_set_dllsym_value(int idx, const char *name, gpointer value)
 {
        ms_module_t *module = ms_get_module_instance(idx);
 
-       g_return_if_fail(module);
-       g_return_if_fail(name);
+       muse_return_if_fail(module);
+       muse_return_if_fail(name);
 
        g_mutex_lock(&dllsym_table_lock);
        g_hash_table_insert(module->dllsym_table, g_strdup(name), value);
@@ -216,8 +216,8 @@ int ms_module_get_dllsym_value(int idx, const char *name, gpointer *value)
 {
        ms_module_t *module = ms_get_module_instance(idx);
 
-       g_return_val_if_fail(module, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(name, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(module, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(name, MM_ERROR_INVALID_ARGUMENT);
 
        if (value) {
                *value = g_hash_table_lookup(module->dllsym_table, name);
@@ -231,8 +231,8 @@ void ms_module_set_timeout(int idx, int disp_api, int timeout)
 {
        ms_module_t *module = ms_get_module_instance(idx);
 
-       g_return_if_fail(module);
-       g_return_if_fail(timeout >= ms_get_instance()->conf->min_timeout && timeout <= ms_get_instance()->conf->max_timeout);
+       muse_return_if_fail(module);
+       muse_return_if_fail(timeout >= ms_get_instance()->conf->min_timeout && timeout <= ms_get_instance()->conf->max_timeout);
 
        g_mutex_lock(&module->lock);
 
@@ -244,14 +244,14 @@ void ms_module_set_timeout(int idx, int disp_api, int timeout)
 int ms_module_get_timeout(int idx, int disp_api)
 {
        ms_module_t *module = ms_get_module_instance(idx);
-       g_return_val_if_fail(module, MUSE_ERR);
+       muse_return_val_if_fail(module, MUSE_ERR);
 
        return module->disp_timeout[disp_api];
 }
 
 void ms_module_deinit(ms_module_t *module)
 {
-       g_return_if_fail(module);
+       muse_return_if_fail(module);
 
        g_mutex_clear(&module->lock);
        g_module_close(module->dllsym);
@@ -266,12 +266,12 @@ void ms_module_init(ms_module_t *module)
 
        LOGD("Enter");
 
-       g_return_if_fail(module);
+       muse_return_if_fail(module);
 
        g_mutex_init(&module->lock);
        module->loaded = FALSE;
        module->dllsym_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
-       g_return_if_fail(module->dllsym_table);
+       muse_return_if_fail(module->dllsym_table);
        for (disp_idx = 0; disp_idx < MUSE_DISPATCHER_MAX; disp_idx++)
                ms_module_set_timeout(module->idx, disp_idx, ms_get_instance()->conf->host_infos[module->idx]->timeout);
 

diff --git a/server/src/muse_server_private.c b/server/src/muse_server_private.c
index 9174470da411e7d7357d5266eedd7ea46dc3328f..b99176f1f8ebb647795b5f2f21e48c724b05a605 100644 (file)
--- a/server/src/muse_server_private.c
+++ b/server/src/muse_server_private.c
@@ -59,7 +59,7 @@ static int _ms_run(void)
 {
        int fd, already_running;
 
-       g_return_val_if_fail(muse_server, MUSE_ERR);
+       muse_return_val_if_fail(muse_server, MUSE_ERR);
 
        /* First, check whether the existing file is locked. */
        fd = open(muse_server->conf->lockfile, O_RDONLY);
@@ -101,7 +101,7 @@ static bool _ms_attach(int fd, muse_module_callback callback, gpointer param)
        GIOChannel *channel = NULL;
        GSource *src = NULL;
 
-       g_return_val_if_fail(muse_server, false);
+       muse_return_val_if_fail(muse_server, false);
 
        channel = g_io_channel_unix_new(fd);
        if (!channel)
@@ -130,7 +130,7 @@ static void _ms_create_new_server_from_fd(int fd[], int type)
 
        LOGD("Enter");
 
-       g_return_if_fail(muse_server);
+       muse_return_if_fail(muse_server);
 
        muse_server->msg_fd = fd[MUSE_CHANNEL_MSG];
        muse_server->data_fd = fd[MUSE_CHANNEL_DATA];
@@ -161,7 +161,7 @@ static int _ms_new(muse_channel_e channel)
        socklen_t address_len;
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
 
-       g_return_val_if_fail(channel < MUSE_CHANNEL_MAX, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(channel < MUSE_CHANNEL_MAX, MM_ERROR_INVALID_ARGUMENT);
 
        unlink(UDS_files[channel]);
 
@@ -264,10 +264,10 @@ static gboolean _ms_connection_handler(GIOChannel *source, GIOCondition conditio
 
        LOGI("Enter");
 
-       g_return_val_if_fail(muse_server, FALSE);
+       muse_return_val_if_fail(muse_server, FALSE);
 
        connection = muse_server->connection;
-       g_return_val_if_fail(connection, FALSE);
+       muse_return_val_if_fail(connection, FALSE);
 
        _ms_lock_state();
 
@@ -424,7 +424,7 @@ static void _ms_check_idle_state(void)
        struct timeval tv_c, tv_r;
        int instance_number, timeout;
 
-       g_return_if_fail(muse_server);
+       muse_return_if_fail(muse_server);
 
        gettimeofday(&tv_c, NULL);
        timersub(&tv_c, &muse_server->tv_s, &tv_r);
@@ -444,7 +444,7 @@ static void _ms_check_connection_event(void)
 {
        ms_connection_state_e state = MUSE_CONNECTION_STATE_INVALID;
 
-       g_return_if_fail(muse_server);
+       muse_return_if_fail(muse_server);
 
        if (ms_connection_get_state(&state)) {
                gettimeofday(&muse_server->tv_s, NULL);
@@ -459,7 +459,7 @@ static void _ms_check_connection_event(void)
 
 gpointer _ms_diag_thread(gpointer data)
 {
-       g_return_val_if_fail(muse_server, NULL);
+       muse_return_val_if_fail(muse_server, NULL);
 
        while (1) {
                if (muse_server->conf->is_on_demand == TRUE)
@@ -473,13 +473,13 @@ gpointer _ms_diag_thread(gpointer data)
 
 static void _ms_lock_state(void)
 {
-       g_return_if_fail(muse_server);
+       muse_return_if_fail(muse_server);
        g_mutex_lock(&muse_server->state_lock);
 }
 
 static void _ms_unlock_state(void)
 {
-       g_return_if_fail(muse_server);
+       muse_return_if_fail(muse_server);
        g_mutex_unlock(&muse_server->state_lock);
 }
 
@@ -490,44 +490,44 @@ void ms_init(void)
        LOGD("Enter");
 
        muse_server = calloc(1, sizeof(muse_server_t));
-       g_return_if_fail(muse_server);
+       muse_return_if_fail(muse_server);
 
        muse_server->system = calloc(1, sizeof(ms_system_t));
-       g_return_if_fail(muse_server->system);
+       muse_return_if_fail(muse_server->system);
        ms_system_init(muse_server->system);
 
        muse_server->conf = calloc(1, sizeof(ms_config_t));
-       g_return_if_fail(muse_server->conf);
+       muse_return_if_fail(muse_server->conf);
        ms_config_init(muse_server->conf);
 
        muse_server->log = calloc(1, sizeof(ms_log_t));
-       g_return_if_fail(muse_server->log);
+       muse_return_if_fail(muse_server->log);
        ms_log_init(muse_server->log);
 
        muse_server->security = calloc(1, sizeof(ms_security_t));
-       g_return_if_fail(muse_server->security);
+       muse_return_if_fail(muse_server->security);
        ms_security_init(muse_server->security);
 
        for (idx = 0; idx < muse_server->conf->host_cnt; idx++) {
                muse_server->module[idx] = calloc(1, sizeof(ms_module_t));
-               g_return_if_fail(muse_server->module[idx]);
+               muse_return_if_fail(muse_server->module[idx]);
                muse_server->module[idx]->idx = idx;
                ms_module_init(muse_server->module[idx]);
        }
 
 #ifdef MUSE_USE_WATCHDOG
        muse_server->watchdog = calloc(1, sizeof(ms_watchdog_t));
-       g_return_if_fail(muse_server->watchdog);
+       muse_return_if_fail(muse_server->watchdog);
        if (ms_watchdog_init(muse_server->watchdog) != MM_ERROR_NONE)
                LOGE("Fail to initialize server watchdog");
 #endif
 
        muse_server->workqueue = (ms_workqueue_t *)calloc(1, sizeof(ms_workqueue_t));
-       g_return_if_fail(muse_server->workqueue);
+       muse_return_if_fail(muse_server->workqueue);
        ms_workqueue_init(muse_server->workqueue);
 
        muse_server->connection = calloc(1, sizeof(ms_connection_t));
-       g_return_if_fail(muse_server->connection);
+       muse_return_if_fail(muse_server->connection);
        ms_connection_init(muse_server->connection);
 
        ms_signal_init();
@@ -558,7 +558,7 @@ gboolean ms_check_module_idx(int idx)
 
 ms_module_t *ms_get_module_instance(int idx)
 {
-       g_return_val_if_fail(ms_check_module_idx(idx), NULL);
+       muse_return_val_if_fail(ms_check_module_idx(idx), NULL);
 
        return muse_server->module[idx];
 }
@@ -570,7 +570,7 @@ int ms_deinit(void)
 
        LOGD("Enter");
 
-       g_return_val_if_fail(muse_server, retval);
+       muse_return_val_if_fail(muse_server, retval);
 
 #ifdef MUSE_USE_WATCHDOG
        if (ms_watchdog_deinit(muse_server->watchdog) == MM_ERROR_NONE)
@@ -618,13 +618,13 @@ void ms_check_memory(int pid)
        ms_connection_t *connection = NULL;
        ms_config_t *conf = NULL;
 
-       g_return_if_fail(muse_server);
+       muse_return_if_fail(muse_server);
 
        connection = muse_server->connection;
-       g_return_if_fail(connection);
+       muse_return_if_fail(connection);
 
        conf = muse_server->conf;
-       g_return_if_fail(conf);
+       muse_return_if_fail(conf);
 
        _ms_lock_state();
 
@@ -693,11 +693,11 @@ int ms_run(void)
 
        LOGW("Enter");
 
-       g_return_val_if_fail(_ms_run() == MM_ERROR_NONE, MUSE_ERR);
-       g_return_val_if_fail(muse_server, MUSE_ERR);
+       muse_return_val_if_fail(_ms_run() == MM_ERROR_NONE, MUSE_ERR);
+       muse_return_val_if_fail(muse_server, MUSE_ERR);
 
        muse_server->main_loop = g_main_loop_new(NULL, FALSE);
-       g_return_val_if_fail(muse_server->main_loop, MUSE_ERR);
+       muse_return_val_if_fail(muse_server->main_loop, MUSE_ERR);
 
        ms_new();
 
@@ -777,7 +777,7 @@ void ms_exit_worker(muse_module_h m)
 {
        LOGD("Enter");
 
-       g_return_if_fail(m);
+       muse_return_if_fail(m);
 
        SECURE_LOGD("[close] [%d] MUSE_CHANNEL_MSG %p", m->ch[MUSE_CHANNEL_MSG].sock_fd, m);
        muse_core_connection_close(m->ch[MUSE_CHANNEL_MSG].sock_fd);
@@ -807,7 +807,7 @@ void ms_respawn(int signo)
        pid_t pid = getpid();
        LOGE("send %d process signal %d", (int)pid, signo);
 
-       g_return_if_fail(muse_server);
+       muse_return_if_fail(muse_server);
 
        ms_set_state(MUSE_SERVER_STATE_IDLE);
        ms_kill_thread(signo);
@@ -815,7 +815,7 @@ void ms_respawn(int signo)
 
 int ms_get_pid(muse_module_h m)
 {
-       g_return_val_if_fail(m, MUSE_ERR);
+       muse_return_val_if_fail(m, MUSE_ERR);
        return m->pid;
 }
 
@@ -857,7 +857,7 @@ void ms_deinit_bufmgr(void)
 {
        LOGD("Enter");
 
-       g_return_if_fail(muse_server->bufmgr);
+       muse_return_if_fail(muse_server->bufmgr);
 
        tbm_bufmgr_deinit(muse_server->bufmgr);
 
@@ -871,8 +871,8 @@ void ms_cmd_dispatch_foreach_func(gpointer data, gpointer user_data)
        muse_module_command_e cmd;
        muse_external_storage_info_t *storage;
 
-       g_return_if_fail(m);
-       g_return_if_fail(dispatch);
+       muse_return_if_fail(m);
+       muse_return_if_fail(dispatch);
 
        cmd = dispatch->cmd;
 
@@ -890,7 +890,7 @@ void ms_cmd_dispatch_foreach_func(gpointer data, gpointer user_data)
 
 void ms_set_state(ms_state_e state)
 {
-       g_return_if_fail(muse_server);
+       muse_return_if_fail(muse_server);
 
        g_mutex_lock(&muse_server->state_lock);
        muse_server->state = state;

diff --git a/server/src/muse_server_security.c b/server/src/muse_server_security.c
index 81dd5cc28c5ae432ba7380fc86eccaf344050849..37a63d7f485e74e4ee0a5a759c54d9fbe53b4606 100644 (file)
--- a/server/src/muse_server_security.c
+++ b/server/src/muse_server_security.c
@@ -40,7 +40,7 @@ static int _ms_security_cynara_new(ms_security_t *security)
        int ret, error = -1;
        cynara_configuration *p_conf = NULL;
 
-       g_return_val_if_fail(security, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(security, MM_ERROR_INVALID_ARGUMENT);
 
        if (security->p_cynara) {
                LOGE("[CYNARA] Improper usage of cynara");
@@ -74,7 +74,7 @@ end:
 
 static void _ms_security_cynara_free(ms_security_t *security)
 {
-       g_return_if_fail(security);
+       muse_return_if_fail(security);
 
        if (security->p_cynara) {
                cynara_finish((cynara *)security->p_cynara);
@@ -86,7 +86,7 @@ void ms_security_init(ms_security_t *security)
 {
        LOGD("Enter");
 
-       g_return_if_fail(security);
+       muse_return_if_fail(security);
 
        _ms_security_cynara_new(security);
 
@@ -97,7 +97,7 @@ void ms_security_deinit(ms_security_t *security)
 {
        LOGD("Enter");
 
-       g_return_if_fail(security);
+       muse_return_if_fail(security);
 
        _ms_security_cynara_free(security);
 
@@ -113,7 +113,7 @@ bool ms_security_is_privilege_granted(ms_security_t *security, int fd, const cha
        char *client = NULL;
        char *session = NULL;
 
-       g_return_val_if_fail(security, false);
+       muse_return_val_if_fail(security, false);
 
        ret = cynara_creds_socket_get_user(fd, USER_METHOD_DEFAULT, &user);
        if (ret != CYNARA_API_SUCCESS) {

diff --git a/server/src/muse_server_signal.c b/server/src/muse_server_signal.c
index 101e95afadac24e0a47a5704a71e91bada9fdd81..91ccb9069835c4921db55e164b733e899574d617 100644 (file)
--- a/server/src/muse_server_signal.c
+++ b/server/src/muse_server_signal.c
@@ -144,8 +144,8 @@ static void _ms_signal_backtrace(void *arg)
 
 static void _ms_signal_sigaction(int signo, siginfo_t *si, void *arg)
 {
-       g_return_if_fail(si);
-       g_return_if_fail(arg);
+       muse_return_if_fail(si);
+       muse_return_if_fail(arg);
 
 #ifdef MUSE_USE_LWIPC
        if (LwipcResetEvent(MUSE_SERVER_READY) < 0)

diff --git a/server/src/muse_server_system.c b/server/src/muse_server_system.c
index 008288e479694e3ebac707c6d1bc10ba7da4721f..59ce206b977b81ea4447163ea2cb3fe824fc1ac2 100644 (file)
--- a/server/src/muse_server_system.c
+++ b/server/src/muse_server_system.c
@@ -39,8 +39,8 @@ static void _ms_system_unsubscribe_poweroff_state_change(void);
 static void _ms_system_unsubscribe_poweroff_state_change(void)
 {
        ms_system_t *system = ms_get_instance()->system;
-       g_return_if_fail(system);
-       g_return_if_fail(system->connection);
+       muse_return_if_fail(system);
+       muse_return_if_fail(system->connection);
 
        g_dbus_connection_signal_unsubscribe(system->connection, system->muse_poweroff_id);
 }
@@ -56,11 +56,11 @@ static void _ms_poweroff_state_changed_cb(GDBusConnection *con, const gchar *sen
 
        LOGE("received power off signal");
 
-       g_return_if_fail(system);
-       g_return_if_fail(connection);
-       g_return_if_fail(object_path);
-       g_return_if_fail(signal_name);
-       g_return_if_fail(parameters);
+       muse_return_if_fail(system);
+       muse_return_if_fail(connection);
+       muse_return_if_fail(object_path);
+       muse_return_if_fail(signal_name);
+       muse_return_if_fail(parameters);
 
        if (g_strcmp0(object_path, MS_POWER_DBUS_PATH) || g_strcmp0(signal_name, MS_POWER_DBUS_MSG)) {
                LOGE("object_path : %s signal_name : %s", object_path, signal_name);
@@ -72,7 +72,7 @@ static void _ms_poweroff_state_changed_cb(GDBusConnection *con, const gchar *sen
        LOGE("POWER OFF TYPE = %d", val_int);
 
        /* muse has to restart when MUSE_POWER_OFF_DIRECT and MUSE_POWER_OFF_RESTART */
-       g_return_if_fail(val_int > MUSE_POWER_OFF_POPUP);
+       muse_return_if_fail(val_int > MUSE_POWER_OFF_POPUP);
 
        _ms_system_unsubscribe_poweroff_state_change();
 
@@ -101,8 +101,8 @@ static void _ms_external_storage_state_changed_cb(int storage_id, storage_dev_e
        ms_system_t *system = (ms_system_t *)user_data;
        ms_connection_t *connection = ms_get_instance()->connection;
 
-       g_return_if_fail(system);
-       g_return_if_fail(connection);
+       muse_return_if_fail(system);
+       muse_return_if_fail(connection);
 
        switch (state) {
        case STORAGE_STATE_UNMOUNTABLE:
@@ -144,7 +144,7 @@ void ms_system_init(ms_system_t *system)
 {
        GError *error = NULL;
 
-       g_return_if_fail(system);
+       muse_return_if_fail(system);
 
        LOGD("Enter");
 
@@ -157,7 +157,7 @@ void ms_system_init(ms_system_t *system)
        }
 
        system->platform_info_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
-       g_return_if_fail(system->platform_info_table);
+       muse_return_if_fail(system->platform_info_table);
 
        g_mutex_init(&system->lock);
 
@@ -166,7 +166,7 @@ void ms_system_init(ms_system_t *system)
 
 void ms_system_deinit(ms_system_t *system)
 {
-       g_return_if_fail(system);
+       muse_return_if_fail(system);
 
        _ms_system_unsubscribe_poweroff_state_change();
 
@@ -184,9 +184,9 @@ int ms_system_subscribe_poweroff_state_change(ms_system_t *system)
 {
        LOGD("Enter");
 
-       g_return_val_if_fail(system, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(system, MM_ERROR_INVALID_ARGUMENT);
 
-       g_return_val_if_fail(system->connection, MM_ERROR_UNKNOWN);
+       muse_return_val_if_fail(system->connection, MM_ERROR_UNKNOWN);
 
        system->muse_poweroff_id = g_dbus_connection_signal_subscribe(system->connection, NULL,
                MS_POWER_DBUS_INTERFACE, MS_POWER_DBUS_MSG, NULL, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
@@ -219,9 +219,9 @@ int ms_system_get_platform_info(const char *key, bool *value)
        gpointer orig_value;
        ms_system_t *system = ms_get_instance()->system;
 
-       g_return_val_if_fail(system, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(key, MM_ERROR_INVALID_ARGUMENT);
-       g_return_val_if_fail(value, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(system, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(key, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(value, MM_ERROR_INVALID_ARGUMENT);
 
        g_mutex_lock(&system->lock);
 
@@ -278,8 +278,8 @@ gboolean ms_system_get_gdbus(GDBusConnection **connection)
        ms_system_t *system;
 
        system = ms_get_instance()->system;
-       g_return_val_if_fail(system, FALSE);
-       g_return_val_if_fail(system->connection, FALSE);
+       muse_return_val_if_fail(system, FALSE);
+       muse_return_val_if_fail(system->connection, FALSE);
 
        *connection = system->connection;
 

diff --git a/server/src/muse_server_tool.c b/server/src/muse_server_tool.c
index 979fe6fb1db0300d5600a9b1b7a85c90651249db..f6a14ba66f991f4c522286f2dea1a8bc0d2718de 100644 (file)
--- a/server/src/muse_server_tool.c
+++ b/server/src/muse_server_tool.c
@@ -135,7 +135,7 @@ void ms_recursive_rmdir(const char *path)
        FTS *fts;
        FTSENT *ftsent;
 
-       g_return_if_fail(path);
+       muse_return_if_fail(path);
 
        char *const paths[] = { (char *)path, NULL };
 

diff --git a/server/src/muse_server_watchdog.c b/server/src/muse_server_watchdog.c
index 5b713aa2cde89526af662660dcb916a342537249..6e135dfa51eee0766121aea7f5afede46f642f28 100644 (file)
--- a/server/src/muse_server_watchdog.c
+++ b/server/src/muse_server_watchdog.c
@@ -28,7 +28,7 @@ static gboolean _ms_watchdog_timer_cb(gpointer data)
 {
        ms_watchdog_t *watchdog = (ms_watchdog_t *)data;
 
-       g_return_val_if_fail(watchdog, FALSE);
+       muse_return_val_if_fail(watchdog, FALSE);
 
        g_mutex_lock(&watchdog->lock);
        g_cond_signal(&watchdog->cond);
@@ -44,7 +44,7 @@ static gpointer _ms_watchdog_thread(gpointer data)
        guint try_count = 0;
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
 
-       g_return_val_if_fail(watchdog, NULL);
+       muse_return_val_if_fail(watchdog, NULL);
 
        LOGW("watchdog start : %p", watchdog);
 
@@ -76,7 +76,7 @@ static gpointer _ms_watchdog_thread(gpointer data)
 
 int ms_watchdog_init(ms_watchdog_t *watchdog)
 {
-       g_return_val_if_fail(watchdog, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(watchdog, MM_ERROR_INVALID_ARGUMENT);
 
        g_mutex_init(&watchdog->lock);
        g_cond_init(&watchdog->cond);
@@ -87,7 +87,7 @@ int ms_watchdog_init(ms_watchdog_t *watchdog)
 
 int ms_watchdog_deinit(ms_watchdog_t *watchdog)
 {
-       g_return_val_if_fail(watchdog, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(watchdog, MM_ERROR_INVALID_ARGUMENT);
 
        g_mutex_clear(&watchdog->lock);
        g_cond_clear(&watchdog->cond);
@@ -97,7 +97,7 @@ int ms_watchdog_deinit(ms_watchdog_t *watchdog)
 
 gboolean ms_watchdog_attach(ms_watchdog_t *watchdog)
 {
-       g_return_val_if_fail(watchdog, FALSE);
+       muse_return_val_if_fail(watchdog, FALSE);
 
        watchdog->thread = g_thread_try_new("muse_server_watchdog",
                                                                                _ms_watchdog_thread,
@@ -117,7 +117,7 @@ int ms_watchdog_detach(ms_watchdog_t *watchdog)
 {
        gboolean rm_success = FALSE;
 
-       g_return_val_if_fail(watchdog, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(watchdog, MM_ERROR_INVALID_ARGUMENT);
 
        g_mutex_lock(&watchdog->lock);
        watchdog->run = FALSE;

diff --git a/server/src/muse_server_workqueue.c b/server/src/muse_server_workqueue.c
index a704f251dc7fb299fb0747f69ca072bee8b93538..bb0d8534d758adb94c7ff79b0545a677cbb923ed 100644 (file)
--- a/server/src/muse_server_workqueue.c
+++ b/server/src/muse_server_workqueue.c
@@ -28,7 +28,7 @@ static void *_ms_workqueue_worker_function(void *ptr)
        ms_workqueue_job_t *job;
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
 
-       g_return_val_if_fail(worker, NULL);
+       muse_return_val_if_fail(worker, NULL);
 
        while (1) {
                pthread_mutex_lock(&worker->workqueue->jobs_mutex);
@@ -72,14 +72,14 @@ void ms_workqueue_init(ms_workqueue_t *workqueue)
 
        LOGD("Enter");
 
-       g_return_if_fail(workqueue);
+       muse_return_if_fail(workqueue);
 
        memcpy(&workqueue->jobs_mutex, &blank_mutex, sizeof(workqueue->jobs_mutex));
        memcpy(&workqueue->jobs_cond, &blank_cond, sizeof(workqueue->jobs_cond));
 
        for (idx = 0; idx < MUSE_WORK_THREAD_NUM; idx++) {
                worker = calloc(1, sizeof(ms_workqueue_worker_t));
-               g_return_if_fail(worker);
+               muse_return_if_fail(worker);
                worker->workqueue = workqueue;
                if (pthread_create(&worker->thread, NULL, _ms_workqueue_worker_function, (void *)worker)) {
                        LOGE("Failed to start all worker threads");
@@ -102,7 +102,7 @@ void ms_workqueue_deinit(ms_workqueue_t *workqueue)
 
        LOGD("Enter");
 
-       g_return_if_fail(workqueue);
+       muse_return_if_fail(workqueue);
 
        /* Set all workers to terminate. */
        for (worker = workqueue->workers; worker; worker = worker->next)
@@ -120,7 +120,7 @@ void ms_workqueue_deinit(ms_workqueue_t *workqueue)
 
 void ms_workqueue_add_job(ms_workqueue_t *workqueue, ms_workqueue_job_t *job)
 {
-       g_return_if_fail(workqueue);
+       muse_return_if_fail(workqueue);
 
        pthread_mutex_lock(&workqueue->jobs_mutex);
        LL_ADD(job, workqueue->waiting_jobs);

diff --git a/unittest/muse_gtest_socket.cpp b/unittest/muse_gtest_socket.cpp
index 1d9996504fa023668e2c74f396e17644f4279f46..f9afe732309e6985b94a32c567776027a8ad1332 100644 (file)
--- a/unittest/muse_gtest_socket.cpp
+++ b/unittest/muse_gtest_socket.cpp
@@ -78,7 +78,7 @@ static int _client_open(muse_channel_e channel)
        int sock_fd;
 
        LOGI("Enter");
-       g_return_val_if_fail(channel < MUSE_CHANNEL_MAX, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(channel < MUSE_CHANNEL_MAX, MM_ERROR_INVALID_ARGUMENT);
 
        /* create socket */
        sock_fd = socket(AF_UNIX, SOCK_STREAM, 0);