Resolve the ASAN issue of heap-use-after-free

 - The issue is accessing connection and workqueue during g_main_quit
    1. Set null after free
    2. Update the 'state' variable during g_main_quit
    3. Update muse_server_config part separately

Change-Id: I2d8daa2714e9f463a29c04c3a028e352d4b2b5b2

diff --git a/server/include/muse_server_config.h b/server/include/muse_server_config.h
index e35e2db72c970730bccad9d145d8896c29226600..7eb603f89cccfca7615c0825e8002bc536dbb1b7 100644 (file)
--- a/server/include/muse_server_config.h
+++ b/server/include/muse_server_config.h
@@ -68,7 +68,6 @@ typedef struct host_info {
 } host_info_t;
 
 typedef struct ms_config {
-       char *hosts;
        char *host[MUSE_MODULE_MAX];
        int host_cnt;
        gboolean log_enabled;
@@ -88,12 +87,24 @@ typedef struct ms_config {
 
 void ms_config_init(ms_config_t *conf);
 void ms_config_deinit(ms_config_t *conf);
-char *ms_config_get_host(int idx);
+char *ms_config_get_host_name(int idx);
 int ms_config_get_host_cnt(void);
 int ms_config_get_gst_param_cnt(void);
 char *ms_config_get_gst_param_str(int idx);
 char *ms_config_get_path(int idx);
 char *ms_config_get_preloaded_value(int idx);
+char *ms_config_get_lockfile(void);
+gboolean ms_config_is_log_enabled(void);
+void ms_config_remove_lockfile(void);
+int ms_config_get_min_timeout(void);
+int ms_config_get_max_timeout(void);
+int ms_config_get_memory_threshold(void);
+gboolean ms_config_is_on_demand(void);
+int ms_config_get_max_idle_time(void);
+int ms_config_get_timeout(int module_idx);
+int ms_config_get_disable_watchdog_api(int module_idx);
+int ms_config_get_max_instance(int module_idx);
+int ms_config_get_caution_instance(int module_idx);
 
 #ifdef __cplusplus
 }

diff --git a/server/src/muse_server.c b/server/src/muse_server.c
index d51529c021b0f8bfef903a7213373b2f0f0946c2..ef9c11c325d200fe0d79dd056616ea5d364e764f 100644 (file)
--- a/server/src/muse_server.c
+++ b/server/src/muse_server.c
@@ -297,7 +297,9 @@ int muse_server_ipc_get_bufmgr(tbm_bufmgr *bufmgr)
 {
        LOGD("Enter");
 
+       muse_return_val_if_fail(ms_get_instance(), MM_ERROR_UNKNOWN);
        muse_return_val_if_fail(bufmgr, MM_ERROR_INVALID_ARGUMENT);
+
        if (!ms_get_instance()->bufmgr)
                muse_return_val_if_fail(ms_init_bufmgr(), MM_ERROR_INVALID_ARGUMENT);
 
@@ -419,6 +421,9 @@ int muse_server_ipc_set_fd(muse_module_h m, int fd)
 /* security */
 bool muse_server_security_check_cynara(int fd, const char *privilege)
 {
+       muse_return_val_if_fail(ms_get_instance(), false);
+       muse_return_val_if_fail(ms_get_instance()->security, false);
+
        return ms_security_is_privilege_granted(ms_get_instance()->security, fd, privilege);
 }
 
@@ -438,7 +443,11 @@ 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;
+       ms_connection_t *connection = NULL;
+
+       muse_return_val_if_fail(ms_get_instance(), MUSE_ERR);
+
+       connection = ms_get_instance()->connection;
        muse_return_val_if_fail(connection, MUSE_ERR);
 
        return connection->instance_count[idx];
@@ -483,6 +492,7 @@ int main(int argc, char **argv)
        trace_end();
 #endif
 
+       muse_return_val_if_fail(ms_get_instance(), 0);
        ms_get_instance()->pid = pid;
 
 #ifdef MUSE_TTRACE_LOG

diff --git a/server/src/muse_server_config.c b/server/src/muse_server_config.c
index 1de0d7ced2366da8dec32c1eac57f54b708a171d..0a99baaeddd411ecb64cdf46fc6c9122658adb5c 100644 (file)
--- a/server/src/muse_server_config.c
+++ b/server/src/muse_server_config.c
@@ -24,6 +24,7 @@
 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);
 static int _ms_config_parser(ms_config_t *conf);
+static ms_config_t *_ms_config_get_instance(void);
 
 static char *_ms_config_get_str(dictionary *d, const char *key, char *def)
 {
@@ -52,6 +53,7 @@ static int _ms_config_get_int(dictionary *d, const char *key, int def)
 static int _ms_config_parser(ms_config_t *conf)
 {
        int host_idx;
+       char *hosts = NULL;
        char *host = NULL;
        char *str = NULL;
        char *ptr = NULL;
@@ -63,8 +65,8 @@ static int _ms_config_parser(ms_config_t *conf)
        conf->muse_dict = iniparser_load(CONFFILE);
        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) {
+       hosts = _ms_config_get_str(conf->muse_dict, MUSE_HOST, NULL);
+       if (!hosts) {
                LOGE("Error - hosts allocation");
                goto out;
        }
@@ -115,7 +117,7 @@ static int _ms_config_parser(ms_config_t *conf)
        }
 
        conf->host_cnt = 0;
-       host = strtok_r(conf->hosts, INI_PARSER_COMMA, &ptr);
+       host = strtok_r(hosts, INI_PARSER_COMMA, &ptr);
 
        while (host) {
                host_idx = conf->host_cnt;
@@ -185,6 +187,13 @@ out:
        return PARSE_ERROR;
 }
 
+static ms_config_t *_ms_config_get_instance(void)
+{
+       muse_return_val_if_fail(ms_get_instance(), NULL);
+
+       return ms_get_instance()->conf;
+}
+
 void ms_config_init(ms_config_t *conf)
 {
        muse_return_if_fail(conf);
@@ -196,35 +205,16 @@ void ms_config_init(ms_config_t *conf)
 void ms_config_deinit(ms_config_t *conf)
 {
        int idx = 0;
-       char *host = NULL;
-       char *ptr = NULL;
 
        muse_return_if_fail(conf);
+       muse_return_if_fail(conf->host_infos);
 
-       if (conf->muse_dict)
-               iniparser_freedict(conf->muse_dict);
-
-       if (conf->hosts) {
-               host = strtok_r(conf->hosts, INI_PARSER_COMMA, &ptr);
-               conf->host_cnt = 0;
-
-               while (host) {
-                       LOGD("host: %s", host);
-                       MUSE_FREE(conf->host_infos[conf->host_cnt]->path);
-                       MUSE_FREE(conf->host_infos[conf->host_cnt]->preloaded);
-                       MUSE_FREE(conf->host_infos[conf->host_cnt]);
-                       host = strtok_r(NULL, INI_PARSER_COMMA, &ptr);
-                       conf->host_cnt++;
-               }
-
-               free(conf->hosts);
-               conf->hosts = NULL;
-       } else {
-               LOGE("NULL hosts");
-       }
-
-       for (idx = 0; idx <= conf->host_cnt; idx++)
+       for (idx = 0; idx <= conf->host_cnt; idx++) {
+               MUSE_FREE(conf->host_infos[conf->host_cnt]->path);
+               MUSE_FREE(conf->host_infos[conf->host_cnt]->preloaded);
+               MUSE_FREE(conf->host_infos[conf->host_cnt]);
                MUSE_FREE(conf->host[idx]);
+       }
 
        MUSE_FREE(conf->lockfile);
 
@@ -234,9 +224,9 @@ void ms_config_deinit(ms_config_t *conf)
        free(conf);
 }
 
-char *ms_config_get_host(int idx)
+char *ms_config_get_host_name(int idx)
 {
-       ms_config_t *conf = ms_get_instance()->conf;
+       ms_config_t *conf = _ms_config_get_instance();
 
        muse_return_val_if_fail(conf, NULL);
        muse_return_val_if_fail(conf->host, NULL);
@@ -246,7 +236,7 @@ char *ms_config_get_host(int idx)
 
 int ms_config_get_host_cnt(void)
 {
-       ms_config_t *conf = ms_get_instance()->conf;
+       ms_config_t *conf = _ms_config_get_instance();
 
        muse_return_val_if_fail(conf, MUSE_ERR);
        return conf->host_cnt;
@@ -254,7 +244,7 @@ int ms_config_get_host_cnt(void)
 
 int ms_config_get_gst_param_cnt(void)
 {
-       ms_config_t *conf = ms_get_instance()->conf;
+       ms_config_t *conf = _ms_config_get_instance();
 
        muse_return_val_if_fail(conf, MUSE_ERR);
 
@@ -263,7 +253,7 @@ int ms_config_get_gst_param_cnt(void)
 
 char *ms_config_get_gst_param_str(int idx)
 {
-       ms_config_t *conf = ms_get_instance()->conf;
+       ms_config_t *conf = _ms_config_get_instance();
 
        muse_return_val_if_fail(conf, NULL);
        muse_return_val_if_fail(conf->gst_param_str[idx], NULL);
@@ -273,7 +263,7 @@ char *ms_config_get_gst_param_str(int idx)
 char *ms_config_get_path(int idx)
 {
        char *path = NULL;
-       ms_config_t *conf = ms_get_instance()->conf;
+       ms_config_t *conf = _ms_config_get_instance();
 
        muse_return_val_if_fail(conf, NULL);
 
@@ -287,7 +277,7 @@ char *ms_config_get_path(int idx)
 char *ms_config_get_preloaded_value(int idx)
 {
        char *value = NULL;
-       ms_config_t *conf = ms_get_instance()->conf;
+       ms_config_t *conf = _ms_config_get_instance();
 
        muse_return_val_if_fail(conf, NULL);
 
@@ -297,3 +287,103 @@ char *ms_config_get_preloaded_value(int idx)
        return value;
 }
 
+char *ms_config_get_lockfile(void)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+
+       muse_return_val_if_fail(conf, NULL);
+
+       return conf->lockfile;
+}
+
+gboolean ms_config_is_log_enabled(void)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+
+       muse_return_val_if_fail(conf, FALSE);
+
+       return conf->log_enabled;
+}
+
+void ms_config_remove_lockfile(void)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+
+       muse_return_if_fail(conf);
+
+       if (remove(conf->lockfile) == MUSE_ERR)
+               LOGE("remove %s failed", conf->lockfile);
+}
+
+int ms_config_get_min_timeout(void)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+       muse_return_val_if_fail(conf, MUSE_ERR);
+
+       return conf->min_timeout;
+}
+
+int ms_config_get_max_timeout(void)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+       muse_return_val_if_fail(conf, MUSE_ERR);
+
+       return conf->max_timeout;
+}
+
+int ms_config_get_memory_threshold(void)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+       muse_return_val_if_fail(conf, MUSE_ERR);
+
+       return conf->memory_threshold;
+}
+
+gboolean ms_config_is_on_demand(void)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+       muse_return_val_if_fail(conf, FALSE);
+
+       return conf->is_on_demand;
+}
+
+int ms_config_get_max_idle_time(void)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+       muse_return_val_if_fail(conf, MUSE_ERR);
+
+       return conf->max_idle_time;
+}
+
+int ms_config_get_timeout(int module_idx)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+       muse_return_val_if_fail(conf, MUSE_ERR);
+
+       return conf->host_infos[module_idx]->timeout;
+}
+
+int ms_config_get_disable_watchdog_api(int module_idx)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+       muse_return_val_if_fail(conf, MUSE_ERR);
+
+       return conf->host_infos[module_idx]->disable_watchdog_api;
+}
+
+int ms_config_get_max_instance(int module_idx)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+       muse_return_val_if_fail(conf, MUSE_ERR);
+
+       return conf->host_infos[module_idx]->max_instance;
+}
+
+int ms_config_get_caution_instance(int module_idx)
+{
+       ms_config_t *conf = _ms_config_get_instance();
+       muse_return_val_if_fail(conf, MUSE_ERR);
+
+       return conf->host_infos[module_idx]->caution_instance;
+}
+

