src/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 #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.h"
  33 #include "media-scanner-socket.h"
  34 #include "media-scanner-scan.h"
  35
  36 gboolean msc_receive_request(GIOChannel *src, GIOCondition condition, gpointer data)
  37 {
  38         ms_comm_msg_s *recv_msg = NULL;
  39         int sockfd = MS_SOCK_NOT_ALLOCATE;
  40         int err = -1;
  41
  42         MS_DBG_RETVM_IF(!src, G_SOURCE_CONTINUE, "src is invalid");
  43
  44         sockfd = g_io_channel_unix_get_fd(src);
  45         MS_DBG_RETVM_IF(sockfd < 0, G_SOURCE_CONTINUE, "sock fd is invalid!");
  46
  47         recv_msg = g_new0(ms_comm_msg_s, 1);
  48
  49         /* read() is blocked until media scanner sends message */
  50         err = read(sockfd, recv_msg, sizeof(ms_comm_msg_s));
  51         if (err < 0) {
  52                 MS_DBG_STRERROR("fifo read failed");
  53                 g_free(recv_msg);
  54                 return G_SOURCE_CONTINUE;
  55         }
  56
  57         if (strlen(recv_msg->msg) == 0 || strlen(recv_msg->msg) >= MAX_MSG_SIZE) {
  58                 MS_DBG_ERR("msg size is invalid");
  59                 g_free(recv_msg);
  60                 return G_SOURCE_CONTINUE;
  61         }
  62
  63         if (strlen(recv_msg->storage_id) >= MS_UUID_SIZE) {
  64                 MS_DBG_ERR("storage_id size is invalid");
  65                 g_free(recv_msg);
  66                 return G_SOURCE_CONTINUE;
  67         }
  68
  69         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);
  70
  71         switch (recv_msg->msg_type) {
  72         case MS_MSG_BULK_INSERT:
  73                 msc_push_scan_request(MS_SCAN_REGISTER, recv_msg);
  74                 break;
  75         case MS_MSG_DIRECTORY_SCANNING:
  76         case MS_MSG_DIRECTORY_SCANNING_NON_RECURSIVE:
  77                 msc_push_scan_request(MS_SCAN_DIRECTORY, recv_msg);
  78                 break;
  79         case MS_MSG_STORAGE_ALL:
  80         case MS_MSG_STORAGE_PARTIAL:
  81         case MS_MSG_STORAGE_INVALID:
  82                 msc_push_scan_request(MS_SCAN_STORAGE, recv_msg);
  83                 break;
  84         case MS_MSG_DIRECTORY_SCANNING_CANCEL:
  85                 msc_remove_dir_scan_request(recv_msg);
  86                 g_free(recv_msg);
  87                 break;
  88         case MS_MSG_STORAGE_META:
  89                 msc_metadata_update_thread(recv_msg);
  90                 break;
  91         default:
  92                 MS_DBG_ERR("THIS REQUEST IS INVALID %d", recv_msg->msg_type);
  93                 g_free(recv_msg);
  94                 break;
  95         }
  96
  97         /*Active flush */
  98         malloc_trim(0);
  99
 100         return G_SOURCE_CONTINUE;
 101 }
 102
 103 int msc_send_ready(void)
 104 {
 105         int ret = MS_MEDIA_ERR_NONE;
 106         ms_comm_msg_s send_msg;
 107         int fd = -1;
 108
 109         fd = open(MS_SCANNER_FIFO_PATH_RES, O_WRONLY);
 110         MS_DBG_RETVM_IF(fd < 0, MS_MEDIA_ERR_INTERNAL, "fifo open failed");
 111
 112         /* send ready message */
 113         memset(&send_msg, 0, sizeof(send_msg));
 114         send_msg.msg_type = MS_MSG_SCANNER_READY;
 115
 116         /* send ready message */
 117         if (write(fd, &send_msg, sizeof(send_msg)) < 0) {
 118                 MS_DBG_STRERROR("fifo write failed");
 119                 ret = MS_MEDIA_ERR_INTERNAL;
 120         }
 121
 122         close(fd);
 123
 124         return ret;
 125 }
 126
 127 int msc_send_result(int result, ms_comm_msg_s *res_data)
 128 {
 129         int ret = MS_MEDIA_ERR_NONE;
 130         ms_comm_msg_s send_msg;
 131         int fd = -1;
 132
 133         fd = open(MS_SCANNER_FIFO_PATH_RES, O_WRONLY);
 134         MS_DBG_RETVM_IF(fd < 0, MS_MEDIA_ERR_INTERNAL, "fifo open failed");
 135
 136         /* send result message */
 137         memset(&send_msg, 0x0, sizeof(ms_comm_msg_s));
 138         send_msg.msg_type = MS_MSG_SCANNER_BULK_RESULT;
 139         send_msg.pid = res_data->pid;
 140         send_msg.result = result;
 141         send_msg.uid = res_data->uid;
 142         SAFE_STRLCPY(send_msg.msg, res_data->msg, sizeof(send_msg.msg));
 143
 144         /* send ready message */
 145         if (write(fd, &send_msg, sizeof(send_msg)) < 0) {
 146                 MS_DBG_STRERROR("fifo write failed");
 147                 ret = MS_MEDIA_ERR_INTERNAL;
 148         }
 149
 150         close(fd);
 151
 152         return ret;
 153 }
 154