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
  24 #include <unistd.h>
  25 #include <dirent.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <vconf.h>
  29
  30 #ifdef LOG_TAG
  31 #undef LOG_TAG
  32 #endif
  33
  34 #define LOG_TAG "MEDIA_THUMBNAIL_SERVER"
  35
  36 static __thread char **arr_path;
  37 static __thread uid_t *arr_uid;
  38 static __thread int g_idx = 0;
  39 static __thread int g_cur_idx = 0;
  40
  41 GMainLoop *g_thumb_server_mainloop; // defined in thumb-server.c as extern
  42
  43 #ifdef _USE_MEDIA_UTIL_
  44 gboolean _thumb_server_send_msg_to_agent(int msg_type);
  45 #endif
  46 void _thumb_daemon_stop_job();
  47
  48 gboolean _thumb_daemon_start_jobs(gpointer data)
  49 {
  50         thumb_dbg("");
  51
  52 #ifdef _USE_MEDIA_UTIL_
  53         _thumb_server_send_msg_to_agent(MS_MSG_THUMB_SERVER_READY);
  54 #endif
  55         return FALSE;
  56 }
  57
  58 void _thumb_daemon_finish_jobs()
  59 {
  60         sqlite3 *sqlite_db_handle = _media_thumb_db_get_handle();
  61
  62         if (sqlite_db_handle != NULL) {
  63                 _media_thumb_db_disconnect();
  64                 thumb_dbg("sqlite3 handle is alive. So disconnect to sqlite3");
  65         }
  66
  67         g_main_loop_quit(g_thumb_server_mainloop);
  68
  69         return;
  70 }
  71
  72 int _thumb_daemon_mmc_status()
  73 {
  74         int err = -1;
  75         int status = -1;
  76
  77         err = vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &status);
  78         if (err == 0) {
  79                 return status;
  80         } else if (err == -1) {
  81                 thumb_err("vconf_get_int failed : %d", err);
  82         } else {
  83                 thumb_err("vconf_get_int Unexpected error code: %d", err);
  84         }
  85
  86         return status;
  87 }
  88
  89 void _thumb_daemon_mmc_eject_vconf_cb(void *data)
  90 {
  91         int err = -1;
  92         int status = 0;
  93
  94         thumb_warn("_thumb_daemon_vconf_cb called");
  95
  96         err = vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &status);
  97         if (err == 0) {
  98                 if (status == VCONFKEY_SYSMAN_MMC_REMOVED || status == VCONFKEY_SYSMAN_MMC_INSERTED_NOT_MOUNTED) {
  99                         thumb_warn("SD card is ejected or not mounted. So media-thumbnail-server stops jobs to extract all thumbnails");
 100
 101                         _thumb_daemon_stop_job();
 102                 }
 103         } else if (err == -1) {
 104                 thumb_err("vconf_get_int failed : %d", err);
 105         } else {
 106                 thumb_err("vconf_get_int Unexpected error code: %d", err);
 107         }
 108
 109         return;
 110 }
 111
 112 void _thumb_daemon_vconf_cb(void *data)
 113 {
 114         int err = -1;
 115         int status = 0;
 116
 117         thumb_warn("_thumb_daemon_vconf_cb called");
 118
 119         err = vconf_get_int(VCONFKEY_SYSMAN_MMC_FORMAT, &status);
 120         if (err == 0) {
 121                 if (status == VCONFKEY_SYSMAN_MMC_FORMAT_COMPLETED) {
 122                         thumb_warn("SD card format is completed. So media-thumbnail-server stops jobs to extract all thumbnails");
 123
 124                         _thumb_daemon_stop_job();
 125                 } else {
 126                         thumb_dbg("not completed");
 127                 }
 128         } else if (err == -1) {
 129                 thumb_err("vconf_get_int failed : %d", err);
 130         } else {
 131                 thumb_err("vconf_get_int Unexpected error code: %d", err);
 132         }
 133
 134         return;
 135 }
 136
 137 void _thumb_daemon_stop_job()
 138 {
 139         int i = 0;
 140         char *path = NULL;
 141
 142         thumb_warn("There are %d jobs in the queue. But all jobs will be stopped", g_idx - g_cur_idx);
 143
 144         for (i = g_cur_idx; i < g_idx; i++) {
 145                 path = arr_path[g_cur_idx++];
 146                 SAFE_FREE(path);
 147         }
 148
 149         return;
 150 }
 151
 152 int _thumb_daemon_process_job(thumbMsg *req_msg, thumbMsg *res_msg, uid_t uid)
 153 {
 154         int err = -1;
 155
 156         err = _media_thumb_process(req_msg, res_msg, uid);
 157         if (err < 0) {
 158                 if (req_msg->msg_type == THUMB_REQUEST_SAVE_FILE) {
 159                         thumb_err("_media_thumb_process is failed: %d", err);
 160                         res_msg->status = THUMB_FAIL;
 161                 } else {
 162                         thumb_warn("_media_thumb_process is failed: %d, So use default thumb", err);
 163                         res_msg->status = THUMB_SUCCESS;
 164                 }
 165         } else {
 166                 res_msg->status = THUMB_SUCCESS;
 167         }
 168
 169         return err;
 170 }
 171
 172 int _thumb_daemon_all_extract(uid_t uid)
 173 {
 174         int err = -1;
 175         int count = 0;
 176         char query_string[MAX_PATH_SIZE + 1] = { 0, };
 177         char path[MAX_PATH_SIZE + 1] = { 0, };
 178         sqlite3 *sqlite_db_handle = NULL;
 179         sqlite3_stmt *sqlite_stmt = NULL;
 180
 181         err = _media_thumb_db_connect(uid);
 182         if (err < 0) {
 183                 thumb_err("_media_thumb_db_connect failed: %d", err);
 184                 return MEDIA_THUMB_ERROR_DB;
 185         }
 186
 187         sqlite_db_handle = _media_thumb_db_get_handle();
 188         if (sqlite_db_handle == NULL) {
 189                 thumb_err("sqlite handle is NULL");
 190                 return MEDIA_THUMB_ERROR_DB;
 191         }
 192
 193         if (_thumb_daemon_mmc_status() == VCONFKEY_SYSMAN_MMC_MOUNTED) {
 194                 snprintf(query_string, sizeof(query_string), SELECT_PATH_FROM_UNEXTRACTED_THUMB_MEDIA);
 195         } else {
 196                 snprintf(query_string, sizeof(query_string), SELECT_PATH_FROM_UNEXTRACTED_THUMB_INTERNAL_MEDIA);
 197         }
 198
 199         thumb_warn("Query: %s", query_string);
 200
 201         err = sqlite3_prepare_v2(sqlite_db_handle, query_string, strlen(query_string), &sqlite_stmt, NULL);
 202         if (SQLITE_OK != err) {
 203                 thumb_err("prepare error [%s]\n", sqlite3_errmsg(sqlite_db_handle));
 204                 _media_thumb_db_disconnect();
 205                 return MEDIA_THUMB_ERROR_DB;
 206         }
 207
 208         while(1) {
 209                 err = sqlite3_step(sqlite_stmt);
 210                 if (err != SQLITE_ROW) {
 211                         thumb_dbg("end of row [%s]\n", sqlite3_errmsg(sqlite_db_handle));
 212                         break;
 213                 }
 214
 215                 strncpy(path, (const char *)sqlite3_column_text(sqlite_stmt, 0), sizeof(path));
 216                 path[sizeof(path) - 1] = '\0';
 217                 count = sqlite3_column_int(sqlite_stmt, 1);
 218
 219                 thumb_dbg("Path : %s", path);
 220
 221                 if (g_idx == 0) {
 222                         arr_path = (char**)malloc(sizeof(char*));
 223                         arr_uid = (uid_t*)malloc(sizeof(uid_t));
 224                 } else {
 225                         arr_path = (char**)realloc(arr_path, (g_idx + 1) * sizeof(char*));
 226                         arr_uid = (uid_t*)realloc(arr_uid, (g_idx + 1) * sizeof(uid_t));
 227                 }
 228                 arr_uid[g_idx] = uid;
 229                 arr_path[g_idx++] = strdup(path);
 230         }
 231
 232         sqlite3_finalize(sqlite_stmt);
 233         _media_thumb_db_disconnect();
 234
 235         return MEDIA_THUMB_ERROR_NONE;
 236 }
 237
 238 int _thumb_daemon_process_queue_jobs(gpointer data)
 239 {
 240         int err = -1;
 241         char *path = NULL;
 242         uid_t uid = NULL;
 243
 244         if (g_cur_idx < g_idx) {
 245                 thumb_dbg("There are %d jobs in the queue", g_idx - g_cur_idx);
 246                 thumb_dbg("Current idx : [%d]", g_cur_idx);
 247                 uid = arr_uid[g_cur_idx];
 248                 path = arr_path[g_cur_idx++];
 249
 250                 thumbMsg recv_msg, res_msg;
 251                 memset(&recv_msg, 0x00, sizeof(thumbMsg));
 252                 memset(&res_msg, 0x00, sizeof(thumbMsg));
 253
 254                 recv_msg.msg_type = THUMB_REQUEST_DB_INSERT;
 255                 recv_msg.thumb_type = MEDIA_THUMB_LARGE;
 256                 strncpy(recv_msg.org_path, path, sizeof(recv_msg.org_path));
 257                 recv_msg.org_path[sizeof(recv_msg.org_path) - 1] = '\0';
 258
 259                 _thumb_daemon_process_job(&recv_msg, &res_msg,uid );
 260
 261                 if (res_msg.status == THUMB_SUCCESS) {
 262
 263                         err = _media_thumb_db_connect(uid);
 264                         if (err < 0) {
 265                                 thumb_err("_media_thumb_mb_svc_connect failed: %d", err);
 266                                 return TRUE;
 267                         }
 268
 269                         /* Need to update DB once generating thumb is done */
 270                         err = _media_thumb_update_db(recv_msg.org_path,
 271                                                                                 res_msg.dst_path,
 272                                                                                 res_msg.origin_width,
 273                                                                                 res_msg.origin_height,
 274                                                                                 uid);
 275                         if (err < 0) {
 276                                 thumb_err("_media_thumb_update_db failed : %d", err);
 277                         }
 278
 279                         _media_thumb_db_disconnect();
 280                 }
 281
 282                 SAFE_FREE(path);
 283         } else {
 284                 g_cur_idx = 0;
 285                 g_idx = 0;
 286                 thumb_warn("Deleting array");
 287                 SAFE_FREE(arr_path);
 288                 SAFE_FREE(arr_uid);
 289                 //_media_thumb_db_disconnect();
 290
 291                 _thumb_server_send_msg_to_agent(MS_MSG_THUMB_EXTRACT_ALL_DONE); // MS_MSG_THUMB_EXTRACT_ALL_DONE
 292
 293                 return FALSE;
 294         }
 295
 296         return TRUE;
 297 }
 298
 299 gboolean _thumb_server_read_socket(GIOChannel *src,
 300                                                                         GIOCondition condition,
 301                                                                         gpointer data)
 302 {
 303 #ifdef _USE_UDS_SOCKET_
 304         struct sockaddr_un client_addr;
 305 #else
 306         struct sockaddr_in client_addr;
 307 #endif
 308         unsigned int client_addr_len;
 309 #ifndef _USE_MEDIA_UTIL_
 310         int client_sock;
 311 #endif
 312
 313         thumbMsg recv_msg;
 314         thumbMsg res_msg;
 315
 316         int sock = -1;
 317         int header_size = 0;
 318
 319         memset((void *)&recv_msg, 0, sizeof(recv_msg));
 320         memset((void *)&res_msg, 0, sizeof(res_msg));
 321
 322         sock = g_io_channel_unix_get_fd(src);
 323         if (sock < 0) {
 324                 thumb_err("sock fd is invalid!");
 325                 return TRUE;
 326         }
 327
 328         header_size = sizeof(thumbMsg) - MAX_PATH_SIZE*2;
 329
 330 #ifndef _USE_MEDIA_UTIL_
 331         if ((client_sock = accept(sock, (struct sockaddr*)&client_addr, &client_addr_len)) < 0) {
 332                 thumb_err("accept failed : %s", strerror(errno));
 333                 return TRUE;
 334         }
 335
 336         thumb_dbg("Client[%d] is accepted", client_sock);
 337
 338
 339         if (_media_thumb_recv_msg(client_sock, header_size, &recv_msg) < 0) {
 340                 thumb_err("_media_thumb_recv_msg failed ");
 341                 close(client_sock);
 342                 return TRUE;
 343         }
 344 #else
 345
 346         if (_media_thumb_recv_udp_msg(sock, header_size, &recv_msg, &client_addr, &client_addr_len) < 0) {
 347                 thumb_err("_media_thumb_recv_udp_msg failed");
 348                 return FALSE;
 349         }
 350 #endif
 351
 352         thumb_warn("Received [%d] %s(%d) from PID(%d) \n", recv_msg.msg_type, recv_msg.org_path, strlen(recv_msg.org_path), recv_msg.pid);
 353
 354         if (recv_msg.msg_type == THUMB_REQUEST_ALL_MEDIA) {
 355                 thumb_dbg("All thumbnails are being extracted now");
 356                 _thumb_daemon_all_extract(recv_msg.uid);
 357                 g_idle_add(_thumb_daemon_process_queue_jobs, NULL);
 358         } else if(recv_msg.msg_type == THUMB_REQUEST_KILL_SERVER) {
 359                 thumb_warn("received KILL msg from thumbnail agent.");
 360         } else {
 361                 long start = thumb_get_debug_time();
 362
 363                 _thumb_daemon_process_job(&recv_msg, &res_msg,recv_msg.uid);
 364
 365                 long end = thumb_get_debug_time();
 366                 thumb_dbg("Time : %f (%s)", ((double)(end - start) / (double)CLOCKS_PER_SEC), recv_msg.org_path);
 367         }
 368
 369         res_msg.msg_type = recv_msg.msg_type;
 370         strncpy(res_msg.org_path, recv_msg.org_path, recv_msg.origin_path_size);
 371         res_msg.origin_path_size = recv_msg.origin_path_size;
 372         res_msg.dest_path_size = strlen(res_msg.dst_path) + 1;
 373
 374         int buf_size = 0;
 375         unsigned char *buf = NULL;
 376         _media_thumb_set_buffer(&res_msg, &buf, &buf_size);
 377
 378         //thumb_dbg("buffer size : %d", buf_size);
 379
 380 #ifndef _USE_MEDIA_UTIL_
 381         if (send(client_sock, buf, buf_size, 0) != buf_size) {
 382                 thumb_err("sendto failed : %s", strerror(errno));
 383         } else {
 384                 thumb_dbg("Sent %s(%d) \n", res_msg.dst_path, strlen(res_msg.dst_path));
 385         }
 386
 387         close(client_sock);
 388 #else
 389 #ifdef _USE_UDS_SOCKET_
 390         thumb_dbg("+++++++++++++++++++++%s", client_addr.sun_path);
 391 #endif
 392         if (sendto(sock, buf, buf_size, 0, (struct sockaddr *)&client_addr, sizeof(client_addr)) != buf_size) {
 393                 thumb_err("sendto failed: %s\n", strerror(errno));
 394                 SAFE_FREE(buf);
 395                 return FALSE;
 396         }
 397 #endif
 398
 399         thumb_warn("Sent %s(%d)", res_msg.dst_path, strlen(res_msg.dst_path));
 400
 401         SAFE_FREE(buf);
 402
 403         if(recv_msg.msg_type == THUMB_REQUEST_KILL_SERVER) {
 404                 thumb_warn("Shutting down...");
 405                 g_main_loop_quit(g_thumb_server_mainloop);
 406         }
 407
 408         return TRUE;
 409 }
 410
 411 #ifdef _USE_MEDIA_UTIL_
 412 gboolean _thumb_server_send_msg_to_agent(int msg_type)
 413 {
 414         int sock;
 415         const char *serv_ip = "127.0.0.1";
 416 #ifdef _USE_UDS_SOCKET_
 417         struct sockaddr_un serv_addr;
 418 #else
 419         struct sockaddr_in serv_addr;
 420 #endif
 421         ms_thumb_server_msg send_msg;
 422
 423 #ifdef _USE_UDS_SOCKET_
 424         if (ms_ipc_create_client_socket(MS_PROTOCOL_UDP, MS_TIMEOUT_SEC_10, &sock, MS_THUMB_COMM_PORT) < 0) {
 425 #else
 426         if (ms_ipc_create_client_socket(MS_PROTOCOL_UDP, MS_TIMEOUT_SEC_10, &sock) < 0) {
 427 #endif
 428                 thumb_err("ms_ipc_create_server_socket failed");
 429                 return FALSE;
 430         }
 431
 432         memset(&serv_addr, 0, sizeof(serv_addr));
 433 #ifdef _USE_UDS_SOCKET_
 434         serv_addr.sun_family = AF_UNIX;
 435         strcpy(serv_addr.sun_path, "/var/run/media-server/media_ipc_thumbcomm.socket");
 436 #else
 437         serv_addr.sin_family = AF_INET;
 438         serv_addr.sin_addr.s_addr = inet_addr(serv_ip);
 439         serv_addr.sin_port = htons(MS_THUMB_COMM_PORT);
 440 #endif
 441
 442         send_msg.msg_type = msg_type;
 443
 444         if (sendto(sock, &send_msg, sizeof(ms_thumb_server_msg), 0, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) != sizeof(ms_thumb_server_msg)) {
 445                 thumb_err("sendto failed: %s\n", strerror(errno));
 446                 close(sock);
 447                 return FALSE;
 448         }
 449
 450         thumb_dbg("Sending msg to thumbnail agent[%d] is successful", send_msg.msg_type);
 451
 452         close(sock);
 453         return TRUE;
 454 }
 455 #endif
 456
 457 gboolean _thumb_server_prepare_socket(int *sock_fd)
 458 {
 459         int sock;
 460         unsigned short serv_port;
 461
 462         thumbMsg recv_msg;
 463         thumbMsg res_msg;
 464
 465         memset((void *)&recv_msg, 0, sizeof(recv_msg));
 466         memset((void *)&res_msg, 0, sizeof(res_msg));
 467 #ifdef _USE_MEDIA_UTIL_
 468         serv_port = MS_THUMB_DAEMON_PORT;
 469
 470         if (ms_ipc_create_server_socket(MS_PROTOCOL_UDP, serv_port, &sock) < 0) {
 471                 thumb_err("ms_ipc_create_server_socket failed");
 472                 return FALSE;
 473         }
 474 #else
 475         char thumb_path[MAX_PATH_SIZE + 1];
 476 #ifdef _USE_UDS_SOCKET_
 477         struct sockaddr_un serv_addr;
 478 #else
 479         struct sockaddr_in serv_addr;
 480 #endif
 481         serv_port = THUMB_DAEMON_PORT;
 482
 483         /* Creaete a TCP socket */
 484         if (_media_thumb_create_socket(SERVER_SOCKET, &sock) < 0) {
 485                 thumb_err("_media_thumb_create_socket failed");
 486                 return FALSE;
 487         }
 488
 489         memset(thumb_path, 0, sizeof(thumb_path));
 490         memset(&serv_addr, 0, sizeof(serv_addr));
 491         serv_addr.sin_family = AF_INET;
 492         serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 493         serv_addr.sin_port = htons(serv_port);
 494
 495         /* Bind to the local address */
 496         if (bind(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
 497                 thumb_err("bind failed : %s", strerror(errno));
 498                 return FALSE;
 499         }
 500
 501         thumb_dbg("bind success");
 502
 503         /* Listening */
 504         if (listen(sock, SOMAXCONN) < 0) {
 505                 thumb_err("listen failed : %s", strerror(errno));
 506         }
 507
 508         thumb_dbg("Listening...");
 509 #endif
 510
 511         *sock_fd = sock;
 512
 513         return TRUE;
 514 }
 515