diff --git a/server/src/muse_server_connection.c b/server/src/muse_server_connection.c
index e850e4b7accf4188032cb4cead09aac37dac82db..cfb601c14afb47999f007b7a2a2a1d5ac1774759 100644 (file)
--- a/server/src/muse_server_connection.c
+++ b/server/src/muse_server_connection.c
@@ -36,12 +36,10 @@ static void _ms_connection_module_instance_info(muse_module_h m, ms_connection_t
        char pids[MUSE_MSG_LEN_MAX] = {'\0',};
        char pid[MUSE_PARAM_MAX] = {'\0',};
        int idx, len, caution_instance;
-       ms_config_t *conf = ms_get_instance()->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);
 
@@ -57,9 +55,9 @@ static void _ms_connection_module_instance_info(muse_module_h m, ms_connection_t
        }
 
        SECURE_LOGI("total number of module = %d ( %s) - %s %p from pid %d %s client (count %d)",
-               len, pids, connection_cmd[cmd], m, m->pid, conf->host[m->idx], connection->instance_count[m->idx]);
+               len, pids, connection_cmd[cmd], m, m->pid, ms_config_get_host_name(m->idx), connection->instance_count[m->idx]);
 
-       caution_instance = conf->host_infos[m->idx]->caution_instance;
+       caution_instance = ms_config_get_caution_instance(m->idx);
 
        if (caution_instance != DEFAULT_CAUTION_INSTANCE && connection->instance_count[m->idx] > caution_instance) {
                LOGI("[MUSE_MODULE_COMMAND_CREATE_CAUTION] player # %d | camera # %d | recorder # %d > %d",
@@ -75,10 +73,14 @@ int ms_connection_register(muse_module_h m)
        GQueue *queue;
        struct epoll_event event;
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
-       ms_connection_t *connection = ms_get_instance()->connection;
+       ms_connection_t *connection = NULL;
 
        LOGD("Enter");
 
+       muse_return_val_if_fail(ms_get_instance(), MM_ERROR_UNKNOWN);
+
+       connection = ms_get_instance()->connection;
+
        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);
@@ -114,13 +116,18 @@ int ms_connection_unregister(muse_module_h m)
 {
        int fd;
        GQueue *queue;
-       ms_connection_t *connection = ms_get_instance()->connection;
+       ms_connection_t *connection = NULL;
 
        LOGD("Enter");
 
+       muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(ms_get_instance(), MM_ERROR_UNKNOWN);
+       muse_return_val_if_fail(ms_get_instance()->state == MUSE_SERVER_STATE_READY, MM_ERROR_UNKNOWN);
+
+       connection = ms_get_instance()->connection;
+
        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);
 
@@ -145,7 +152,11 @@ gboolean ms_connection_get_state(ms_connection_state_e *state)
        int idx, fd, ep_fd, fd_count, errsv;
        struct epoll_event *p_event;
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
-       ms_connection_t *connection = ms_get_instance()->connection;
+       ms_connection_t *connection = NULL;
+
+       muse_return_val_if_fail(ms_get_instance(), MM_ERROR_UNKNOWN);
+
+       connection = ms_get_instance()->connection;
 
        muse_return_val_if_fail(connection, FALSE);
 
@@ -212,6 +223,7 @@ void ms_connection_deinit(ms_connection_t *connection)
        muse_return_if_fail(connection);
 
        g_queue_free(connection->instance_queue);
+       connection->instance_queue = NULL;
 
        g_mutex_clear(&connection->lock);
 

diff --git a/server/src/muse_server_ipc.c b/server/src/muse_server_ipc.c
index 6013dc79414e1e0be70997f7a92eeb1c451e1cd0..ec7401720347a49fde4fa311c9f64559ccf8c8d7 100644 (file)
--- a/server/src/muse_server_ipc.c
+++ b/server/src/muse_server_ipc.c
@@ -66,7 +66,7 @@ static gboolean _ms_ipc_module_instance_creation_is_allowed(int module_idx)
 
        muse_return_val_if_fail(ms_check_module_idx(module_idx), FALSE);
 
-       max_instance = ms_get_instance()->conf->host_infos[module_idx]->max_instance;
+       max_instance = ms_config_get_max_instance(module_idx);
        created_module_instance_count = muse_server_get_module_instance_count(module_idx);
 
        if (max_instance == UNLIMITED_INSTANCE || created_module_instance_count < max_instance) {
@@ -104,7 +104,7 @@ static gpointer _ms_ipc_dispatch_worker(gpointer data)
                len = muse_core_msg_recv_fd(fd, m->recv_msg, MUSE_MSG_MAX_LENGTH, tbm_fd);
                if (len <= 0) {
                        strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
-                       LOGE("[%s] [%d] recv : %s (%d)", ms_config_get_host(m->idx), fd, err_msg, errno);
+                       LOGE("[%s] [%d] recv : %s (%d)", ms_config_get_host_name(m->idx), fd, err_msg, errno);
                        ms_cmd_dispatch(m, MUSE_MODULE_COMMAND_SHUTDOWN);
                        attempt_to_dispatch = FALSE;
                }
@@ -221,6 +221,8 @@ static gboolean _ms_ipc_data_processing(int fd, muse_recv_data_head_t *header, m
 {
        char *raw_data = NULL;
 
+       muse_return_val_if_fail(ms_get_instance(), FALSE);
+
        if (!(fd > 0 && header && ch)) {
                LOGE("invalid param %d %p %p", fd, header, ch);
                goto _PROCESSING_FAILED;
@@ -322,6 +324,8 @@ gboolean ms_ipc_job_function(ms_workqueue_job_t *job)
        GError *error = NULL;
 
        LOGD("Enter");
+
+       muse_return_val_if_fail(ms_get_instance(), FALSE);
        muse_return_val_if_fail(job, FALSE);
        muse_return_val_if_fail(ms_is_running(), FALSE);
 
@@ -351,6 +355,7 @@ gboolean ms_ipc_data_job_function(ms_workqueue_job_t *job)
 
        LOGD("Enter");
 
+       muse_return_val_if_fail(ms_get_instance(), FALSE);
        muse_return_val_if_fail(job, FALSE);
        muse_return_val_if_fail(ms_is_running(), FALSE);
 

diff --git a/server/src/muse_server_log.c b/server/src/muse_server_log.c
index 2c587d3673ac9e319e05999c4adc507399c31da5..1eba0985efbae5f161dceed6f2e1f882e74d9356 100644 (file)
--- a/server/src/muse_server_log.c
+++ b/server/src/muse_server_log.c
@@ -151,7 +151,7 @@ static void _ms_log_api_info(ms_log_t *log)
        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++) {
+       for (idx = 0; idx < ms_config_get_host_cnt(); idx++) {
                ms_module_get_dllsym_value(idx, DISPATCHER_PTR, &ptr);
                memset(&info, 0, sizeof(info));
                if (dladdr((const void *) ptr, &info) && info.dli_sname) {
@@ -320,6 +320,7 @@ void ms_log_save_addr_name(int pid, gpointer addr)
 {
        Dl_info info;
 
+       muse_return_if_fail(ms_get_instance());
        muse_return_if_fail(ms_is_log_enabled());
        muse_return_if_fail(addr);
 
@@ -333,8 +334,9 @@ void ms_log_save_addr_name(int pid, gpointer addr)
 
 void ms_log_debug_pid_info(int pid)
 {
-       ms_log_t *log;
+       ms_log_t *log = NULL;
 
+       muse_return_if_fail(ms_get_instance());
        muse_return_if_fail(ms_is_log_enabled());
 
        log = ms_get_instance()->log;
@@ -361,7 +363,11 @@ void ms_log_debug_pid_info(int pid)
 
 void ms_log_write(char *buf)
 {
-       ms_log_t *log = ms_get_instance()->log;
+       ms_log_t *log = NULL;
+
+       muse_return_if_fail(ms_get_instance());
+
+       log = ms_get_instance()->log;
 
        muse_return_if_fail(ms_is_log_enabled());
        muse_return_if_fail(log);

diff --git a/server/src/muse_server_module.c b/server/src/muse_server_module.c
index 7585f08ac6cc645ec5a8da17fbfbe987af362f2a..21689df928912b6306785bcef951fb3e72593d19 100644 (file)
--- a/server/src/muse_server_module.c
+++ b/server/src/muse_server_module.c
@@ -40,7 +40,7 @@ static gboolean _ms_module_dispatch_timeout_callback(gpointer data)
                api = m->api;
                timeout = ms_module_get_timeout(idx, api);
                snprintf(err_msg, sizeof(err_msg), "[DEADLOCK] %s (pid %d)'s dispatcher (%d) does not return value within (%d) second",
-                                       ms_get_instance()->conf->host[idx], m->pid, api, timeout);
+                                       ms_config_get_host_name(idx), m->pid, api, timeout);
 
                LOGE("%s", err_msg);
                if (ms_is_log_enabled())
@@ -56,9 +56,9 @@ static gboolean _ms_module_dispatch_timeout_callback(gpointer data)
 
 static gboolean _ms_module_enable_dispatch_timeout_callback(int cmd, muse_module_h m)
 {
-       muse_return_val_if_fail(m, TRUE);
+       muse_return_val_if_fail(m, FALSE);
 
-       if (cmd == ms_get_instance()->conf->host_infos[m->idx]->disable_watchdog_api)
+       if (cmd == ms_config_get_disable_watchdog_api(m->idx))
                return FALSE;
 
        return TRUE;
@@ -149,10 +149,10 @@ int ms_module_dispatch(muse_module_h m, int api)
                if (enable_dispatch_timeout_callback) {
                        rm_success = g_source_remove(id);
                        if (!rm_success)
-                               LOGE("[%s] [%d] Failed to remove %d", ms_get_instance()->conf->host[m->idx], api, id);
+                               LOGE("[%s] [%d] Failed to remove %d", ms_config_get_host_name(m->idx), api, id);
                }
        } else {
-               LOGE("[%s] [%d] error - dispatcher", ms_get_instance()->conf->host[m->idx], api);
+               LOGE("[%s] [%d] error - dispatcher", ms_config_get_host_name(m->idx), api);
                ret = MUSE_ERR;
        }
 
@@ -231,7 +231,7 @@ void ms_module_set_timeout(int idx, int api, int timeout)
        ms_module_t *module = ms_get_module_instance(idx);
 
        muse_return_if_fail(module);
-       muse_return_if_fail(timeout >= ms_get_instance()->conf->min_timeout && timeout <= ms_get_instance()->conf->max_timeout);
+       muse_return_if_fail(timeout >= ms_config_get_min_timeout() && timeout <= ms_config_get_max_timeout());
 
        g_mutex_lock(&module->lock);
 
@@ -272,7 +272,7 @@ void ms_module_init(ms_module_t *module)
        module->dllsym_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
        muse_return_if_fail(module->dllsym_table);
        for (disp_idx = 0; disp_idx < API_MAX; disp_idx++)
-               ms_module_set_timeout(module->idx, disp_idx, ms_get_instance()->conf->host_infos[module->idx]->timeout);
+               ms_module_set_timeout(module->idx, disp_idx, ms_config_get_timeout(module->idx));
 
        LOGD("Leave");
 }

diff --git a/server/src/muse_server_private.c b/server/src/muse_server_private.c
index 004bca7c132d327bf5cc9001548275d8da02cab6..4345bc951a6b18c3c6c00c3f074580c10c646ce8 100644 (file)
--- a/server/src/muse_server_private.c
+++ b/server/src/muse_server_private.c
@@ -70,15 +70,18 @@ static int _ms_run(void)
 {
        int fd, already_running;
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
+       char *lockfile = NULL;
 
        muse_return_val_if_fail(muse_server, MUSE_ERR);
-       muse_return_val_if_fail(muse_server->conf->lockfile, MM_ERROR_INVALID_ARGUMENT);
 
-       muse_core_remove_symlink((const char *)muse_server->conf->lockfile);
-       fd = open(muse_server->conf->lockfile, O_RDONLY);
+       lockfile = ms_config_get_lockfile();
+       muse_return_val_if_fail(lockfile, MUSE_ERR);
+
+       muse_core_remove_symlink((const char *)lockfile);
+       fd = open(lockfile, O_RDONLY);
        if (fd == -1 && errno != ENOENT) {
                /* Cannot open file even though file exists. */
-               snprintf(err_msg, sizeof(err_msg), "datserver: Cannot open lock file %s", muse_server->conf->lockfile);
+               snprintf(err_msg, sizeof(err_msg), "datserver: Cannot open lock file %s", lockfile);
                LOGE("open failed : %s", err_msg);
                return MUSE_ERR;
        } else if (fd != -1) {
@@ -91,14 +94,14 @@ static int _ms_run(void)
        }
 
        /* Lock file does not exist, or is not locked. Create a new lockfile and lock it. */
-       fd = open(muse_server->conf->lockfile, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+       fd = open(lockfile, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        if (fd == -1) {
                LOGE("dataserver: Cannot create lock file");
                return MUSE_ERR;
        }
 
        if (flock(fd, LOCK_EX | LOCK_NB) != 0) {
-               LOGE("Can't lock the lock file \"%s\". " "Is another instance running?", muse_server->conf->lockfile);
+               LOGE("Can't lock the lock file \"%s\". " "Is another instance running?", lockfile);
                close(fd);
                return MUSE_ERR;
        }
@@ -294,6 +297,7 @@ static gboolean _ms_connection_handler(GIOChannel *source, GIOCondition conditio
        LOGI("Enter");
 
        muse_return_val_if_fail(muse_server, FALSE);
+       muse_return_val_if_fail(muse_server->workqueue, FALSE);
 
        connection = muse_server->connection;
        muse_return_val_if_fail(connection, FALSE);
@@ -382,14 +386,14 @@ static gboolean _ms_connection_handler(GIOChannel *source, GIOCondition conditio
 
                        if (muse_core_fd_is_valid(m->ch[MUSE_CHANNEL_DATA].sock_fd)) {
                                SECURE_LOGE("[%d] %s pid %d %p you had better check if instance destroy completed properly",
-                                       client_sockfd, muse_server->conf->host[m->idx], pid, m);
+                                       client_sockfd, ms_config_get_host_name(m->idx), pid, m);
                                ms_connection_unlock(connection);
                                goto out;
                        }
 
                        m->ch[MUSE_CHANNEL_DATA].sock_fd = client_sockfd;
                        SECURE_LOGI("%s (pid %d) module : %p module addr from client : %p",
-                               muse_server->conf->host[m->idx], pid, m, (void *)module_addr);
+                               ms_config_get_host_name(m->idx), pid, m, (void *)module_addr);
                        break;
                }
 
@@ -397,7 +401,7 @@ static gboolean _ms_connection_handler(GIOChannel *source, GIOCondition conditio
                        m = candidate_m;
                        m->ch[MUSE_CHANNEL_DATA].sock_fd = client_sockfd;
                        SECURE_LOGW("[%d] %s pid %d %p restore module address at the only one null data channel",
-                               client_sockfd, muse_server->conf->host[m->idx], pid, m);
+                               client_sockfd, ms_config_get_host_name(m->idx), pid, m);
                }
 
                ms_connection_unlock(connection);
@@ -412,7 +416,10 @@ static gboolean _ms_connection_handler(GIOChannel *source, GIOCondition conditio
        job->job_function = job_functions[channel];
        job->user_data = m;
 
-       ms_workqueue_add_job(muse_server->workqueue, job);
+       if (muse_server->state == MUSE_SERVER_STATE_READY)
+               ms_workqueue_add_job(muse_server->workqueue, job);
+       else
+               free(job);
 
        _ms_unlock_state();
 
@@ -463,9 +470,7 @@ static void _ms_check_idle_state(void)
        instance_number = g_queue_get_length(muse_server->connection->instance_queue);
        timeout = (int)tv_r.tv_sec;
 
-       /* LOGI("instance # : %d [Idle time] %d sec", instance_number, timeout); */
-
-       if (instance_number == 0 && timeout >= muse_server->conf->max_idle_time) {
+       if (instance_number == 0 && timeout >= ms_config_get_max_idle_time()) {
                LOGE("Timeout exit !!! [Idle time] %d sec", timeout);
                exit(EXIT_SUCCESS);
        }
@@ -602,6 +607,14 @@ int ms_deinit(void)
        LOGD("Enter");
 
        muse_return_val_if_fail(muse_server, retval);
+       muse_return_val_if_fail(muse_server->conf, retval);
+       muse_return_val_if_fail(muse_server->connection, retval);
+       muse_return_val_if_fail(muse_server->log, retval);
+       muse_return_val_if_fail(muse_server->security, retval);
+       muse_return_val_if_fail(muse_server->watchdog, retval);
+       muse_return_val_if_fail(muse_server->workqueue, retval);
+
+       muse_server->state = MUSE_SERVER_STATE_IDLE;
 
 #ifdef MUSE_USE_WATCHDOG
        if (ms_watchdog_deinit(muse_server->watchdog) == MM_ERROR_NONE)
@@ -621,22 +634,35 @@ int ms_deinit(void)
        if (remove(MUSE_DEFAULT_PIDFILE) == MUSE_ERR)
                LOGE("remove %s falied", MUSE_DEFAULT_PIDFILE);
 
-       g_mutex_clear(&muse_server->state_lock);
-
        for (idx = 0; idx < muse_server->conf->host_cnt; idx++)
                ms_module_deinit(muse_server->module[idx]);
 
        ms_workqueue_deinit(muse_server->workqueue);
+       muse_server->workqueue = NULL;
+
        ms_security_deinit(muse_server->security);
+       muse_server->security = NULL;
+
        ms_system_deinit(muse_server->system);
+       muse_server->system = NULL;
+
        ms_log_deinit(muse_server->log);
+       muse_server->log = NULL;
+
        ms_config_deinit(muse_server->conf);
+       muse_server->conf = NULL;
+
        ms_connection_deinit(muse_server->connection);
+       muse_server->connection = NULL;
 
        muse_core_destroy_fd_table();
 
        ms_deinit_bufmgr();
+
+       g_mutex_clear(&muse_server->state_lock);
+
        free(muse_server);
+       muse_server = NULL;
 
        LOGD("Leave");
        return retval;
@@ -644,19 +670,15 @@ int ms_deinit(void)
 
 void ms_check_memory(int pid)
 {
-       int used_pss;
+       int used_pss, memory_threshold;
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
        ms_connection_t *connection = NULL;
-       ms_config_t *conf = NULL;
 
        muse_return_if_fail(muse_server);
 
        connection = muse_server->connection;
        muse_return_if_fail(connection);
 
-       conf = muse_server->conf;
-       muse_return_if_fail(conf);
-
        _ms_lock_state();
 
        ms_connection_lock(connection);
@@ -666,11 +688,12 @@ void ms_check_memory(int pid)
        LOGI("[%d] Proportional set size %d (KByte)", pid, used_pss);
 
        if (g_queue_is_empty(connection->instance_queue) && muse_server->state != MUSE_SERVER_STATE_IDLE) {
-               if (used_pss > conf->memory_threshold) {
+               memory_threshold = ms_config_get_memory_threshold();
+               if (used_pss > memory_threshold) {
                        muse_server->state = MUSE_SERVER_STATE_IDLE;
                        ms_log_process_info(pid);
 
-                       snprintf(err_msg, sizeof(err_msg), "[Memory Leak] %d > %d (KByte)", used_pss, conf->memory_threshold);
+                       snprintf(err_msg, sizeof(err_msg), "[Memory Leak] %d > %d (KByte)", used_pss, memory_threshold);
 
                        LOGE("%s", err_msg);
                        ms_connection_unlock(connection);
@@ -697,7 +720,7 @@ void ms_new(void)
        int i, j;
 
        for (i = 0; i < MUSE_CHANNEL_MAX; i++) {
-               if (ms_get_instance()->conf->is_on_demand == TRUE && i == MUSE_CHANNEL_MSG)
+               if (ms_config_is_on_demand() == TRUE && i == MUSE_CHANNEL_MSG)
                        fd[i] = SD_LISTEN_FDS_START;
                else
                        fd[i] = _ms_new(i);
@@ -882,13 +905,15 @@ void ms_log_user_group_info(void)
 
 gboolean ms_is_log_enabled(void)
 {
-       return muse_server->conf->log_enabled;
+       return ms_config_is_log_enabled();
 }
 
 gboolean ms_init_bufmgr(void)
 {
        LOGD("Enter");
 
+       muse_return_val_if_fail(muse_server, FALSE);
+
        muse_server->bufmgr = tbm_bufmgr_init(-1);
        if (!muse_server->bufmgr) {
                LOGE("Error - tbm_bufmgr_init");
@@ -905,6 +930,7 @@ void ms_deinit_bufmgr(void)
 {
        LOGD("Enter");
 
+       muse_return_if_fail(muse_server);
        muse_return_if_fail(muse_server->bufmgr);
 
        tbm_bufmgr_deinit(muse_server->bufmgr);
@@ -919,6 +945,7 @@ void ms_cmd_dispatch_foreach_func(gpointer data, gpointer user_data)
        muse_module_command_e cmd;
        muse_external_storage_info_t *storage;
 
+       muse_return_if_fail(muse_server);
        muse_return_if_fail(m);
        muse_return_if_fail(dispatch);
 
@@ -931,7 +958,7 @@ void ms_cmd_dispatch_foreach_func(gpointer data, gpointer user_data)
        }
 
        ms_cmd_dispatch(m, cmd);
-       SECURE_LOGI("[%s] %p (%s)", module_cmd[cmd], m, ms_get_instance()->conf->host[m->idx]);
+       SECURE_LOGI("[%s] %p (%s)", module_cmd[cmd], m, muse_server->conf->host[m->idx]);
 
        if (cmd == MUSE_MODULE_COMMAND_EXTERNAL_STORAGE_STATE_CHANGED)
                muse_server_set_user_data(m, NULL);
@@ -948,11 +975,14 @@ void ms_set_state(ms_state_e state)
 
 void ms_set_running(gboolean value)
 {
+       muse_return_if_fail(muse_server);
+
        g_atomic_int_set(&muse_server->running, value);
 }
 
 gboolean ms_is_running(void)
 {
-       return (gboolean)g_atomic_int_get(&ms_get_instance()->running);
+       muse_return_val_if_fail(muse_server, FALSE);
+       return (gboolean)g_atomic_int_get(&muse_server->running);
 }
 

diff --git a/server/src/muse_server_signal.c b/server/src/muse_server_signal.c
index 6007152ace15e8280c0f98ad67d9260d5445a740..d76ea54e275011ffd13a86f4f46ea9b2a6c7b1a6 100644 (file)
--- a/server/src/muse_server_signal.c
+++ b/server/src/muse_server_signal.c
@@ -155,8 +155,7 @@ static void _ms_signal_sigaction(int signo, siginfo_t *si, void *arg)
                LOGE("remove %s failed", MUSE_SERVER_READY);
 #endif
 
-       if (remove(ms_get_instance()->conf->lockfile) == MUSE_ERR)
-               LOGE("remove %s failed", ms_get_instance()->conf->lockfile);
+       ms_config_remove_lockfile();
 
        _ms_signal_debug_pid_info(si->si_pid);
        _ms_signal_backtrace(arg);

diff --git a/server/src/muse_server_system.c b/server/src/muse_server_system.c
index 4d952023d97f983853be1808c54485f5479581d6..d9129410705efcd22c96ae64fffbb3887d12643c 100644 (file)
--- a/server/src/muse_server_system.c
+++ b/server/src/muse_server_system.c
@@ -74,7 +74,11 @@ static int _ms_system_subscribe_poweroff_state_change(ms_system_t *system)
 
 static void _ms_system_unsubscribe_poweroff_state_change(void)
 {
-       ms_system_t *system = ms_get_instance()->system;
+       ms_system_t *system = NULL;
+
+       muse_return_if_fail(ms_get_instance());
+
+       system = ms_get_instance()->system;
        muse_return_if_fail(system);
        muse_return_if_fail(system->connection);
 
@@ -87,17 +91,22 @@ static void _ms_poweroff_state_changed_cb(GDBusConnection *con, const gchar *sen
        int val_int = 0;
        GQueue *queue;
        ms_cmd_dispatcher_info_t dispatch;
-       ms_system_t *system = ms_get_instance()->system;
-       ms_connection_t *connection = ms_get_instance()->connection;
+       ms_system_t *system = NULL;
+       ms_connection_t *connection = NULL;
 
        LOGE("received power off signal");
 
-       muse_return_if_fail(system);
-       muse_return_if_fail(connection);
+       muse_return_if_fail(ms_get_instance());
        muse_return_if_fail(object_path);
        muse_return_if_fail(signal_name);
        muse_return_if_fail(parameters);
 
+       system = ms_get_instance()->system;
+       muse_return_if_fail(system);
+
+       connection = ms_get_instance()->connection;
+       muse_return_if_fail(connection);
+
        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);
                return;
@@ -160,9 +169,12 @@ static void _ms_external_storage_state_changed_cb(int storage_id, storage_dev_e
        GQueue *queue;
        ms_cmd_dispatcher_info_t dispatch;
        ms_system_t *system = (ms_system_t *)user_data;
-       ms_connection_t *connection = ms_get_instance()->connection;
+       ms_connection_t *connection = NULL;
 
        muse_return_if_fail(system);
+       muse_return_if_fail(ms_get_instance());
+
+       connection = ms_get_instance()->connection;
        muse_return_if_fail(connection);
 
        switch (state) {
@@ -221,7 +233,12 @@ static int _ms_system_subscribe_resource_manager_state_change(ms_system_t *syste
 
 static void _ms_system_unsubscribe_resource_manager_state_change(void)
 {
-       ms_system_t *system = ms_get_instance()->system;
+       ms_system_t *system = NULL;
+
+       muse_return_if_fail(ms_get_instance());
+
+       system = ms_get_instance()->system;
+
        muse_return_if_fail(system);
        muse_return_if_fail(system->connection);
 
@@ -233,18 +250,23 @@ static void _ms_resource_manager_owner_name_changed_cb(GDBusConnection *con, con
 {
        GQueue *queue;
        ms_cmd_dispatcher_info_t dispatch;
-       ms_system_t *system = ms_get_instance()->system;
-       ms_connection_t *connection = ms_get_instance()->connection;
+       ms_system_t *system = NULL;
+       ms_connection_t *connection = NULL;
        gchar *owner_name = NULL;
        gchar *old_owner = NULL;
        gchar *new_owner = NULL;
 
-       muse_return_if_fail(system);
-       muse_return_if_fail(connection);
+       muse_return_if_fail(ms_get_instance());
        muse_return_if_fail(object_path);
        muse_return_if_fail(signal_name);
        muse_return_if_fail(parameters);
 
+       system = ms_get_instance()->system;
+       muse_return_if_fail(system);
+
+       connection = ms_get_instance()->connection;
+       muse_return_if_fail(connection);
+
        if (g_strcmp0(object_path, MS_DBUS_PATH) || g_strcmp0(signal_name, MS_RM_DBUS_MSG))
                return;
 
@@ -324,7 +346,11 @@ int ms_system_get_platform_info(const char *key, bool *value)
 {
        int ret = MM_ERROR_NONE;
        gpointer orig_value;
-       ms_system_t *system = ms_get_instance()->system;
+       ms_system_t *system = NULL;
+
+       muse_return_val_if_fail(ms_get_instance(), MM_ERROR_UNKNOWN);
+
+       system = ms_get_instance()->system;
 
        muse_return_val_if_fail(system, MM_ERROR_INVALID_ARGUMENT);
        muse_return_val_if_fail(key, MM_ERROR_INVALID_ARGUMENT);
@@ -408,7 +434,9 @@ gboolean ms_system_get_gdbus(GDBusConnection **connection)
 {
        LOGD("Enter");
 
-       ms_system_t *system;
+       ms_system_t *system = NULL;
+
+       muse_return_val_if_fail(ms_get_instance(), FALSE);
 
        system = ms_get_instance()->system;
        muse_return_val_if_fail(system, FALSE);