server/thumb-server-internal.c

   1 /*
   2  * media-thumbnail-server
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Hyunjun Ko <zzoon.ko@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 "thumb-server-internal.h"
  23 #include "media-thumb-util.h"
  24 #include "media-thumb-debug.h"
  25
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28 #include <dirent.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <tzplatform_config.h>
  32
  33 #ifdef LOG_TAG
  34 #undef LOG_TAG
  35 #endif
  36
  37 #define LOG_TAG "MEDIA_THUMBNAIL_SERVER"
  38 #define THUMB_DEFAULT_WIDTH 320
  39 #define THUMB_DEFAULT_HEIGHT 240
  40 #define THUMB_COMM_SOCK_PATH tzplatform_mkpath(TZ_SYS_RUN, "media-server/media_ipc_thumbcomm.socket")
  41 #define THUMB_EMPTY_STR ""
  42
  43 static int __thumbnail_get_data(const char *origin_path, char *thumb_path)
  44 {
  45         int err = MS_MEDIA_ERR_NONE;
  46         int file_type = THUMB_NONE_TYPE;
  47
  48         thumb_retvm_if(!origin_path, MS_MEDIA_ERR_INVALID_PARAMETER, "Original path is null");
  49         thumb_retvm_if(!g_file_test(origin_path, G_FILE_TEST_IS_REGULAR), MS_MEDIA_ERR_INVALID_PARAMETER, "Original path(%s) does not exist", origin_path);
  50         thumb_dbg("Origin path : %s", origin_path);
  51
  52         file_type = _media_thumb_get_file_type(origin_path);
  53
  54         if (file_type == THUMB_IMAGE_TYPE) {
  55                 err = _media_thumb_image(origin_path, thumb_path, THUMB_DEFAULT_WIDTH, THUMB_DEFAULT_HEIGHT, NULL);
  56                 thumb_retvm_if(err != MS_MEDIA_ERR_NONE, err, "_media_thumb_image failed");
  57         } else if (file_type == THUMB_VIDEO_TYPE) {
  58                 err = _media_thumb_video(origin_path, thumb_path, THUMB_DEFAULT_WIDTH, THUMB_DEFAULT_HEIGHT, NULL);
  59                 thumb_retvm_if(err != MS_MEDIA_ERR_NONE, err, "_media_thumb_video failed");
  60         } else {
  61                 thumb_err("invalid file type");
  62                 return MS_MEDIA_ERR_THUMB_UNSUPPORTED;
  63         }
  64
  65         thumb_dbg("Thumb data is generated successfully");
  66
  67         return MS_MEDIA_ERR_NONE;
  68 }
  69
  70 static int __thumbnail_get_raw_data(const char *origin_path, unsigned int *width, unsigned int *height, unsigned char **data, size_t *size)
  71 {
  72         int err = MS_MEDIA_ERR_NONE;
  73         unsigned int thumb_width = 0;
  74         unsigned int thumb_height = 0;
  75
  76         if (origin_path == NULL || *width == 0 || *height == 0) {
  77                 thumb_err("Invalid parameter");
  78                 return MS_MEDIA_ERR_INVALID_PARAMETER;
  79         }
  80
  81         if (!g_file_test(origin_path, G_FILE_TEST_IS_REGULAR)) {
  82                 thumb_err("Original path (%s) does not exist", origin_path);
  83                 return MS_MEDIA_ERR_INVALID_PARAMETER;
  84         }
  85
  86         int file_type = THUMB_NONE_TYPE;
  87         media_thumb_info thumb_info = {0,};
  88         file_type = _media_thumb_get_file_type(origin_path);
  89         thumb_width = *width;
  90         thumb_height = *height;
  91
  92         if (file_type == THUMB_IMAGE_TYPE) {
  93                 err = _media_thumb_image(origin_path, NULL, thumb_width, thumb_height, &thumb_info);
  94                 thumb_retvm_if(err != MS_MEDIA_ERR_NONE, err, "_media_thumb_image failed");
  95         } else if (file_type == THUMB_VIDEO_TYPE) {
  96                 err = _media_thumb_video(origin_path, NULL, thumb_width, thumb_height, &thumb_info);
  97                 thumb_retvm_if(err != MS_MEDIA_ERR_NONE, err, "_media_thumb_video failed");
  98         } else {
  99                 thumb_err("invalid file type");
 100                 return MS_MEDIA_ERR_THUMB_UNSUPPORTED;
 101         }
 102
 103         if (size) *size = thumb_info.size;
 104         *data = thumb_info.data;
 105         *width = thumb_info.width;
 106         *height = thumb_info.height;
 107
 108         return MS_MEDIA_ERR_NONE;
 109 }
 110
 111 static int __media_thumb_process(thumbMsg *req_msg, thumbMsg *res_msg)
 112 {
 113         int err = MS_MEDIA_ERR_NONE;
 114
 115         thumb_retvm_if(!req_msg || !res_msg, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid msg");
 116
 117         memset(res_msg->dst_path, 0, MAX_FILEPATH_LEN);
 118         res_msg->status = MS_MEDIA_ERR_NONE;
 119
 120         if (!g_file_test(req_msg->org_path, G_FILE_TEST_IS_REGULAR)) {
 121                 thumb_err("origin_path does not exist in file system.");
 122                 res_msg->status = MS_MEDIA_ERR_FILE_NOT_EXIST;
 123                 return MS_MEDIA_ERR_FILE_NOT_EXIST;
 124         }
 125
 126         err = _media_thumb_get_thumb_from_db(req_msg->org_path, res_msg->dst_path, MAX_FILEPATH_LEN, req_msg->uid);
 127         thumb_retvm_if(err == MS_MEDIA_ERR_NONE, err, "Already exists");
 128         if (strlen(res_msg->dst_path) == 0) {
 129                 err = _media_thumb_get_hash_name(req_msg->org_path, res_msg->dst_path, MAX_FILEPATH_LEN, req_msg->uid);
 130                 if (err != MS_MEDIA_ERR_NONE) {
 131                         thumb_err("_media_thumb_get_hash_name failed - %d", err);
 132                         SAFE_STRLCPY(res_msg->dst_path, THUMB_EMPTY_STR, MAX_FILEPATH_LEN);
 133                         res_msg->status = err;
 134                         return err;
 135                 }
 136         }
 137
 138         thumb_dbg_slog("Thumb path : %s", res_msg->dst_path);
 139
 140         err = __thumbnail_get_data(req_msg->org_path, res_msg->dst_path);
 141         if (err != MS_MEDIA_ERR_NONE) {
 142                 thumb_err("_thumbnail_get_data failed - %d", err);
 143                 SAFE_STRLCPY(res_msg->dst_path, THUMB_EMPTY_STR, MAX_FILEPATH_LEN);
 144                 res_msg->status = err;
 145
 146                 goto DB_UPDATE;
 147         }
 148
 149         res_msg->msg_type = THUMB_RESPONSE;
 150
 151 DB_UPDATE:
 152         err = _media_thumb_update_db(req_msg->org_path, res_msg->dst_path, req_msg->uid);
 153         if (err != MS_MEDIA_ERR_NONE) {
 154                 thumb_err("_media_thumb_update_db failed : %d", err);
 155                 res_msg->status = err;
 156         }
 157
 158         return err;
 159 }
 160
 161 static int __media_thumb_process_raw(thumbMsg *req_msg, thumbMsg *res_msg)
 162 {
 163         int err = MS_MEDIA_ERR_NONE;
 164         unsigned char *data = NULL;
 165         size_t thumb_size = 0;
 166         unsigned int thumb_w = 0;
 167         unsigned int thumb_h = 0;
 168
 169         thumb_retvm_if(!req_msg || !res_msg, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid msg");
 170
 171         thumb_w = (req_msg->thumb_width > 0) ? req_msg->thumb_width : THUMB_DEFAULT_WIDTH;
 172         thumb_h = (req_msg->thumb_height > 0) ? req_msg->thumb_height : THUMB_DEFAULT_HEIGHT;
 173
 174         res_msg->status = MS_MEDIA_ERR_NONE;
 175         res_msg->msg_type = THUMB_RESPONSE_RAW_DATA;
 176
 177         err = __thumbnail_get_raw_data(req_msg->org_path, &thumb_w, &thumb_h, &data, &thumb_size);
 178         if (err != MS_MEDIA_ERR_NONE) {
 179                 thumb_err("_thumbnail_get_data failed - %d", err);
 180                 res_msg->status = err;
 181                 res_msg->thumb_size = 0;
 182                 goto ERROR;
 183         }
 184
 185         res_msg->thumb_width = thumb_w;
 186         res_msg->thumb_height = thumb_h;
 187         res_msg->thumb_size = thumb_size;
 188         res_msg->thumb_data = malloc(thumb_size * sizeof(unsigned char));
 189         if (res_msg->thumb_data) {
 190                 memcpy(res_msg->thumb_data, data, thumb_size);
 191         } else {
 192                 thumb_err("Allocation failed");
 193                 err = MS_MEDIA_ERR_OUT_OF_MEMORY;
 194         }
 195
 196 ERROR:
 197         SAFE_FREE(data);
 198
 199         return err;
 200 }
 201
 202 static int __thumb_daemon_process_job(thumbMsg *req_msg, thumbMsg *res_msg)
 203 {
 204         int err = MS_MEDIA_ERR_NONE;
 205
 206         if (req_msg->msg_type == THUMB_REQUEST_RAW_DATA) {
 207                 err = __media_thumb_process_raw(req_msg, res_msg);
 208                 if (err != MS_MEDIA_ERR_NONE)
 209                         thumb_err("_media_thumb_process_raw is failed: %d", err);
 210         } else if (req_msg->msg_type == THUMB_REQUEST_DB_INSERT) {
 211                 err = __media_thumb_process(req_msg, res_msg);
 212                 if (err != MS_MEDIA_ERR_NONE)
 213                         thumb_err("_media_thumb_process is failed: %d", err);
 214         }
 215
 216         return err;
 217 }
 218
 219 static void __thumb_server_send_deny_message(int sockfd)
 220 {
 221         thumbMsg msg = {0};
 222
 223         msg.msg_type = THUMB_RESPONSE;
 224         msg.status = MS_MEDIA_ERR_PERMISSION_DENIED;
 225
 226         if (send(sockfd, &msg, sizeof(msg), 0) < 0)
 227                 thumb_stderror("send failed");
 228 }
 229
 230 gboolean _thumb_daemon_start_jobs(gpointer data)
 231 {
 232         int client_sock;
 233         struct sockaddr_un serv_addr;
 234         ms_thumb_server_msg send_msg;
 235
 236         if (ms_ipc_create_client_socket(MS_TIMEOUT_SEC_10, &client_sock) < 0) {
 237                 thumb_err("ms_ipc_create_server_socket failed");
 238                 return G_SOURCE_REMOVE;
 239         }
 240
 241         memset(&serv_addr, 0, sizeof(serv_addr));
 242
 243         serv_addr.sun_family = AF_UNIX;
 244         SAFE_STRLCPY(serv_addr.sun_path, THUMB_COMM_SOCK_PATH, sizeof(serv_addr.sun_path));
 245
 246         /* Connecting to the thumbnail server */
 247         if (connect(client_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
 248                 thumb_stderror("connect");
 249                 goto ERROR;
 250         }
 251
 252         send_msg.msg_type = MS_MSG_THUMB_SERVER_READY;
 253
 254         if (send(client_sock, &send_msg, sizeof(ms_thumb_server_msg), 0) < 0) {
 255                 thumb_stderror("send failed");
 256                 goto ERROR;
 257         }
 258
 259         thumb_dbg("Sending msg to thumbnail agent[%d] is successful", send_msg.msg_type);
 260 ERROR:
 261         close(client_sock);
 262
 263         return G_SOURCE_REMOVE;
 264 }
 265
 266 gboolean _thumb_server_read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
 267 {
 268         struct sockaddr_un client_addr;
 269         unsigned int client_addr_len;
 270         thumbMsg recv_msg;
 271         thumbMsg res_msg;
 272         ms_peer_credentials credentials;
 273         GMainLoop *thumb_server = (GMainLoop *)data;
 274
 275         int sock = -1;
 276         int client_sock = -1;
 277
 278         int buf_size = 0;
 279         int send_len = 0;
 280         int send_pos = 0;
 281         unsigned char *buf = NULL;
 282
 283         memset((void *)&recv_msg, 0, sizeof(recv_msg));
 284         memset((void *)&res_msg, 0, sizeof(res_msg));
 285         memset((void *)&credentials, 0, sizeof(credentials));
 286
 287         sock = g_io_channel_unix_get_fd(src);
 288         thumb_retvm_if(sock < 0, G_SOURCE_CONTINUE, "sock fd is invalid!");
 289
 290         client_addr_len = sizeof(client_addr);
 291
 292         if ((client_sock = accept(sock, (struct sockaddr*)&client_addr, &client_addr_len)) < 0) {
 293                 thumb_stderror("accept failed");
 294                 return G_SOURCE_CONTINUE;
 295         }
 296
 297         if (ms_cynara_receive_untrusted_message_thumb(client_sock, &recv_msg, &credentials) != MS_MEDIA_ERR_NONE) {
 298                 thumb_err("ms_cynara_receive_untrusted_message_thumb failed");
 299                 goto ERROR;
 300         }
 301
 302         if (recv_msg.msg_type != THUMB_REQUEST_KILL_SERVER) {
 303                 if (ms_cynara_check(&credentials, MEDIA_STORAGE_PRIVILEGE) != MS_MEDIA_ERR_NONE) {
 304                         thumb_err("Cynara denied access to process request");
 305                         __thumb_server_send_deny_message(client_sock);
 306                         goto ERROR;
 307                 }
 308         } else {
 309                 thumb_warn("Shutting down...");
 310                 g_main_loop_quit(thumb_server);
 311                 goto ERROR;
 312         }
 313
 314         SAFE_FREE(credentials.smack);
 315         SAFE_FREE(credentials.uid);
 316
 317         thumb_warn_slog("Received [%d] %.*s(%zu) from PID(%d)", recv_msg.msg_type, MAX_FILEPATH_LEN, recv_msg.org_path, strlen(recv_msg.org_path), recv_msg.pid);
 318
 319         __thumb_daemon_process_job(&recv_msg, &res_msg);
 320
 321         if (res_msg.msg_type == 0)
 322                 res_msg.msg_type = recv_msg.msg_type;
 323         res_msg.request_id = recv_msg.request_id;
 324         SAFE_STRLCPY(res_msg.org_path, recv_msg.org_path, sizeof(res_msg.org_path));
 325         if (res_msg.msg_type != THUMB_RESPONSE_RAW_DATA)
 326                 res_msg.thumb_size = 0;
 327         else
 328                 res_msg.dst_path[0] = '\0';
 329
 330         _media_thumb_set_buffer(&res_msg, &buf, &buf_size);
 331
 332         while (buf_size > 0) {
 333                 if ((send_len = send(client_sock, buf + send_pos, buf_size, 0)) < 0) {
 334                         thumb_stderror("send failed");
 335                         break;
 336                 }
 337                 send_pos += send_len;
 338                 buf_size -= send_len;
 339         }
 340
 341         SAFE_FREE(buf);
 342         SAFE_FREE(res_msg.thumb_data);
 343
 344 ERROR:
 345         close(client_sock);
 346
 347         return G_SOURCE_CONTINUE;
 348 }
 349
 350 gboolean _thumb_server_prepare_socket(int *sock_fd)
 351 {
 352         int sock;
 353
 354         if (ms_ipc_create_server_socket(MS_THUMB_DAEMON_PORT, &sock) < 0) {
 355                 thumb_err("ms_ipc_create_server_socket failed");
 356                 return FALSE;
 357         }
 358
 359         if (ms_cynara_enable_credentials_passing(sock) != MS_MEDIA_ERR_NONE) {
 360                 thumb_err("ms_cynara_enable_credentials_passing failed");
 361                 close(sock);
 362                 return FALSE;
 363         }
 364
 365         *sock_fd = sock;
 366
 367         return TRUE;
 368 }