Use connected socket to communicate with CAPI

Add credential option to get user UID from CAPI

Bug-Tizen: TC-1598

Change-Id: Id94e50986af8ce1635422df7b23e0eeb18de18ab
Signed-off-by: Jean-Benoit MARTIN <jean-benoit.martin@open.eurogiciel.org>

diff --git a/lib/include/media-util-ipc.h b/lib/include/media-util-ipc.h
index d858ede..11ed155 100755 (executable)
--- a/lib/include/media-util-ipc.h
+++ b/lib/include/media-util-ipc.h
@@ -71,8 +71,8 @@ int ms_ipc_create_server_socket(ms_protocol_e protocol, int port, int *sock_fd);
 #ifdef _USE_UDS_SOCKET_
 int ms_ipc_send_msg_to_server(int sockfd, int port, ms_comm_msg_s *send_msg, struct sockaddr_un *serv_addr);
 int ms_ipc_send_msg_to_client(int sockfd, ms_comm_msg_s *send_msg, struct sockaddr_un *client_addr);
-int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *client_addr, unsigned int *size);
-int ms_ipc_wait_message(int sockfd, void  *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *size);
+int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *client_addr, unsigned int *size, int *recv_socket);
+int ms_ipc_wait_message(int sockfd, void  *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *size, int connected);
 #else
 int ms_ipc_send_msg_to_server(int sockfd, int port, ms_comm_msg_s *send_msg, struct sockaddr_in *serv_addr);
 int ms_ipc_send_msg_to_client(int sockfd, ms_comm_msg_s *send_msg, struct sockaddr_in *client_addr);

diff --git a/lib/media-util-db.c b/lib/media-util-db.c
index e50ad2e..509e442 100755 (executable)
--- a/lib/media-util-db.c
+++ b/lib/media-util-db.c
@@ -392,7 +392,7 @@ static int __media_db_request_update(ms_msg_type_e msg_type, const char *request
 
        /*Create Socket*/
 #ifdef _USE_UDS_SOCKET_
-       ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, MS_TIMEOUT_SEC_10, &sockfd, port);
+       ret = ms_ipc_create_client_socket(MS_PROTOCOL_TCP, MS_TIMEOUT_SEC_10, &sockfd, port);
 #else
        ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, MS_TIMEOUT_SEC_10, &sockfd);
 #endif
