Modify for readability

Change-Id: Ib3a4e363eaa8e1e2ba57e95e58c9eaf2335a029b
Signed-off-by: Minje Ahn <minje.ahn@samsung.com>

diff --git a/lib/media-util-dcm.c b/lib/media-util-dcm.c
index 18e368d..8ba937f 100755 (executable)
--- a/lib/media-util-dcm.c
+++ b/lib/media-util-dcm.c
@@ -149,12 +149,12 @@ gboolean __media_dcm_write_socket(GIOChannel *src, GIOCondition condition, gpoin
                else
                        MSAPI_DBG_ERR("origin path size is wrong.");
 
-               return FALSE;
+               return G_SOURCE_REMOVE;
        }
 
        if (strlen(recv_msg.msg) == 0 || strlen(recv_msg.msg) >= MAX_FILEPATH_LEN) {
                MSAPI_DBG_ERR("msg size is invlid");
-               return FALSE;
+               return G_SOURCE_REMOVE;
        }
 
        MSAPI_DBG("Completed. msg_type[%d], msg[%.*s], result[%d]", recv_msg.msg_type, MAX_FILEPATH_LEN, recv_msg.msg, recv_msg.result);
@@ -177,7 +177,7 @@ gboolean __media_dcm_write_socket(GIOChannel *src, GIOCondition condition, gpoin
 
        MSAPI_DBG("Done");
 
-       return FALSE;
+       return G_SOURCE_REMOVE;
 }
 
 static int __media_dcm_send_request()

diff --git a/lib/media-util-register.c b/lib/media-util-register.c
index 8d0bf4f..5b607dd 100755 (executable)
--- a/lib/media-util-register.c
+++ b/lib/media-util-register.c
@@ -81,7 +81,7 @@ gboolean _read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
        sockfd = g_io_channel_unix_get_fd(src);
        if (sockfd < 0) {
                MSAPI_DBG("sock fd is invalid!");
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        memset(&recv_msg, 0x0, sizeof(ms_comm_msg_s));
@@ -89,14 +89,14 @@ gboolean _read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
 
        if ((recv_msg_size = read(sockfd, &recv_msg, sizeof(ms_comm_msg_s))) < 0) {
                MSAPI_DBG_STRERROR("recv failed");
-               return FALSE;
+               return G_SOURCE_REMOVE;
        }
        if (strlen(recv_msg.msg) > 0 && strlen(recv_msg.msg) < MAX_MSG_SIZE) {
                req_result.complete_path = g_strdup(recv_msg.msg);
                MSAPI_DBG("complete_path :%s", req_result.complete_path);
        } else {
                MSAPI_DBG("The message is invalid!");
-               return FALSE;
+               return G_SOURCE_REMOVE;
        }
 
        req_result.pid = recv_msg.pid;
@@ -121,7 +121,7 @@ gboolean _read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
        default:
                MSAPI_DBG("Invalid msg_type[%d]", recv_msg.msg_type);
                MS_SAFE_FREE(req_result.complete_path);
-               return FALSE;
+               return G_SOURCE_REMOVE;
        }
 
        MSAPI_DBG("pid[%d] result[%d] request_type[%d]", req_result.pid, req_result.result, req_result.request_type);
@@ -180,7 +180,7 @@ gboolean _read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
 
        MS_SAFE_FREE(req_result.complete_path);
 
-       return TRUE;
+       return G_SOURCE_CONTINUE;
 }
 
 static int _add_request(const char * req_path, media_callback_data *cb_data, GIOChannel *channel, guint source_id)

