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