@@ -411,7 +411,8 @@ static int __media_db_request_update(ms_msg_type_e msg_type, const char *request
        serv_addr_len = sizeof(serv_addr);
        memset(&recv_msg, 0x0, sizeof(ms_comm_msg_s));
 
-       err = ms_ipc_wait_message(sockfd, &recv_msg, sizeof(recv_msg), &serv_addr, NULL);
+       /* connected socket*/
+       err = ms_ipc_wait_message(sockfd, &recv_msg, sizeof(recv_msg), &serv_addr, NULL,TRUE);
        if (err != MS_MEDIA_ERR_NONE) {
                ret = err;
        } else {

diff --git a/lib/media-util-ipc.c b/lib/media-util-ipc.c
index 0c3374d..adab3a9 100755 (executable)
--- a/lib/media-util-ipc.c
+++ b/lib/media-util-ipc.c
@@ -115,7 +115,6 @@ int ms_ipc_create_client_socket(ms_protocol_e protocol, int timeout_sec, int *so
        int cx,len;
 
 #ifdef _USE_UDS_SOCKET_
-       mode_t orig_mode;
 
        if (tzplatform_getuid(TZ_USER_NAME) == 0 ){
                cx = snprintf ( NULL, 0, MEDIA_IPC_PATH_CLIENT_ROOT[port],getpid());
@@ -131,7 +130,6 @@ int ms_ipc_create_client_socket(ms_protocol_e protocol, int timeout_sec, int *so
                buffer = (char*)malloc((cx + 1 )*sizeof(char));
                snprintf ( buffer, cx + 1,  MEDIA_IPC_PATH_CLIENT[port],tzplatform_getuid(TZ_USER_NAME),getpid());
        }
-       orig_mode = umask(0111);
 #endif
                
        if(protocol == MS_PROTOCOL_UDP)
@@ -163,7 +161,6 @@ int ms_ipc_create_client_socket(ms_protocol_e protocol, int timeout_sec, int *so
                        close(sock);
 #ifdef _USE_UDS_SOCKET_
                        free(buffer);
-                       umask(orig_mode);
 #endif
                        return MS_MEDIA_ERR_SOCKET_CONN;
                }
@@ -180,7 +177,6 @@ int ms_ipc_create_client_socket(ms_protocol_e protocol, int timeout_sec, int *so
                        MSAPI_DBG_ERR("socket failed: %s", strerror(errno));
 #ifdef _USE_UDS_SOCKET_
                        free(buffer);
-                       umask(orig_mode);
 #endif
                        return MS_MEDIA_ERR_SOCKET_CONN;
                }
@@ -192,7 +188,6 @@ int ms_ipc_create_client_socket(ms_protocol_e protocol, int timeout_sec, int *so
                        close(sock);
 #ifdef _USE_UDS_SOCKET_
                        free(buffer);
-                       umask(orig_mode);
 #endif
                        return MS_MEDIA_ERR_SOCKET_CONN;
                }
@@ -201,7 +196,6 @@ int ms_ipc_create_client_socket(ms_protocol_e protocol, int timeout_sec, int *so
        *sock_fd = sock;
 #ifdef _USE_UDS_SOCKET_
        free(buffer);
-       umask(orig_mode);
 #endif
 
        return MS_MEDIA_ERR_NONE;
@@ -241,7 +235,6 @@ int ms_ipc_create_server_tcp_socket(ms_protocol_e protocol, int port, int *sock_
 
        struct sockaddr_un serv_addr;
        mode_t orig_mode;
-       orig_mode = umask(0111);
 
        /* Create a TCP socket */
        if ((sock = socket(PF_FILE, SOCK_STREAM, 0)) < 0) {
@@ -256,6 +249,8 @@ int ms_ipc_create_server_tcp_socket(ms_protocol_e protocol, int port, int *sock_
        unlink(MEDIA_IPC_PATH[port]);
        strcpy(serv_addr.sun_path, MEDIA_IPC_PATH[port]);
 
+       orig_mode = umask(0);
+
        /* Bind to the local address */
        for (i = 0; i < 20; i ++) {
                if (bind(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == 0) {
@@ -266,6 +261,8 @@ int ms_ipc_create_server_tcp_socket(ms_protocol_e protocol, int port, int *sock_
                usleep(250000);
        }
 
+       umask(orig_mode);
+
        if (bind_success == false) {
                MSAPI_DBG_ERR("bind failed : %s %d_", strerror(errno), errno);
                close(sock);
@@ -285,7 +282,6 @@ int ms_ipc_create_server_tcp_socket(ms_protocol_e protocol, int port, int *sock_
 
        *sock_fd = sock;
 
-       umask(orig_mode);
        return MS_MEDIA_ERR_NONE;
 }
 
@@ -300,7 +296,6 @@ int ms_ipc_create_server_socket(ms_protocol_e protocol, int port, int *sock_fd)
 #ifdef _USE_UDS_SOCKET_
        struct sockaddr_un serv_addr;
        mode_t orig_mode;
-       orig_mode = umask(0111);
 #else
        struct sockaddr_in serv_addr;
 #endif
@@ -317,9 +312,6 @@ int ms_ipc_create_server_socket(ms_protocol_e protocol, int port, int *sock_fd)
                if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
 #endif
                        MSAPI_DBG_ERR("socket failed: %s", strerror(errno));
-#ifdef _USE_UDS_SOCKET_
-                       umask(orig_mode);
-#endif
                        return MS_MEDIA_ERR_SOCKET_CONN;
                }
        }
@@ -332,9 +324,6 @@ int ms_ipc_create_server_socket(ms_protocol_e protocol, int port, int *sock_fd)
                if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
 #endif
                        MSAPI_DBG_ERR("socket failed: %s", strerror(errno));
-#ifdef _USE_UDS_SOCKET_
-                       umask(orig_mode);
-#endif
                        return MS_MEDIA_ERR_SOCKET_CONN;
                }
        }
@@ -358,6 +347,9 @@ int ms_ipc_create_server_socket(ms_protocol_e protocol, int port, int *sock_fd)
 //     serv_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
        serv_addr.sin_port = htons(serv_port);
 #endif
+
+       orig_mode = umask(0);
+
        /* Bind to the local address */
        for (i = 0; i < 20; i ++) {
                if (bind(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == 0) {
@@ -368,12 +360,11 @@ int ms_ipc_create_server_socket(ms_protocol_e protocol, int port, int *sock_fd)
                usleep(250000);
        }
 
+       umask(orig_mode);
+
        if (bind_success == false) {
                MSAPI_DBG_ERR("bind failed : %s %d_", strerror(errno), errno);
                close(sock);
-#ifdef _USE_UDS_SOCKET_
-                       umask(orig_mode);
-#endif
                return MS_MEDIA_ERR_SOCKET_CONN;
        }
 
@@ -384,9 +375,6 @@ int ms_ipc_create_server_socket(ms_protocol_e protocol, int port, int *sock_fd)
                if (listen(sock, SOMAXCONN) < 0) {
                        MSAPI_DBG_ERR("listen failed : %s", strerror(errno));
                        close(sock);
-#ifdef _USE_UDS_SOCKET_
-                       umask(orig_mode);
-#endif
                        return MS_MEDIA_ERR_SOCKET_CONN;
                }
 
@@ -394,9 +382,6 @@ int ms_ipc_create_server_socket(ms_protocol_e protocol, int port, int *sock_fd)
        }
 
        *sock_fd = sock;
-#ifdef _USE_UDS_SOCKET_
-       umask(orig_mode);
-#endif
 
        return MS_MEDIA_ERR_NONE;
 }
@@ -426,8 +411,13 @@ int ms_ipc_send_msg_to_server(int sockfd, int port, ms_comm_msg_s *send_msg, str
        addr.sin_port = htons(port);
 #endif
 
-       if (sendto(sockfd, send_msg, sizeof(*(send_msg)), 0, (struct sockaddr *)&addr, sizeof(addr)) != sizeof(*(send_msg))) {
-               MSAPI_DBG_ERR("sendto failed [%s]", strerror(errno));
+    if (connect(sockfd, &addr, sizeof(addr)) < 0) {
+        MSAPI_DBG_ERR("connect failed [%s]",strerror(errno));
+        return MS_MEDIA_ERR_SOCKET_SEND;
+    }
+
+       if (send(sockfd, send_msg, sizeof(*(send_msg)), 0) != sizeof(*(send_msg))) {
+               MSAPI_DBG_ERR("send failed [%s]", strerror(errno));
                res = MS_MEDIA_ERR_SOCKET_SEND;
        } else {
                MSAPI_DBG("sent %d", send_msg->result);
@@ -446,30 +436,29 @@ int ms_ipc_send_msg_to_client(int sockfd, ms_comm_msg_s *send_msg, struct sockad
 #endif
 {
        int res = MS_MEDIA_ERR_NONE;
-
-#ifdef _USE_UDS_SOCKET_
-       MSAPI_DBG("the path of client address : %s", client_addr->sun_path);
-#endif
-       if (sendto(sockfd, send_msg, sizeof(*(send_msg)), 0, (struct sockaddr *)client_addr, sizeof(*(client_addr))) != sizeof(*(send_msg))) {
-               MSAPI_DBG_ERR("sendto failed [%s]", strerror(errno));
+       
+       if (send(sockfd, send_msg, sizeof(*(send_msg)), 0) != sizeof(*(send_msg))) {
+               MSAPI_DBG_ERR("send failed [%s]", strerror(errno));
                res = MS_MEDIA_ERR_SOCKET_SEND;
        } else {
                MSAPI_DBG("sent %d", send_msg->result);
                MSAPI_DBG("sent %s", send_msg->msg);
        }
 
-       return MS_MEDIA_ERR_NONE;
+       return res;
 }
 
 #ifdef _USE_UDS_SOCKET_
-int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *addr_size)
+int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *addr_size, int *recv_socket)
 #else
 int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_in *recv_addr, unsigned int *addr_size)
 #endif
 {
        int recv_msg_size;
+       int client_socket = -1;
 #ifdef _USE_UDS_SOCKET_
-       struct sockaddr_un addr;
+       struct sockaddr_un addr, client_addr;
+       unsigned int client_addr_len;
 #else
        struct sockaddr_in addr;
 #endif
@@ -484,13 +473,19 @@ int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, st
        addr_len = sizeof(struct sockaddr_in);
 #endif
 
-       if ((recv_msg_size = recvfrom(sockfd, recv_msg, msg_size, 0, (struct sockaddr *)&addr, &addr_len)) < 0) {
-               MSAPI_DBG_ERR("recvfrom failed [%s]", strerror(errno));
+    if ((client_socket = accept(sockfd,(struct sockaddr *) &client_addr,(socklen_t *) &client_addr_len)) < 0) {
+        MSAPI_DBG_ERR("accept failed [%s]",strerror(errno));
+        return MS_MEDIA_ERR_SOCKET_RECEIVE;
+    }
+
+       if ((recv_msg_size = recv(client_socket, recv_msg, msg_size, 0)) < 0) {
+               MSAPI_DBG_ERR("recv failed [%s]", strerror(errno));
                return MS_MEDIA_ERR_SOCKET_RECEIVE;
        }
 
 #ifdef _USE_UDS_SOCKET_
-       MSAPI_DBG("the path of received client address : %s", addr.sun_path);
+       if (recv_socket != NULL)
+               *recv_socket = client_socket;
 #endif
 
        if (recv_addr != NULL)
@@ -502,7 +497,7 @@ int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, st
 }
 
 #ifdef _USE_UDS_SOCKET_
-int ms_ipc_wait_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *addr_size)
+int ms_ipc_wait_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *addr_size, int connected)
 #else
 int ms_ipc_wait_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_in *recv_addr, unsigned int *addr_size)
 #endif
@@ -510,6 +505,10 @@ int ms_ipc_wait_message(int sockfd, void *recv_msg, unsigned int msg_size, struc
        int recv_msg_size;
        socklen_t addr_len;
 
+       struct sockaddr_un client_addr;
+       unsigned int client_addr_len;
+       int client_socket = -1;
+       
        if (!recv_msg ||!recv_addr)
                return MS_MEDIA_ERR_INVALID_PARAMETER;
 
@@ -519,13 +518,19 @@ int ms_ipc_wait_message(int sockfd, void *recv_msg, unsigned int msg_size, struc
        addr_len = sizeof(struct sockaddr_in);
 #endif
 
-       if ((recv_msg_size = recvfrom(sockfd, recv_msg, msg_size, 0, (struct sockaddr *)recv_addr, &addr_len)) < 0) {
-               MSAPI_DBG_ERR("recvfrom failed [%s]", strerror(errno));
-               if (errno == EWOULDBLOCK) {
-                       MSAPI_DBG_ERR("recvfrom Timeout.");
-                       return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
-               } else {
-                       MSAPI_DBG_ERR("recvfrom error [%s]", strerror(errno));
+       if (connected != TRUE){
+
+               if ((client_socket = accept(sockfd,(struct sockaddr *) &client_addr,(socklen_t *) &client_addr_len)) < 0) {
+                       MSAPI_DBG_ERR("accept failed [%s]",strerror(errno));
+                       return MS_MEDIA_ERR_SOCKET_RECEIVE;
+               }
+               if ((recv_msg_size = recv(client_socket, recv_msg, msg_size, 0)) < 0) {
+                       MSAPI_DBG_ERR("recv failed [%s]", strerror(errno));
+                       return MS_MEDIA_ERR_SOCKET_RECEIVE;
+               }
+       } else {
+                       if ((recv_msg_size = recv(sockfd, recv_msg, msg_size, 0)) < 0) {
+                       MSAPI_DBG_ERR("recv failed [%s]", strerror(errno));
                        return MS_MEDIA_ERR_SOCKET_RECEIVE;
                }
        }

diff --git a/lib/media-util-register.c b/lib/media-util-register.c
index d1b61ab..380b11a 100755 (executable)
--- a/lib/media-util-register.c
+++ b/lib/media-util-register.c
@@ -171,7 +171,9 @@ gboolean _read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
        memset(&recv_msg, 0x0, sizeof(ms_comm_msg_s));
 
        /* Socket is readable */
-       ret = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(recv_msg), NULL, NULL);
+       struct sockaddr_in recv_add;
+       
+       ret = ms_ipc_wait_message(sockfd, &recv_msg, sizeof(recv_msg), &recv_add, NULL, TRUE);
        if (ret != MS_MEDIA_ERR_NONE) {
                MSAPI_DBG("ms_ipc_receive_message failed");
                return TRUE;
@@ -274,7 +276,7 @@ static int __media_db_request_update_async(ms_msg_type_e msg_type, const char *r
 
        /*Create Socket*/
 #ifdef _USE_UDS_SOCKET_
-       ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd, port);
+       ret = ms_ipc_create_client_socket(MS_PROTOCOL_TCP, 0, &sockfd, port);
 #else
        ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
 #endif

diff --git a/src/scanner/media-scanner-socket.c b/src/scanner/media-scanner-socket.c
index b6639bd..b638b43 100755 (executable)
--- a/src/scanner/media-scanner-socket.c
+++ b/src/scanner/media-scanner-socket.c
@@ -71,7 +71,7 @@ gboolean msc_receive_request(GIOChannel *src, GIOCondition condition, gpointer d
        }
 
        /* Socket is readable */
-       ret = ms_ipc_receive_message(sockfd, recv_msg, sizeof(*recv_msg), NULL, NULL);
+       ret = ms_ipc_receive_message(sockfd, recv_msg, sizeof(*recv_msg), NULL, NULL, NULL);
        if (ret != MS_MEDIA_ERR_NONE) {
                MS_SAFE_FREE(recv_msg);
                return TRUE;
@@ -115,7 +115,7 @@ int msc_send_scan_result(int result, ms_comm_msg_s *scan_data)
 
        /*Create Socket*/
 #ifdef _USE_UDS_SOCKET_
-       ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd, MS_SCAN_COMM_PORT);
+       ret = ms_ipc_create_client_socket(MS_PROTOCOL_TCP, 0, &sockfd, MS_SCAN_COMM_PORT);
 #else
        ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
 #endif
@@ -148,7 +148,7 @@ int msc_send_register_result(int result, ms_comm_msg_s *reg_data)
 
        /*Create Socket*/
 #ifdef _USE_UDS_SOCKET_
-       ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd, MS_SCAN_COMM_PORT);
+       ret = ms_ipc_create_client_socket(MS_PROTOCOL_TCP, 0, &sockfd, MS_SCAN_COMM_PORT);
 #else
        ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
 #endif
@@ -179,7 +179,7 @@ int msc_send_ready(void)
 
        /*Create Socket*/
 #ifdef _USE_UDS_SOCKET_
-       ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd, MS_SCAN_COMM_PORT);
+       ret = ms_ipc_create_client_socket(MS_PROTOCOL_TCP, 0, &sockfd, MS_SCAN_COMM_PORT);
 #else
        ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
 #endif

diff --git a/src/scanner/media-scanner.c b/src/scanner/media-scanner.c
index 4a36851..48fffb0 100755 (executable)
--- a/src/scanner/media-scanner.c
+++ b/src/scanner/media-scanner.c
@@ -254,7 +254,7 @@ int main(int argc, char **argv)
 
        /*prepare socket*/
        /* Create and bind new UDP socket */
-       if (ms_ipc_create_server_socket(MS_PROTOCOL_UDP, MS_SCAN_DAEMON_PORT, &sockfd)
+       if (ms_ipc_create_server_socket(MS_PROTOCOL_TCP, MS_SCAN_DAEMON_PORT, &sockfd)
                != MS_MEDIA_ERR_NONE) {
                MSC_DBG_ERR("Failed to create socket\n");
                exit(0);

diff --git a/src/server/media-server-db.c b/src/server/media-server-db.c
index a60dfd8..ec41384 100755 (executable)
--- a/src/server/media-server-db.c
+++ b/src/server/media-server-db.c
@@ -64,7 +64,7 @@ gboolean ms_db_thread(void *data)
 
 
        /* Create Socket*/
-       ret = ms_ipc_create_server_socket(MS_PROTOCOL_UDP, MS_DB_UPDATE_PORT, &sockfd);
+       ret = ms_ipc_create_server_socket(MS_PROTOCOL_TCP, MS_DB_UPDATE_PORT, &sockfd);
        if(ret != MS_MEDIA_ERR_NONE) {
 
                MS_DBG_ERR("Failed to create socket\n");

diff --git a/src/server/media-server-main.c b/src/server/media-server-main.c
index ce1a8f6..60a6c98 100755 (executable)
--- a/src/server/media-server-main.c
+++ b/src/server/media-server-main.c
@@ -316,7 +316,7 @@ int main(int argc, char **argv)
        _mkdir("/var/run/media-server",S_IRWXU | S_IRWXG | S_IRWXO);
        
        /* Create and bind new UDP socket */
-       if (ms_ipc_create_server_socket(MS_PROTOCOL_UDP, MS_SCANNER_PORT, &sockfd)
+       if (ms_ipc_create_server_socket(MS_PROTOCOL_TCP, MS_SCANNER_PORT, &sockfd)
                != MS_MEDIA_ERR_NONE) {
                MS_DBG_ERR("Failed to create socket");
        } else {

diff --git a/src/server/media-server-scanner.c b/src/server/media-server-scanner.c
index acd0f52..d3b6acc 100755 (executable)
--- a/src/server/media-server-scanner.c
+++ b/src/server/media-server-scanner.c
@@ -168,7 +168,7 @@ ms_scanner_start(void)
 
                /*Create Socket*/
 #ifdef _USE_UDS_SOCKET_
-               ret = ms_ipc_create_server_socket(MS_PROTOCOL_UDP, MS_SCAN_COMM_PORT, &sockfd);
+               ret = ms_ipc_create_server_socket(MS_PROTOCOL_TCP, MS_SCAN_COMM_PORT, &sockfd);
                if (ret != MS_MEDIA_ERR_NONE) {
                        MS_DBG_ERR("ms_ipc_create_server_socket failed [%d]",ret);
                        g_mutex_unlock(scanner_mutex);
@@ -204,7 +204,8 @@ ms_scanner_start(void)
 
                /*Receive Response*/
                serv_addr_len = sizeof(serv_addr);
-               err = ms_ipc_wait_message(sockfd, &recv_msg, sizeof(recv_msg), &serv_addr, NULL);
+
+               err = ms_ipc_wait_message(sockfd, &recv_msg, sizeof(recv_msg), &serv_addr, NULL, FALSE);
                if (err != MS_MEDIA_ERR_NONE) {
                        ret = err;
                        close(sockfd);

diff --git a/src/server/media-server-socket.c b/src/server/media-server-socket.c
index d1753e0..fb17e46 100755 (executable)
--- a/src/server/media-server-socket.c
+++ b/src/server/media-server-socket.c
@@ -28,6 +28,8 @@
  * @brief
  */
  
+#define _GNU_SOURCE
+ 
 #include <arpa/inet.h>
 #include <sys/types.h>
 #ifdef _USE_UDS_SOCKET_
@@ -60,6 +62,7 @@ typedef struct ms_req_owner_data
        int index;
 #ifdef _USE_UDS_SOCKET_
        struct sockaddr_un *client_addr;
+       int client_socket;
 #else
        struct sockaddr_in *client_addr;
 #endif
@@ -129,6 +132,9 @@ gboolean ms_read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
        int pid;
        int req_num;
        int path_size;
+       int client_sock = -1;
+       struct ucred cr;
+       int cl = sizeof(struct ucred);
 
        g_mutex_lock(scanner_mutex);
 
@@ -155,7 +161,7 @@ gboolean ms_read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
 #else
        client_addr_len = sizeof(struct sockaddr_in);
 #endif
-       ret = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(recv_msg), client_addr, NULL);
+       ret = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(recv_msg), client_addr, NULL, &client_sock);
        if (ret != MS_MEDIA_ERR_NONE) {
                MS_DBG_ERR("ms_ipc_receive_message failed");
                MS_SAFE_FREE(client_addr);
@@ -163,7 +169,11 @@ gboolean ms_read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
                return TRUE;
        }
 
-       MS_DBG("receive msg from [%d] %d, %s, uid %d", recv_msg.pid, recv_msg.msg_type, recv_msg.msg, recv_msg.uid);
+       if (getsockopt(client_sock, SOL_SOCKET, SO_PEERCRED, &cr, (socklen_t *) &cl) < 0) {
+               MS_DBG_ERR("Credentail information error");
+       }
+
+       MS_DBG("receive msg from [%d] %d, %s, uid %d", recv_msg.pid, recv_msg.msg_type, recv_msg.msg, cr.uid);
 
        if (recv_msg.msg_size > 0 && recv_msg.msg_size < MS_FILE_PATH_LEN_MAX) {
                msg_size = recv_msg.msg_size;
@@ -207,6 +217,7 @@ gboolean ms_read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
                MS_MALLOC(owner_data, sizeof(ms_req_owner_data));
                owner_data->pid = recv_msg.pid;
                owner_data->client_addr = client_addr;
+               owner_data->client_socket = client_sock;
 
                _ms_add_owner(owner_data);
 
@@ -214,7 +225,7 @@ gboolean ms_read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
                scan_msg.msg_type = req_num;
                scan_msg.pid = pid;
                scan_msg.msg_size = msg_size;
-               scan_msg.uid = recv_msg.uid;
+               scan_msg.uid = cr.uid;
                ms_strcopy(scan_msg.msg, path_size, "%s", recv_msg.msg);
 
                g_mutex_unlock(scanner_mutex);
@@ -248,6 +259,8 @@ gboolean ms_receive_message_from_scanner(GIOChannel *src, GIOCondition condition
        int sockfd = MS_SOCK_NOT_ALLOCATE;
        int msg_type;
        int ret;
+       int client_sock = -1;
+       struct sockaddr_un client_addr;
 
        sockfd = g_io_channel_unix_get_fd(src);
        if (sockfd < 0) {
@@ -256,7 +269,7 @@ gboolean ms_receive_message_from_scanner(GIOChannel *src, GIOCondition condition
        }
 
        /* Socket is readable */
-       ret = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(recv_msg), NULL, NULL);
+       ret = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(recv_msg), &client_addr, NULL, NULL);
        if (ret != MS_MEDIA_ERR_NONE) {
                MS_DBG_ERR("ms_ipc_receive_message failed [%s]", strerror(errno));
                return TRUE;
@@ -283,8 +296,7 @@ gboolean ms_receive_message_from_scanner(GIOChannel *src, GIOCondition condition
 
                                /* owner data exists */
                                /* send result to the owner of request */
-                               ms_ipc_send_msg_to_client(sockfd, &recv_msg, owner_data->client_addr);
-
+                               ms_ipc_send_msg_to_client(owner_data->client_socket, &recv_msg, owner_data->client_addr);
                                /* free owner data*/
                                _ms_delete_owner(owner_data);
                        }
@@ -307,7 +319,7 @@ int ms_send_scan_request(ms_comm_msg_s *send_msg)
 
        /*Create Socket*/
 #ifdef _USE_UDS_SOCKET_
-       ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd, MS_SCAN_DAEMON_PORT);
+       ret = ms_ipc_create_client_socket(MS_PROTOCOL_TCP, 0, &sockfd, MS_SCAN_DAEMON_PORT);
 #else
        ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
 #endif
@@ -333,8 +345,6 @@ int ms_send_storage_scan_request(ms_storage_type_t storage_type, ms_dir_scan_typ
                .msg_size = 0,
                .msg = {0},
        };
-
-       scan_msg.uid = tzplatform_getuid(TZ_USER_NAME);
        
        /* msg_type */
        switch (scan_type) {
@@ -403,10 +413,14 @@ gboolean ms_read_db_socket(GIOChannel *src, GIOCondition condition, gpointer dat
        ms_comm_msg_s recv_msg;
        int send_msg = MS_MEDIA_ERR_NONE;
        int sockfd = MS_SOCK_NOT_ALLOCATE;
+       int client_sock = -1;
        int ret = MS_MEDIA_ERR_NONE;
        MediaDBHandle *db_handle = NULL;
        ms_comm_msg_s msg;
        char * sql_query = NULL;
+       uid_t uid;
+    struct ucred cr;
+    int cl = sizeof(struct ucred);
 
        memset(&recv_msg, 0, sizeof(recv_msg));
 
@@ -416,7 +430,7 @@ gboolean ms_read_db_socket(GIOChannel *src, GIOCondition condition, gpointer dat
                return TRUE;
        }
 
-       ret = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(recv_msg), &client_addr, NULL);
+       ret = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(recv_msg), &client_addr, NULL, &client_sock);
        if (ret != MS_MEDIA_ERR_NONE) {
                MS_DBG_ERR("ms_ipc_receive_message failed");
                return TRUE;
@@ -424,12 +438,22 @@ gboolean ms_read_db_socket(GIOChannel *src, GIOCondition condition, gpointer dat
 
 //     MS_DBG("msg_type[%d], msg_size[%d] msg[%s]", recv_msg.msg_type, recv_msg.msg_size, recv_msg.msg);
 
+       if (getsockopt(client_sock, SOL_SOCKET, SO_PEERCRED, &cr, (socklen_t *) &cl) < 0) {
+               MS_DBG_ERR("credential information error");
+       }
+
+       if ( getuid() == cr.uid ){
+               uid = recv_msg.uid;
+       } else {
+               uid = cr.uid;
+       }
+
        if((recv_msg.msg_size <= 0) ||(recv_msg.msg_size > MS_FILE_PATH_LEN_MAX)  || (!MS_STRING_VALID(recv_msg.msg))) {
                MS_DBG_ERR("invalid query. size[%d]", recv_msg.msg_size);
                return TRUE;
        }
 
-       media_db_connect(&db_handle, recv_msg.uid);
+       media_db_connect(&db_handle, uid);
 
        sql_query = strndup(recv_msg.msg, recv_msg.msg_size);
        if (sql_query != NULL) {
@@ -446,7 +470,7 @@ gboolean ms_read_db_socket(GIOChannel *src, GIOCondition condition, gpointer dat
        memset(&msg, 0x0, sizeof(ms_comm_msg_s));
        msg.result = send_msg;
 
-       ms_ipc_send_msg_to_client(sockfd, &msg, &client_addr);
+       ms_ipc_send_msg_to_client(client_sock, &msg, &client_addr);
 
        media_db_disconnect(db_handle);
 
@@ -475,7 +499,10 @@ gboolean ms_read_db_tcp_socket(GIOChannel *src, GIOCondition condition, gpointer
        int ret = MS_MEDIA_ERR_NONE;
        char * sql_query = NULL;
        MediaDBHandle *db_handle = NULL;
-
+       uid_t uid;
+       struct ucred cr;
+       int cl = sizeof(struct ucred);
+       
        sock = g_io_channel_unix_get_fd(src);
        if (sock < 0) {
                MS_DBG_ERR("sock fd is invalid!");
@@ -513,9 +540,19 @@ gboolean ms_read_db_tcp_socket(GIOChannel *src, GIOCondition condition, gpointer
                        return TRUE;
                }
 
+               if (getsockopt(client_sock, SOL_SOCKET, SO_PEERCRED, &cr, (socklen_t *) &cl) < 0) {
+               MS_DBG_ERR("credential information error");
+               }
+
+               if ( getuid() == cr.uid ){
+                       uid = recv_msg.uid;
+               } else {
+                       uid = cr.uid;
+               }
+
                sql_query = strndup(recv_msg.msg, recv_msg.msg_size);
                if (sql_query != NULL) {
-                       media_db_connect(&db_handle, recv_msg.uid);
+                       media_db_connect(&db_handle, uid);
                        if (recv_msg.msg_type == MS_MSG_DB_UPDATE_BATCH_START) {
                                ret = media_db_update_db_batch_start(sql_query);
                        } else if(recv_msg.msg_type == MS_MSG_DB_UPDATE_BATCH_END) {

diff --git a/src/server/media-server-thumb.c b/src/server/media-server-thumb.c
index db449c4..0281c70 100755 (executable)
--- a/src/server/media-server-thumb.c
+++ b/src/server/media-server-thumb.c
@@ -19,6 +19,8 @@
  *
  */
 
+#define _GNU_SOURCE
+
 #include <dirent.h>
 #include <errno.h>
 
@@ -354,8 +356,8 @@ _ms_thumb_recv_udp_msg(int sock, int header_size, thumbMsg *msg, struct sockaddr
        unsigned char *buf = NULL;
 
        buf = (unsigned char*)malloc(sizeof(thumbMsg));
-
-       recv_msg_len = ms_ipc_wait_message(sock, buf, sizeof(thumbMsg), from_addr, &from_addr_size);
+       
+       recv_msg_len = ms_ipc_wait_message(sock, buf, sizeof(thumbMsg), from_addr, &from_addr_size, TRUE);
        if (recv_msg_len != MS_MEDIA_ERR_NONE) {
                MS_DBG_ERR("ms_ipc_wait_message failed : %s", strerror(errno));
                MS_SAFE_FREE(buf);
@@ -441,7 +443,7 @@ gboolean _ms_thumb_agent_recv_msg_from_server()
        ms_thumb_server_msg recv_msg;
        int recv_msg_size = 0;
 
-       recv_msg_size = ms_ipc_receive_message(g_communicate_sock, & recv_msg, sizeof(ms_thumb_server_msg),  NULL, NULL);
+       recv_msg_size = ms_ipc_receive_message(g_communicate_sock, & recv_msg, sizeof(ms_thumb_server_msg),  NULL, NULL, NULL);
        if (recv_msg_size != MS_MEDIA_ERR_NONE) {
                MS_DBG_ERR("ms_ipc_receive_message failed : %s\n", strerror(errno));
                return FALSE;
@@ -468,7 +470,7 @@ gboolean _ms_thumb_agent_recv_thumb_done_from_server(GIOChannel *src, GIOConditi
        ms_thumb_server_msg recv_msg;
        int recv_msg_size = 0;
 
-       recv_msg_size = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(ms_thumb_server_msg), NULL, NULL);
+       recv_msg_size = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(ms_thumb_server_msg), NULL, NULL, NULL);
        if (recv_msg_size != MS_MEDIA_ERR_NONE) {
                MS_DBG_ERR("ms_ipc_receive_message failed : %s\n", strerror(errno));
                return FALSE;
@@ -961,7 +963,9 @@ gboolean _ms_thumb_agent_read_socket(GIOChannel *src,
        int header_size = 0;
        int sock = -1;
        int client_sock = -1;
-
+       struct ucred cr;
+       int cl = sizeof(struct ucred);
+       
        sock = g_io_channel_unix_get_fd(src);
        if (sock < 0) {
                MS_DBG_ERR("sock fd is invalid!");
@@ -992,7 +996,13 @@ gboolean _ms_thumb_agent_read_socket(GIOChannel *src,
                return TRUE;
        }
 
-       MS_DBG("Received [%d] %s(%d) from PID(%d) \n", recv_msg->msg_type, recv_msg->org_path, strlen(recv_msg->org_path), recv_msg->pid);
+       if (getsockopt(client_sock, SOL_SOCKET, SO_PEERCRED, &cr, (socklen_t *) &cl) < 0) {
+               MS_DBG_ERR("credential information error");
+       }
+
+       if ( getuid() != cr.uid ){
+               recv_msg->uid = cr.uid;
+       }
 
        thumbRequest *thumb_req = NULL;
        thumb_req = calloc(1, sizeof(thumbRequest));
@@ -1135,7 +1145,7 @@ gboolean _ms_thumb_agent_prepare_udp_socket()
 
        serv_port = MS_THUMB_COMM_PORT;
 
-       if (ms_ipc_create_server_socket(MS_PROTOCOL_UDP, serv_port, &sock) < 0) {
+       if (ms_ipc_create_server_socket(MS_PROTOCOL_TCP, serv_port, &sock) < 0) {
                MS_DBG_ERR("ms_ipc_create_server_socket failed");
                return FALSE;
        }