diff --git a/src/scanner/media-scanner-socket.c b/src/scanner/media-scanner-socket.c
index d2b027d..f085b14 100755 (executable)
--- a/src/scanner/media-scanner-socket.c
+++ b/src/scanner/media-scanner-socket.c
@@ -40,29 +40,29 @@ gboolean msc_receive_request(GIOChannel *src, GIOCondition condition, gpointer d
        int err = -1;
 
        sockfd = g_io_channel_unix_get_fd(src);
-       MS_DBG_RETVM_IF(sockfd < 0, TRUE, "sock fd is invalid!");
+       MS_DBG_RETVM_IF(sockfd < 0, G_SOURCE_CONTINUE, "sock fd is invalid!");
 
        MS_MALLOC(recv_msg, sizeof(ms_comm_msg_s));
-       MS_DBG_RETVM_IF(!recv_msg, TRUE, "MS_MALLOC failed");
+       MS_DBG_RETVM_IF(!recv_msg, G_SOURCE_CONTINUE, "MS_MALLOC failed");
 
        /* read() is blocked until media scanner sends message */
        err = read(sockfd, recv_msg, sizeof(ms_comm_msg_s));
        if (err < 0) {
                MS_DBG_STRERROR("fifo read failed");
                MS_SAFE_FREE(recv_msg);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        if (strlen(recv_msg->msg) == 0 || strlen(recv_msg->msg) >= MAX_MSG_SIZE) {
                MS_DBG_ERR("msg size is invlid");
                MS_SAFE_FREE(recv_msg);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        if (strlen(recv_msg->storage_id) >= MS_UUID_SIZE) {
                MS_DBG_ERR("storage_id size is invlid");
                MS_SAFE_FREE(recv_msg);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        MS_DBG_SLOG("receive msg from [%d][%d] M[%.*s] S[%.*s]", recv_msg->pid, recv_msg->msg_type, MAX_MSG_SIZE, recv_msg->msg, MS_UUID_SIZE, recv_msg->storage_id);
@@ -96,7 +96,7 @@ gboolean msc_receive_request(GIOChannel *src, GIOCondition condition, gpointer d
        /*Active flush */
        malloc_trim(0);
 
-       return TRUE;
+       return G_SOURCE_CONTINUE;
 }
 
 int msc_send_ready(void)

diff --git a/src/server/include/media-server-db.h b/src/server/include/media-server-db.h
index ae50655..b859468 100755 (executable)
--- a/src/server/include/media-server-db.h
+++ b/src/server/include/media-server-db.h
@@ -26,6 +26,6 @@
 
 GMainLoop *ms_db_get_mainloop(void);
 gboolean ms_db_get_thread_status(void);
-gboolean ms_db_thread(void *data);
+gpointer ms_db_thread(gpointer data);
 
 #endif/* _MEDIA_SERVER_DB_H_ */

diff --git a/src/server/media-server-db.c b/src/server/media-server-db.c
index 3ea924c..6127188 100755 (executable)
--- a/src/server/media-server-db.c
+++ b/src/server/media-server-db.c
@@ -41,7 +41,7 @@ gboolean ms_db_get_thread_status(void)
        return db_thread_ready;
 }
 
-gboolean ms_db_thread(void *data)
+gpointer ms_db_thread(gpointer data)
 {
        int sockfd = -1;
        int ret = MS_MEDIA_ERR_NONE;
@@ -52,15 +52,12 @@ gboolean ms_db_thread(void *data)
 
        /* Create TCP Socket*/
        ret = ms_ipc_create_server_socket(MS_DB_UPDATE_PORT, &sockfd);
-       if (ret != MS_MEDIA_ERR_NONE) {
-               MS_DBG_ERR("Failed to create socket");
-               return FALSE;
-       }
+       MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, NULL, "Failed to create socket");
 
        if (ms_cynara_enable_credentials_passing(sockfd) != MS_MEDIA_ERR_NONE) {
                close(sockfd);
                MS_DBG_ERR("Failed to set up credentials passing");
-               return FALSE;
+               return NULL;
        }
 
        context = g_main_context_new();
@@ -93,5 +90,5 @@ gboolean ms_db_thread(void *data)
 
        g_main_loop_unref(g_db_mainloop);
 
-       return FALSE;
+       return NULL;
 }

diff --git a/src/server/media-server-dcm.c b/src/server/media-server-dcm.c
index d2e68ab..429c7bb 100755 (executable)
--- a/src/server/media-server-dcm.c
+++ b/src/server/media-server-dcm.c
@@ -397,14 +397,14 @@ gboolean _ms_dcm_agent_read_socket(GIOChannel *src, GIOCondition condition, gpoi
        sock = g_io_channel_unix_get_fd(src);
        if (sock < 0) {
                MS_DBG_ERR("sock fd is invalid!");
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        client_addr_len = sizeof(client_addr);
 
        if ((client_sock = accept(sock, (struct sockaddr*)&client_addr, &client_addr_len)) < 0) {
                MS_DBG_STRERROR("accept failed");
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        MS_DBG("Client[%d] is accepted", client_sock);
@@ -413,14 +413,14 @@ gboolean _ms_dcm_agent_read_socket(GIOChannel *src, GIOCondition condition, gpoi
        if (recv_msg == NULL) {
                MS_DBG_ERR("Failed to allocate memory");
                close(client_sock);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        if (__ms_dcm_recv_msg(client_sock, recv_msg) < 0) {
                MS_DBG_ERR("__ms_dcm_recv_msg failed ");
                close(client_sock);
                MS_SAFE_FREE(recv_msg);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        dcmRequest *dcm_req = NULL;
@@ -430,7 +430,7 @@ gboolean _ms_dcm_agent_read_socket(GIOChannel *src, GIOCondition condition, gpoi
                MS_DBG_ERR("Failed to create request element");
                close(client_sock);
                MS_SAFE_FREE(recv_msg);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        dcm_req->client_sock = client_sock;
@@ -459,7 +459,7 @@ gboolean _ms_dcm_agent_read_socket(GIOChannel *src, GIOCondition condition, gpoi
                MS_SAFE_FREE(dcm_req->recv_msg);
                MS_SAFE_FREE(dcm_req);
 
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        MS_DBG_SLOG("[%.*s] is queued", MAX_FILEPATH_LEN, recv_msg->msg);
@@ -473,7 +473,7 @@ gboolean _ms_dcm_agent_read_socket(GIOChannel *src, GIOCondition condition, gpoi
                g_dcm_queue_work = 1;
        }
 
-       return TRUE;
+       return G_SOURCE_CONTINUE;
 }
 
 gboolean _ms_dcm_agent_prepare_tcp_socket(int *sock_fd, unsigned short serv_port)

diff --git a/src/server/media-server-main.c b/src/server/media-server-main.c
index 077c0ed..81b8567 100755 (executable)
--- a/src/server/media-server-main.c
+++ b/src/server/media-server-main.c
@@ -442,10 +442,10 @@ int main(int argc, char **argv)
        __ms_add_signal_handler();
 
        /*create each threads*/
-       db_thread = g_thread_new("db_thread", (GThreadFunc)ms_db_thread, NULL);
-       thumb_thread = g_thread_new("thumb_agent_thread", (GThreadFunc)ms_thumb_agent_start_thread, NULL);
+       db_thread = g_thread_new("db_thread", ms_db_thread, NULL);
+       thumb_thread = g_thread_new("thumb_agent_thread", ms_thumb_agent_start_thread, NULL);
        if (is_dcm_supported)
-               dcm_thread = g_thread_new("dcm_agent_thread", (GThreadFunc)ms_dcm_agent_start_thread, NULL);
+               dcm_thread = g_thread_new("dcm_agent_thread", ms_dcm_agent_start_thread, NULL);
 
        /*clear previous data of sdcard on media database and check db status for updating*/
        while (!ms_db_get_thread_status()) {

diff --git a/src/server/media-server-scanner.c b/src/server/media-server-scanner.c
index 22b6a25..2d652e2 100755 (executable)
--- a/src/server/media-server-scanner.c
+++ b/src/server/media-server-scanner.c
@@ -89,13 +89,13 @@ static gboolean _ms_stop_scanner(gpointer user_data)
        if (task_num > 0) {
                MS_DBG("[%d] task(s) remains", task_num);
                g_mutex_unlock(&scanner_mutex);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        if (ms_check_scanning_status() == MS_DB_UPDATING) {
                MS_DBG("DB is updating");
                g_mutex_unlock(&scanner_mutex);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        } else {
                MS_DBG("DB updating is not working");
        }
@@ -103,7 +103,7 @@ static gboolean _ms_stop_scanner(gpointer user_data)
        if (ms_req_num > 0) {
                MS_DBG("[%d] request(s) remain(s)", ms_req_num);
                g_mutex_unlock(&scanner_mutex);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        } else {
                MS_DBG("DB updating is not working");
        }
@@ -141,7 +141,7 @@ static gboolean _ms_stop_scanner(gpointer user_data)
        MS_DBG_WARN("stop_scanner unlock...");
        g_mutex_unlock(&scanner_mutex);
 
-       return FALSE;
+       return G_SOURCE_REMOVE;
 }
 
 static int _ms_get_ini_config(const char *key)

diff --git a/src/server/media-server-socket.c b/src/server/media-server-socket.c
index 5dd918e..8c9c9ee 100755 (executable)
--- a/src/server/media-server-socket.c
+++ b/src/server/media-server-socket.c
@@ -209,11 +209,11 @@ gboolean ms_read_socket(GIOChannel *src, GIOCondition condition, gpointer user_d
        ms_peer_credentials creds;
 
        sockfd = g_io_channel_unix_get_fd(src);
-       MS_DBG_RETVM_IF(sockfd < 0, TRUE, "sock fd is invalid!");
+       MS_DBG_RETVM_IF(sockfd < 0, G_SOURCE_CONTINUE, "sock fd is invalid!");
 
        /* get client socket fd */
        ret = ms_ipc_accept_client_tcp(sockfd, &client_sock);
-       MS_DBG_RETV_IF(ret != MS_MEDIA_ERR_NONE, TRUE);
+       MS_DBG_RETV_IF(ret != MS_MEDIA_ERR_NONE, G_SOURCE_CONTINUE);
 
        memset(&creds, 0, sizeof(creds));
 
@@ -260,7 +260,7 @@ gboolean ms_read_socket(GIOChannel *src, GIOCondition condition, gpointer user_d
        /*Active flush */
        malloc_trim(0);
 
-       return TRUE;
+       return G_SOURCE_CONTINUE;
 ERROR:
        memset(&res_msg, 0x0, sizeof(ms_comm_msg_s));
 
@@ -284,7 +284,7 @@ ERROR:
        ms_ipc_send_msg_to_client_tcp(client_sock, &res_msg, NULL);
        close(client_sock);
 
-       return TRUE;
+       return G_SOURCE_CONTINUE;
 }
 
 static int __ms_send_request(ms_comm_msg_s *send_msg)
@@ -444,14 +444,14 @@ gboolean ms_read_db_tcp_socket(GIOChannel *src, GIOCondition condition, gpointer
        sqlite3 *db_handle = (sqlite3 *)data;
        ms_peer_credentials creds;
 
-       MS_DBG_RETVM_IF(power_off, TRUE, "POWER OFF");
+       MS_DBG_RETVM_IF(power_off, G_SOURCE_CONTINUE, "POWER OFF");
 
        sock = g_io_channel_unix_get_fd(src);
-       MS_DBG_RETVM_IF(sock < 0, TRUE, "sock fd is invalid!");
+       MS_DBG_RETVM_IF(sock < 0, G_SOURCE_CONTINUE, "sock fd is invalid!");
 
        /* get client socket fd */
        ret = ms_ipc_accept_client_tcp(sock, &client_sock);
-       MS_DBG_RETV_IF(ret != MS_MEDIA_ERR_NONE, TRUE);
+       MS_DBG_RETV_IF(ret != MS_MEDIA_ERR_NONE, G_SOURCE_CONTINUE);
 
        memset(&creds, 0, sizeof(creds));
 
@@ -494,7 +494,7 @@ ERROR:
        if (close(client_sock) < 0)
                MS_DBG_STRERROR("close failed");
 
-       return TRUE;
+       return G_SOURCE_CONTINUE;
 }
 
 gboolean ms_receive_message_from_scanner(GIOChannel *src, GIOCondition condition, gpointer data)
@@ -504,18 +504,18 @@ gboolean ms_receive_message_from_scanner(GIOChannel *src, GIOCondition condition
        int err;
 
        fd = g_io_channel_unix_get_fd(src);
-       MS_DBG_RETVM_IF(fd < 0, TRUE, "fd is invalid!");
+       MS_DBG_RETVM_IF(fd < 0, G_SOURCE_CONTINUE, "fd is invalid!");
 
        /* read() is blocked until media scanner sends message */
        err = read(fd, &recv_msg, sizeof(recv_msg));
        if (err < 0) {
                MS_DBG_STRERROR("fifo read failed");
                close(fd);
-               return FALSE;
+               return G_SOURCE_REMOVE;
        }
 
-       MS_DBG_RETVM_IF(strlen(recv_msg.msg) == 0 || strlen(recv_msg.msg) >= MAX_MSG_SIZE, TRUE, "msg size is invalid!");
-       MS_DBG_RETVM_IF(strlen(recv_msg.storage_id) >= MS_UUID_SIZE, TRUE, "storage_id size is invlid");
+       MS_DBG_RETVM_IF(strlen(recv_msg.msg) == 0 || strlen(recv_msg.msg) >= MAX_MSG_SIZE, G_SOURCE_CONTINUE, "msg size is invalid!");
+       MS_DBG_RETVM_IF(strlen(recv_msg.storage_id) >= MS_UUID_SIZE, G_SOURCE_CONTINUE, "storage_id size is invlid");
 
        MS_DBG_SLOG("receive result from scanner [%d][%d] M[%.*s] S[%.*s]", recv_msg.pid, recv_msg.result, MAX_MSG_SIZE, recv_msg.msg, MS_UUID_SIZE, recv_msg.storage_id);
 
@@ -534,13 +534,13 @@ gboolean ms_receive_message_from_scanner(GIOChannel *src, GIOCondition condition
                break;
        default:
                MS_DBG_ERR("Wrong MSG [%d]", recv_msg.msg_type);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        if (recv_msg.pid != 0)
                __ms_send_result_to_client(recv_msg.pid, &recv_msg);
 
-       return TRUE;
+       return G_SOURCE_CONTINUE;
 }
 
 void ms_remove_request_owner(int pid, const char *req_path)

diff --git a/src/server/media-server-thumb.c b/src/server/media-server-thumb.c
index 5f10f60..71bb87c 100755 (executable)
--- a/src/server/media-server-thumb.c
+++ b/src/server/media-server-thumb.c
@@ -494,9 +494,7 @@ gboolean _ms_thumb_request_to_server(gpointer data)
        return TRUE;
 }
 
-gboolean _ms_thumb_agent_read_socket(GIOChannel *src,
-                                                                       GIOCondition condition,
-                                                                       gpointer data)
+gboolean _ms_thumb_agent_read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
 {
        struct sockaddr_un client_addr;
        unsigned int client_addr_len;
@@ -508,14 +506,14 @@ gboolean _ms_thumb_agent_read_socket(GIOChannel *src,
        sock = g_io_channel_unix_get_fd(src);
        if (sock < 0) {
                MS_DBG_ERR("sock fd is invalid!");
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        client_addr_len = sizeof(client_addr);
 
        if ((client_sock = accept(sock, (struct sockaddr*)&client_addr, &client_addr_len)) < 0) {
                MS_DBG_STRERROR("accept failed");
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        MS_DBG("Client[%d] is accepted", client_sock);
@@ -524,14 +522,14 @@ gboolean _ms_thumb_agent_read_socket(GIOChannel *src,
        if (recv_msg == NULL) {
                MS_DBG_ERR("Failed to allocate memory");
                close(client_sock);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        if (_ms_thumb_recv_msg(client_sock, recv_msg) < 0) {
                MS_DBG_ERR("_ms_thumb_recv_msg failed ");
                close(client_sock);
                MS_SAFE_FREE(recv_msg);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        thumbRequest *thumb_req = NULL;
@@ -542,7 +540,7 @@ gboolean _ms_thumb_agent_read_socket(GIOChannel *src,
                close(client_sock);
                MS_SAFE_FREE(recv_msg->thumb_data);
                MS_SAFE_FREE(recv_msg);
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        thumb_req->client_sock = client_sock;
@@ -577,7 +575,7 @@ gboolean _ms_thumb_agent_read_socket(GIOChannel *src,
                MS_SAFE_FREE(thumb_req->recv_msg);
                MS_SAFE_FREE(thumb_req);
 
-               return TRUE;
+               return G_SOURCE_CONTINUE;
        }
 
        MS_DBG_SLOG("%s is queued", recv_msg->org_path);
@@ -591,7 +589,7 @@ gboolean _ms_thumb_agent_read_socket(GIOChannel *src,
                g_queue_work = 1;
        }
 
-       return TRUE;
+       return G_SOURCE_CONTINUE;
 }
 
 gboolean _ms_thumb_agent_prepare_tcp_socket(int *sock_fd, unsigned short serv_port)