common/scanner/media-scanner-socket.c

   1 /*
   2  *  Media Server
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Yong Yeon Kim <yy9875.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /**
  23  * This file defines api utilities of contents manager engines.
  24  *
  25  * @file                media-server-thumb.c
  26  * @author      Yong Yeon Kim(yy9875.kim@samsung.com)
  27  * @version     1.0
  28  * @brief
  29  */
  30 #include <arpa/inet.h>
  31 #include <sys/types.h>
  32 #include <sys/socket.h>
  33 #include <malloc.h>
  34 #include <vconf.h>
  35
  36 #include "media-util.h"
  37
  38 #include "media-server-ipc.h"
  39 #include "media-server-types.h"
  40 #include "media-scanner-dbg.h"
  41 #include "media-scanner-db-svc.h"
  42 #include "media-scanner-utils.h"
  43 #include "media-scanner-socket.h"
  44
  45 extern GAsyncQueue *storage_queue;
  46 extern GAsyncQueue *scan_queue;
  47 extern GAsyncQueue *reg_queue;
  48 GMutex *receive_mutex;
  49
  50 gboolean msc_receive_request(GIOChannel *src, GIOCondition condition, gpointer data)
  51 {
  52         ms_comm_msg_s *recv_msg = NULL;
  53         int sockfd = MS_SOCK_NOT_ALLOCATE;
  54         int req_num = MS_MSG_MAX;
  55         int pid = -1;
  56         int ret = MS_MEDIA_ERR_NONE;
  57
  58         sockfd = g_io_channel_unix_get_fd(src);
  59         if (sockfd < 0) {
  60                 MSC_DBG_ERR("sock fd is invalid!");
  61                 return TRUE;
  62         }
  63
  64         MS_MALLOC(recv_msg, sizeof(ms_comm_msg_s));
  65         if (recv_msg == NULL) {
  66                 MSC_DBG_ERR("MS_MALLOC failed");
  67                 return TRUE;
  68         }
  69
  70         /* Socket is readable */
  71         ret = ms_ipc_receive_message(sockfd, recv_msg, sizeof(*recv_msg), NULL, NULL);
  72         if (ret != MS_MEDIA_ERR_NONE) {
  73                 MS_SAFE_FREE(recv_msg);
  74                 return TRUE;
  75         }
  76
  77         MSC_DBG_INFO("receive msg from [%d] %d, %s", recv_msg->pid, recv_msg->msg_type, recv_msg->msg);
  78
  79         /* copy from recived data */
  80         req_num = recv_msg->msg_type;
  81         pid = recv_msg->pid;
  82
  83         /* request bulk insert*/
  84         if (req_num == MS_MSG_BULK_INSERT) {
  85                 MSC_DBG_INFO("BULK INSERT");
  86                 g_async_queue_push(reg_queue, GINT_TO_POINTER(recv_msg));
  87         } else if (req_num == MS_MSG_DIRECTORY_SCANNING ||req_num == MS_MSG_DIRECTORY_SCANNING_NON_RECURSIVE) {
  88                 /* this request from another apps */
  89                 /* set the scan data for scanning thread */
  90                 g_async_queue_push(scan_queue, GINT_TO_POINTER(recv_msg));
  91         } else if (req_num == MS_MSG_STORAGE_ALL ||req_num == MS_MSG_STORAGE_PARTIAL || req_num == MS_MSG_STORAGE_INVALID) {
  92                 /* this request from media-server */
  93                 g_async_queue_push(storage_queue, GINT_TO_POINTER(recv_msg));
  94         } else {
  95                 MSC_DBG_ERR("THIS REQUEST IS INVALID %d", req_num);
  96                 MS_SAFE_FREE(recv_msg);
  97                 return TRUE;
  98         }
  99
 100         /*Active flush */
 101         malloc_trim(0);
 102
 103         return TRUE;
 104 }
 105
 106 int msc_send_scan_result(int result, ms_comm_msg_s *scan_data)
 107 {
 108         int ret;
 109         int res = MS_MEDIA_ERR_NONE;
 110         int sockfd = -1;
 111         ms_comm_msg_s send_msg;
 112
 113         /*Create Socket*/
 114         ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
 115         if (ret != MS_MEDIA_ERR_NONE)
 116                 return MS_MEDIA_ERR_SOCKET_CONN;
 117
 118         /* send ready message */
 119         memset(&send_msg, 0x0, sizeof(ms_comm_msg_s));
 120         send_msg.msg_type = MS_MSG_SCANNER_RESULT;
 121         send_msg.pid = scan_data->pid;
 122         send_msg.result = result;
 123         send_msg.msg_size = strlen(scan_data->msg);
 124         strncpy(send_msg.msg, scan_data->msg, send_msg.msg_size);
 125
 126         ret = ms_ipc_send_msg_to_server(sockfd, MS_SCAN_COMM_PORT, &send_msg, NULL);
 127         if (ret != MS_MEDIA_ERR_NONE)
 128                 res = ret;
 129
 130         close(sockfd);
 131
 132         return res;
 133 }
 134
 135 int msc_send_register_result(int result, ms_comm_msg_s *reg_data)
 136 {
 137         int ret = MS_MEDIA_ERR_NONE;
 138         int sockfd = -1;
 139         ms_comm_msg_s send_msg;
 140
 141         /*Create Socket*/
 142         ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
 143         if (ret != MS_MEDIA_ERR_NONE)
 144                 return MS_MEDIA_ERR_SOCKET_CONN;
 145
 146         /* send ready message */
 147         memset(&send_msg, 0x0, sizeof(ms_comm_msg_s));
 148         send_msg.msg_type = MS_MSG_SCANNER_BULK_RESULT;
 149         send_msg.pid = reg_data->pid;
 150         send_msg.result = result;
 151         send_msg.msg_size = reg_data->msg_size;
 152         strncpy(send_msg.msg, reg_data->msg, send_msg.msg_size);
 153
 154         ret = ms_ipc_send_msg_to_server(sockfd, MS_SCAN_COMM_PORT, &send_msg, NULL);
 155
 156         close(sockfd);
 157
 158         return ret;
 159 }
 160
 161 int msc_send_ready(void)
 162 {
 163         int ret;
 164         int res = MS_MEDIA_ERR_NONE;
 165         int sockfd = -1;
 166         ms_comm_msg_s send_msg;
 167
 168         /*Create Socket*/
 169         ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
 170         if (ret != MS_MEDIA_ERR_NONE)
 171                 return MS_MEDIA_ERR_SOCKET_CONN;
 172
 173         /* send ready message */
 174         memset(&send_msg, 0, sizeof(send_msg));
 175         send_msg.msg_type = MS_MSG_SCANNER_READY;
 176
 177         ret = ms_ipc_send_msg_to_server(sockfd, MS_SCAN_COMM_PORT, &send_msg, NULL);
 178         if (ret != MS_MEDIA_ERR_NONE)
 179                 res = ret;
 180
 181         close(sockfd);
 182
 183         return res;
 184 }
 185