Modify tcp message transfer to service daemon

Change-Id: Id2e3d0b5635812acc32c5272f1e2d5d75b84c1ba

diff --git a/packaging/capi-media-controller.spec b/packaging/capi-media-controller.spec
index d6d8fe2..8a60700 100755 (executable)
--- a/packaging/capi-media-controller.spec
+++ b/packaging/capi-media-controller.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-controller
 Summary:    A media controller library in Tizen Native API
-Version:    0.1.60
+Version:    0.1.61
 Release:    1
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/media_controller_ipc.c b/src/media_controller_ipc.c
index ca008d3..972b118 100755 (executable)
--- a/src/media_controller_ipc.c
+++ b/src/media_controller_ipc.c
@@ -325,10 +325,6 @@ int mc_ipc_send_message_to_server(mc_msg_type_e msg_type, mc_priv_type_e priv_ty
        }
 
        request_msg_size = strlen(request_msg);
-       if (request_msg_size >= MAX_MSG_SIZE) {
-               mc_error("Query is Too long. [%d] query size limit is [%d]", request_msg_size, MAX_MSG_SIZE);
-               return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER;
-       }
 
        mc_secure_debug("msg_type[%d] priv_type[%d], message[%s]", msg_type, priv_type, request_msg);
 
@@ -340,7 +336,6 @@ int mc_ipc_send_message_to_server(mc_msg_type_e msg_type, mc_priv_type_e priv_ty
        send_msg.pid = getpid();
        send_msg.uid = getuid();
        send_msg.msg_size = request_msg_size;
-       MC_SAFE_STRLCPY(send_msg.msg, request_msg, sizeof(send_msg.msg));
 
        /*Create Socket*/
        ret = mc_ipc_create_client_socket(MC_TIMEOUT_SEC_5, &sockfd);
@@ -362,13 +357,46 @@ int mc_ipc_send_message_to_server(mc_msg_type_e msg_type, mc_priv_type_e priv_ty
                        return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
        }
 
-       /* Send request */
-       if (send(sockfd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
-               mc_stderror("send failed");
-               close(sockfd);
+       size_t full_msg_size = 0;
+       size_t head_msg_size = 0;
+       size_t send_msg_size = 0;
+       size_t temp_buf_index = 0;
+       char *temp_buf = NULL;
 
-               return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+       head_msg_size = sizeof(send_msg) - sizeof(send_msg.msg);
+       full_msg_size = head_msg_size + request_msg_size;
+
+       temp_buf = (char *)calloc(1, full_msg_size + 1);
+       if (temp_buf == NULL) {
+               mc_error("Error memroy allocation");
+               return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
        }
+       memcpy(temp_buf, &send_msg, head_msg_size);
+       memcpy(temp_buf + head_msg_size, request_msg, request_msg_size);
+
+       if (full_msg_size <= MAX_MSG_SIZE)
+               send_msg_size = full_msg_size;
+       else
+               send_msg_size = head_msg_size;
+
+       while (temp_buf_index < full_msg_size) {
+               size_t send_result = 0;
+               /* Send request */
+               send_result = send(sockfd, temp_buf + temp_buf_index, send_msg_size, 0);
+               if (send_result < send_msg_size) {
+                       mc_stderror("send failed");
+                       close(sockfd);
+                       MC_SAFE_FREE(temp_buf);
+                       return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+               }
+               temp_buf_index += send_result;
+               if ((full_msg_size - temp_buf_index) > MAX_MSG_SIZE)
+                       send_msg_size = MAX_MSG_SIZE;
+               else
+                       send_msg_size = full_msg_size - temp_buf_index;
+       }
+
+       MC_SAFE_FREE(temp_buf);
 
        /*Receive Response*/
        int recv_msg_size = -1;

diff --git a/svc/include/media_controller_socket.h b/svc/include/media_controller_socket.h
index 72a3e8c..55324e8 100755 (executable)
--- a/svc/include/media_controller_socket.h
+++ b/svc/include/media_controller_socket.h
@@ -27,8 +27,8 @@ extern "C" {
 #endif /* __cplusplus */
 
 #define SERVER_IP                      "127.0.0.1"
-#define MC_TIMEOUT_SEC_5                                       5               /**< Response from Server time out */
-#define MAX_MSG_SIZE                           4096*2
+#define MC_TIMEOUT_SEC_5                                       5               /* Response from daemon time out */
+#define MAX_MSG_SIZE                           10 * 1024               /* Maximum of message to daemon */
 #define MC_SOCK_NOT_ALLOCATE           -1
 #define MC_SOCK_ACTIVATION_PATH                "/run/.mediacontroller.sock"            /* tzplatform_mkpath(TZ_SYS_RUN, ".media_controller.sock") */
 #define MC_IPC_PATH                                    "/run/.mediacontroller-comm.sock"       /* tzplatform_mkpath(TZ_SYS_RUN, ".media_controller-comm.sock") */
@@ -61,7 +61,7 @@ typedef struct {
        uid_t uid;
        int result;
        size_t msg_size; /*this is size of message below and this does not include the terminationg null byte ('\0'). */
-       char msg[MAX_MSG_SIZE];
+       char *msg;
 } mc_comm_msg_s;
 
 int mc_ipc_create_client_socket(int timeout_sec, int *sock_fd);

diff --git a/svc/media_controller_cynara.c b/svc/media_controller_cynara.c
index de1c00a..ab67cba 100755 (executable)
--- a/svc/media_controller_cynara.c
+++ b/svc/media_controller_cynara.c
@@ -72,12 +72,14 @@ void mc_cynara_finish(void)
 int mc_cynara_receive_untrusted_message(int sockfd, mc_comm_msg_s *recv_msg, mc_peer_creds *credentials)
 {
        int ret = 0;
-       int recv_msg_size = 0;
+       size_t recv_msg_size = 0;
+       size_t head_size = 0;
 
        if (!recv_msg || !credentials)
                return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER;
 
-       if ((recv_msg_size = read(sockfd, recv_msg, sizeof(mc_comm_msg_s))) < 0) {
+       head_size = sizeof(mc_comm_msg_s) - sizeof(recv_msg->msg);
+       if ((recv_msg_size = read(sockfd, recv_msg, head_size)) < head_size) {
                if (errno == EWOULDBLOCK) {
                        mc_error("Timeout. Can't try any more");
                        return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
@@ -87,6 +89,52 @@ int mc_cynara_receive_untrusted_message(int sockfd, mc_comm_msg_s *recv_msg, mc_
                }
        }
 
+       if (recv_msg->msg_size > 0) {
+               size_t remain_size = recv_msg->msg_size;
+               size_t block_size = 0;
+               size_t msg_index = 0;
+               char *recv_buf = NULL;
+
+               recv_buf = (char *)calloc(1, MAX_MSG_SIZE + 1);
+               recv_msg->msg = (char *)calloc(1, recv_msg->msg_size + 1);
+
+               if (recv_buf == NULL || recv_msg->msg == NULL) {
+                       mc_error("Error memroy allocation");
+                       MC_SAFE_FREE(recv_buf);
+                       MC_SAFE_FREE(recv_msg->msg);
+                       return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
+               }
+
+               while (remain_size > 0) {
+                       memset(recv_buf, 0, MAX_MSG_SIZE + 1);
+                       if (remain_size < MAX_MSG_SIZE)
+                               block_size = remain_size;
+                       else
+                               block_size = MAX_MSG_SIZE;
+
+                       if ((recv_msg_size = read(sockfd, recv_buf, block_size)) < block_size) {
+                               MC_SAFE_FREE(recv_buf);
+                               MC_SAFE_FREE(recv_msg->msg);
+                               if (errno == EWOULDBLOCK) {
+                                       mc_error("Timeout. Can't try any more");
+                                       return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+                               } else {
+                                       mc_stderror("recv failed");
+                                       return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+                               }
+                       }
+
+                       memcpy(recv_msg->msg + msg_index, recv_buf, recv_msg_size);
+                       msg_index += recv_msg_size;
+                       remain_size -= recv_msg_size;
+               }
+
+               MC_SAFE_FREE(recv_buf);
+       } else {
+               mc_error("msg_size is zero");
+               recv_msg->msg = NULL;
+       }
+
 /*     mc_debug("receive msg[%d] from [%d(%d)] %d, %s", recv_msg_size, recv_msg->pid, recv_msg->uid, recv_msg->msg_type, recv_msg->msg); */
 
        ret = cynara_creds_socket_get_pid(sockfd, &(credentials->pid));

diff --git a/svc/media_controller_svc.c b/svc/media_controller_svc.c
index 914c598..58a0d5b 100755 (executable)
--- a/svc/media_controller_svc.c
+++ b/svc/media_controller_svc.c
@@ -64,6 +64,8 @@ static void __mc_destroy_queue(gpointer data)
 {
        mc_service_request *req = (mc_service_request *)data;
        if (req != NULL) {
+               if (req->req_msg != NULL)
+                       MC_SAFE_FREE(req->req_msg->msg);
                MC_SAFE_FREE(req->req_msg);
                MC_SAFE_FREE(req);
        }
@@ -561,14 +563,25 @@ gboolean _mc_read_service_request_tcp_socket(GIOChannel *src, GIOCondition condi
                        goto ERROR;
                }
 
-               req->req_msg = (mc_comm_msg_s *) malloc(sizeof(mc_comm_msg_s));
+               req->req_msg = (mc_comm_msg_s *) calloc(1, sizeof(mc_comm_msg_s));
                if (req->req_msg == NULL) {
                        send_msg = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
-                       MC_SAFE_FREE(req->req_msg);
                        goto ERROR;
                }
-               memset(req->req_msg, 0x00, sizeof(mc_comm_msg_s));
-               memcpy(req->req_msg, &recv_msg, sizeof(mc_comm_msg_s));
+               memcpy(req->req_msg, &recv_msg, sizeof(mc_comm_msg_s) - sizeof(recv_msg.msg));
+
+               if (recv_msg.msg_size > 0) {
+                       req->req_msg->msg = (char *) calloc(1, recv_msg.msg_size + 1);
+                       if (req->req_msg->msg == NULL) {
+                               send_msg = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
+                               MC_SAFE_FREE(req->req_msg);
+                               goto ERROR;
+                       }
+
+                       memcpy(req->req_msg->msg, recv_msg.msg, recv_msg.msg_size);
+               } else {
+                       req->req_msg->msg = NULL;
+               }
 
                mc_debug("msg(%d) is queued", req->req_msg->msg_type);
                g_queue_push_tail(request_queue, (gpointer)req);
@@ -594,6 +607,8 @@ ERROR:
                mc_stderror("close failed");
 
        if (req != NULL) {
+               if (req->req_msg != NULL)
+                       MC_SAFE_FREE(req->req_msg->msg);
                MC_SAFE_FREE(req->req_msg);
                MC_SAFE_FREE(req);
        }
@@ -642,7 +657,6 @@ gboolean mc_svc_thread(void *data)
        /* Create TCP Socket*/
        ret = mc_ipc_create_server_socket(MC_DB_UPDATE_PORT, &sockfd);
        if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-               /* Disconnect DB*/
                mc_error("Failed to create socket");
                _mc_service_deinit(mc_service_data);
                return FALSE;