src/scanner-v2/media-scanner-socket-v2.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 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <fcntl.h>
  25 #include <malloc.h>
  26
  27 #include "media-util.h"
  28 #include "media-server-ipc.h"
  29 #include "media-common-types.h"
  30 #include "media-common-utils.h"
  31 #include "media-common-db-svc.h"
  32 #include "media-scanner-dbg-v2.h"
  33 #include "media-scanner-scan-v2.h"
  34 #include "media-scanner-socket-v2.h"
  35 #include "media-scanner-extract-v2.h"
  36 #define SUPPORT_PARTIAL_EVENT
  37
  38 extern GAsyncQueue *storage_queue2;
  39 extern GAsyncQueue *scan_queue2;
  40 extern GAsyncQueue *reg_queue2;
  41 extern GMutex scan_req_mutex2;
  42 extern GAsyncQueue *folder_extract_queue;
  43 extern int g_directory_scan_processing2;
  44
  45 static void __msc_remove_request(GAsyncQueue *req_queue, ms_comm_msg_s *recv_msg)
  46 {
  47         char *cancel_path = recv_msg->msg;
  48         int pid = recv_msg->pid;
  49         int i = 0;
  50         int len = g_async_queue_length(req_queue);
  51         ms_comm_msg_s *msg = NULL;
  52         GAsyncQueue *temp_scan_queue = NULL;
  53
  54         MS_DBG_WARN("scan_req_mutex2 is LOCKED");
  55         g_mutex_lock(&scan_req_mutex2);
  56
  57         if (len <= 0 && g_directory_scan_processing2 == 0) {
  58                 MS_DBG_WARN("Request is not stacked[%d]", len);
  59                 goto END_REMOVE_REQUEST;
  60         }
  61
  62         MS_DBG_WARN("len == [%d] pid=[%d], cancel_path[%s]", len, pid, cancel_path);
  63
  64         msc_set_cancel_scan_item(recv_msg->msg, recv_msg->pid);
  65
  66         if (len > 0) {
  67                 temp_scan_queue = g_async_queue_new();
  68
  69                 MS_DBG_WARN("start update scan_queue2");
  70                 for (i = 0; i < len; i++) {
  71                         /*create new queue to compare request*/
  72                         msg = g_async_queue_pop(scan_queue2);
  73                         MS_DBG_WARN("msg->msg[%.*s], msg->pid[%d]", MAX_MSG_SIZE, msg->msg, msg->pid);
  74                         if ((strcmp(msg->msg, cancel_path) == 0) && (pid == msg->pid)) {
  75                                 msg->msg_type = MS_MSG_DIRECTORY_SCANNING_CANCEL;
  76                                 msc_send_result(MS_MEDIA_ERR_SCANNER_FORCE_STOP, msg);
  77                                 g_free(msg);
  78                         } else {
  79                                 g_async_queue_push(temp_scan_queue, msg);
  80                         }
  81                 }
  82
  83                 len = g_async_queue_length(temp_scan_queue);
  84                 int j = 0;
  85                 for (; j < len; j++) {
  86                         msg = g_async_queue_pop(temp_scan_queue);
  87                         if (msg)
  88                                 g_async_queue_push(scan_queue2, msg);
  89                 }
  90                 g_async_queue_unref(temp_scan_queue);
  91                 MS_DBG_WARN("end update scan_queue2");
  92         }
  93
  94 END_REMOVE_REQUEST:
  95         {
  96                 msc_set_cancel_extract_item(recv_msg->msg, recv_msg->pid);
  97                 GAsyncQueue *temp_extract_queue = NULL;
  98                 int len_extract = g_async_queue_length(folder_extract_queue);
  99                 MS_DBG_WARN("len [%d]", len_extract);
 100
 101                 if (len_extract > 0) {
 102                         temp_extract_queue = g_async_queue_new();
 103                         MS_DBG_WARN("start update folder_extract_queue");
 104                         for (i = 0; i < len_extract; i++) {
 105                                 /*create new queue to compare request*/
 106                                 msg = g_async_queue_pop(folder_extract_queue);
 107                                 if ((strcmp(msg->msg, cancel_path) == 0) && (pid == msg->pid)) {
 108                                         MS_DBG_WARN("cancel path [%s]", cancel_path);
 109                                         if (msg->result) {
 110                                                 msg->msg_type = MS_MSG_DIRECTORY_SCANNING_CANCEL;
 111                                                 msc_send_result(MS_MEDIA_ERR_SCANNER_FORCE_STOP, msg);
 112                                         }
 113                                         g_free(msg);
 114                                 } else {
 115                                         g_async_queue_push(temp_extract_queue, msg);
 116                                 }
 117                         }
 118
 119                         len = g_async_queue_length(temp_extract_queue);
 120                         int j = 0;
 121                         for (; j < len; j++) {
 122                                 msg = g_async_queue_pop(temp_extract_queue);
 123                                 if (msg)
 124                                         g_async_queue_push(folder_extract_queue, msg);
 125                         }
 126                         g_async_queue_unref(temp_extract_queue);
 127                         MS_DBG_WARN("end update folder_extract_queue");
 128                 }
 129         }
 130
 131         g_mutex_unlock(&scan_req_mutex2);
 132         MS_DBG_WARN("scan_req_mutex2 is UNLOCKED");
 133 }
 134
 135 gboolean msc_receive_request(GIOChannel *src, GIOCondition condition, gpointer data)
 136 {
 137         ms_comm_msg_s *recv_msg = NULL;
 138         int sockfd = MS_SOCK_NOT_ALLOCATE;
 139         int req_num = MS_MSG_MAX;
 140         int err = -1;
 141
 142         sockfd = g_io_channel_unix_get_fd(src);
 143         if (sockfd < 0) {
 144                 MS_DBG_ERR("sock fd is invalid!");
 145                 return G_SOURCE_CONTINUE;
 146         }
 147
 148         recv_msg = g_new0(ms_comm_msg_s, 1);
 149
 150         /* read() is blocked until media scanner sends message */
 151         err = read(sockfd, recv_msg, sizeof(ms_comm_msg_s));
 152         if (err < 0) {
 153                 MS_DBG_STRERROR("fifo read failed");
 154                 g_free(recv_msg);
 155                 return G_SOURCE_CONTINUE;
 156         }
 157
 158         if (strlen(recv_msg->msg) == 0 || strlen(recv_msg->msg) >= MAX_MSG_SIZE) {
 159                 MS_DBG_ERR("msg size is invalid");
 160                 g_free(recv_msg);
 161                 return G_SOURCE_CONTINUE;
 162         }
 163
 164         if (strlen(recv_msg->storage_id) >= MS_UUID_SIZE) {
 165                 MS_DBG_ERR("storage_id size is invalid");
 166                 g_free(recv_msg);
 167                 return G_SOURCE_CONTINUE;
 168         }
 169
 170         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);
 171
 172         /* copy from recived data */
 173         req_num = recv_msg->msg_type;
 174
 175         switch (req_num) {
 176         case MS_MSG_BULK_INSERT:
 177                 {
 178                         MS_DBG_INFO("BULK INSERT");
 179                         /* request bulk insert*/
 180                         g_async_queue_push(reg_queue2, recv_msg);
 181                 }
 182                 break;
 183         case MS_MSG_DIRECTORY_SCANNING:
 184         case MS_MSG_DIRECTORY_SCANNING_NON_RECURSIVE:
 185                 {
 186                         /* this request from another apps */
 187                         /* set the scan data for scanning thread */
 188                         g_async_queue_push(scan_queue2, recv_msg);
 189                 }
 190                 break;
 191         case MS_MSG_STORAGE_ALL:
 192         case MS_MSG_STORAGE_PARTIAL:
 193         case MS_MSG_STORAGE_INVALID:
 194                 {
 195                         /* this request from media-server */
 196                         g_async_queue_push(storage_queue2, recv_msg);
 197                 }
 198                 break;
 199         case MS_MSG_DIRECTORY_SCANNING_CANCEL:
 200                 {
 201                         __msc_remove_request(scan_queue2, recv_msg);
 202                         msc_send_result(MS_MEDIA_ERR_SCANNER_FORCE_STOP, recv_msg);
 203                         g_free(recv_msg);
 204                 }
 205                 break;
 206         default:
 207                 {
 208                         MS_DBG_ERR("THIS REQUEST IS INVALID %d", req_num);
 209                         g_free(recv_msg);
 210                 }
 211                 break;
 212         }
 213
 214         /*Active flush */
 215         malloc_trim(0);
 216
 217         return G_SOURCE_CONTINUE;
 218 }
 219
 220 int msc_send_ready(void)
 221 {
 222         int res = MS_MEDIA_ERR_NONE;
 223         ms_comm_msg_s send_msg;
 224         int fd = -1;
 225         int err = -1;
 226
 227         fd = open(MS_SCANNER_FIFO_PATH_RES, O_WRONLY);
 228         if (fd < 0) {
 229                 MS_DBG_STRERROR("fifo read failed");
 230                 return MS_MEDIA_ERR_INTERNAL;
 231         }
 232
 233         /* send ready message */
 234         memset(&send_msg, 0, sizeof(send_msg));
 235         send_msg.msg_type = MS_MSG_SCANNER_READY;
 236
 237         /* send ready message */
 238         err = write(fd, &send_msg, sizeof(send_msg));
 239         if (err < 0) {
 240                 MS_DBG_STRERROR("fifo write failed");
 241                 res = MS_MEDIA_ERR_INTERNAL;
 242         }
 243
 244         close(fd);
 245
 246         return res;
 247 }
 248
 249 int msc_send_result(int result, ms_comm_msg_s *res_data)
 250 {
 251         MS_DBG_SLOG("msc_send_result msg_type=%d", res_data->msg_type);
 252         int res = MS_MEDIA_ERR_NONE;
 253
 254         if (result == MS_MEDIA_ERR_SCANNER_FORCE_STOP) {
 255                 MS_DBG_WARN("msc_send_result -701 will not be sent");
 256                 return res;
 257         }
 258         ms_comm_msg_s send_msg;
 259         int fd = -1;
 260         int err = -1;
 261
 262         fd = open(MS_SCANNER_FIFO_PATH_RES, O_WRONLY);
 263         if (fd < 0) {
 264                 MS_DBG_STRERROR("fifo open failed");
 265                 return MS_MEDIA_ERR_INTERNAL;
 266         }
 267
 268         /* send result message */
 269         memset(&send_msg, 0x0, sizeof(ms_comm_msg_s));
 270         if (res_data->msg_type == MS_MSG_SCANNER_COMPLETE)
 271                 send_msg.msg_type = MS_MSG_SCANNER_COMPLETE;
 272         else if (res_data->msg_type == MS_MSG_EXTRACTOR_COMPLETE)
 273                 send_msg.msg_type = MS_MSG_EXTRACTOR_COMPLETE;
 274         else
 275                 send_msg.msg_type = MS_MSG_SCANNER_BULK_RESULT;
 276         send_msg.pid = res_data->pid;
 277         send_msg.result = result;
 278         SAFE_STRLCPY(send_msg.msg, res_data->msg, sizeof(send_msg.msg));
 279
 280         /* send ready message */
 281         err = write(fd, &send_msg, sizeof(send_msg));
 282         if (err < 0) {
 283                 MS_DBG_STRERROR("fifo write failed");
 284                 res = MS_MEDIA_ERR_INTERNAL;
 285         }
 286
 287         close(fd);
 288
 289         return res;
 290 }
 291
 292 /* define of  SUPPORT_PARTIAL_EVENT is disabled, send partial result will not be active */
 293 int msc_send_result_partial(int result, ms_msg_type_e msg_type, int pid, const char *msg)
 294 {
 295 #ifdef SUPPORT_PARTIAL_EVENT
 296         MS_DBG_SLOG("msc_send_result_partial %d,%d,%s", msg_type, pid, msg);
 297         int res = MS_MEDIA_ERR_NONE;
 298
 299         /*in case of request continuously with same pid and request path, cancel request force stop will be sent*/
 300         if (result == MS_MEDIA_ERR_SCANNER_FORCE_STOP) {
 301                 MS_DBG_WARN("msc_send_result_partial -701 will not be sent");
 302                 return res;
 303         }
 304         ms_comm_msg_s send_msg;
 305         int fd = -1;
 306         int err = -1;
 307
 308         fd = open(MS_SCANNER_FIFO_PATH_RES, O_WRONLY);
 309         if (fd < 0) {
 310                 MS_DBG_STRERROR("fifo open failed");
 311                 return MS_MEDIA_ERR_INTERNAL;
 312         }
 313
 314         /* send result message */
 315         memset(&send_msg, 0x0, sizeof(ms_comm_msg_s));
 316         send_msg.msg_type = msg_type;
 317         send_msg.pid = pid;
 318         send_msg.result = result;
 319         SAFE_STRLCPY(send_msg.msg, msg, sizeof(send_msg.msg));
 320
 321         /* send ready message */
 322         err = write(fd, &send_msg, sizeof(send_msg));
 323         if (err < 0) {
 324                 MS_DBG_STRERROR("fifo write failed");
 325                 res = MS_MEDIA_ERR_INTERNAL;
 326         }
 327
 328         close(fd);
 329
 330         return res;
 331 #else
 332         MS_DBG_SLOG("partial even not support!");
 333         return MS_MEDIA_ERR_NONE;
 334 #endif
 335 }
 336
 337