lib/media-util-db.c

   1 /*
   2  * Media Utility
   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 <unistd.h>
  23 #include <db-util.h>
  24 #include <sys/stat.h>
  25 #include <sys/wait.h>
  26 #include <sys/smack.h>
  27 #include "media-server-ipc.h"
  28 #include "media-util-dbg.h"
  29 #include "media-util-internal.h"
  30 #include "media-util.h"
  31
  32 #define BATCH_START "BEGIN"
  33 #define BATCH_END "COMMIT"
  34
  35 static __thread GArray *sql_list = NULL;
  36
  37 static int __media_db_request_recovery(uid_t uid);
  38
  39 static void __media_db_destroy_sql_list()
  40 {
  41         if (sql_list != NULL) {
  42                 while (sql_list->len != 0) {
  43                         char *sql = g_array_index(sql_list, char *, 0);
  44                         g_array_remove_index(sql_list, 0);
  45
  46                         MS_SAFE_FREE(sql);
  47                 }
  48
  49                 g_array_unref(sql_list);
  50                 sql_list = NULL;
  51         }
  52 }
  53
  54 static int __media_db_busy_handler(void *pData, int count)
  55 {
  56         usleep(50000);
  57
  58         MSAPI_DBG("media_db_busy_handler called : %d", count);
  59
  60         return 200 - count;
  61 }
  62
  63 static int __media_db_connect_db_with_handle(sqlite3 **db_handle, uid_t uid, bool need_write)
  64 {
  65         int ret = SQLITE_OK;
  66         char *db_path = NULL;
  67         char *sql = NULL;
  68
  69         ret = ms_user_get_media_db_path(uid, &db_path);
  70         MSAPI_RETVM_IF(ret != MS_MEDIA_ERR_NONE, MS_MEDIA_ERR_DB_CONNECT_FAIL, "ms_user_get_media_db_path failed");
  71
  72         /*Connect DB*/
  73         if (need_write)
  74                 ret = db_util_open_with_options(db_path, db_handle, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
  75         else
  76                 ret = db_util_open_with_options(db_path, db_handle, SQLITE_OPEN_READONLY, NULL);
  77
  78
  79         if (SQLITE_OK != ret) {
  80                 MSAPI_DBG_ERR("error when db open path[%s],ret[%d]", db_path, ret);
  81                 MS_SAFE_FREE(db_path);
  82                 *db_handle = NULL;
  83                 return MS_MEDIA_ERR_DB_CONNECT_FAIL;
  84         }
  85         MS_SAFE_FREE(db_path);
  86
  87         if (*db_handle == NULL) {
  88                 MSAPI_DBG_ERR("*db_handle is NULL");
  89                 return MS_MEDIA_ERR_DB_CONNECT_FAIL;
  90         }
  91
  92         /*Register busy handler*/
  93         ret = sqlite3_busy_handler(*db_handle, __media_db_busy_handler, NULL);
  94         if (SQLITE_OK != ret) {
  95                 if (*db_handle)
  96                         MSAPI_DBG_ERR("[error when register busy handler] %s", sqlite3_errmsg(*db_handle));
  97
  98                 db_util_close(*db_handle);
  99                 *db_handle = NULL;
 100
 101                 return MS_MEDIA_ERR_DB_CONNECT_FAIL;
 102         }
 103
 104         /*For TV internal space issue, change TRUNCATE to OFF */
 105         sql = sqlite3_mprintf("%s", "PRAGMA journal_mode = OFF");
 106         ret = sqlite3_exec(*db_handle, sql, NULL, NULL, NULL);
 107         MS_SQL_SAFE_FREE(sql);
 108         if (SQLITE_OK != ret) {
 109                 if (*db_handle)
 110                         MSAPI_DBG_ERR("[error when change the journal mode] %s", sqlite3_errmsg(*db_handle));
 111
 112                 db_util_close(*db_handle);
 113                 *db_handle = NULL;
 114
 115                 if (ret == SQLITE_CORRUPT) {
 116                         MSAPI_DBG_ERR("MEDIA DB IS CORRUPTED");
 117                         return MS_MEDIA_ERR_DB_CORRUPT;
 118                 }
 119
 120                 return MS_MEDIA_ERR_DB_CONNECT_FAIL;
 121         }
 122
 123         return MS_MEDIA_ERR_NONE;
 124 }
 125
 126 static int __media_db_disconnect_db_with_handle(sqlite3 *db_handle)
 127 {
 128         int ret = MS_MEDIA_ERR_NONE;
 129
 130         ret = db_util_close(db_handle);
 131         if (SQLITE_OK != ret) {
 132                 MSAPI_DBG_ERR("error when db close [%s]", sqlite3_errmsg(db_handle));
 133                 db_handle = NULL;
 134                 return MS_MEDIA_ERR_DB_DISCONNECT_FAIL;
 135         }
 136
 137         return MS_MEDIA_ERR_NONE;
 138 }
 139
 140 extern char MEDIA_IPC_PATH[][70];
 141 #define MAX_RETRY_COUNT 3
 142
 143 static int __media_db_request_update_tcp(ms_msg_type_e msg_type, const char *request_msg, uid_t uid)
 144 {
 145         int ret = MS_MEDIA_ERR_NONE;
 146         int request_msg_size = 0;
 147         int sockfd = -1;
 148         struct sockaddr_un serv_addr;
 149         int retry_count = 0;
 150
 151         if (!MS_STRING_VALID(request_msg)) {
 152                 MSAPI_DBG_ERR("invalid query");
 153                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 154         }
 155
 156         request_msg_size = strlen(request_msg);
 157         if (request_msg_size >= MAX_MSG_SIZE) {
 158                 MSAPI_DBG_ERR("Too long query[%d] limit[%d]", request_msg_size, MAX_MSG_SIZE);
 159                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 160         }
 161
 162         ms_comm_msg_s send_msg;
 163         memset((void *)&send_msg, 0, sizeof(ms_comm_msg_s));
 164
 165         send_msg.msg_type = msg_type;
 166         SAFE_STRLCPY(send_msg.msg, request_msg, sizeof(send_msg.msg));
 167         send_msg.uid = uid;
 168
 169         /*Create Socket*/
 170         ret = ms_ipc_create_client_socket(MS_TIMEOUT_SEC_10, &sockfd);
 171         MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
 172
 173         /*Set server Address*/
 174         memset(&serv_addr, 0, sizeof(serv_addr));
 175         serv_addr.sun_family = AF_UNIX;
 176         SAFE_STRLCPY(serv_addr.sun_path, tzplatform_mkpath(TZ_SYS_RUN, MEDIA_IPC_PATH[MS_DB_UPDATE_PORT]), sizeof(serv_addr.sun_path));
 177
 178         /* Connecting to the media db server */
 179         if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
 180                 MSAPI_DBG_STRERROR("connect error");
 181                 close(sockfd);
 182                 if (errno == EACCES)
 183                         return MS_MEDIA_ERR_PERMISSION_DENIED;
 184                 else
 185                         return MS_MEDIA_ERR_SOCKET_CONN;
 186         }
 187
 188         /* Send request */
 189         if (send(sockfd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
 190                 MSAPI_DBG_STRERROR("send failed");
 191                 close(sockfd);
 192                 return MS_MEDIA_ERR_SOCKET_SEND;
 193         }
 194
 195         /*Receive Response*/
 196         int recv_msg_size = -1;
 197         int recv_msg = -1;
 198 RETRY:
 199         if ((recv_msg_size = recv(sockfd, &recv_msg, sizeof(recv_msg), 0)) < 0) {
 200                 MSAPI_DBG_ERR("recv failed : [%d]", sockfd);
 201
 202                 if (errno == EINTR) {
 203                         MSAPI_DBG_STRERROR("catch interrupt");
 204                         goto RETRY;
 205                 }
 206
 207                 if (errno == EWOULDBLOCK) {
 208                         if (retry_count < MAX_RETRY_COUNT) {
 209                                 MSAPI_DBG_ERR("TIME OUT[%d]", retry_count);
 210                                 retry_count++;
 211                                 goto RETRY;
 212                         }
 213
 214                         close(sockfd);
 215                         MSAPI_DBG_ERR("Timeout. Can't try any more");
 216                         return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
 217                 } else {
 218                         MSAPI_DBG_STRERROR("recv failed");
 219
 220                         close(sockfd);
 221
 222                         return MS_MEDIA_ERR_SOCKET_RECEIVE;
 223                 }
 224         }
 225
 226         MSAPI_DBG("RECEIVE OK [%d]", recv_msg);
 227         ret = recv_msg;
 228
 229         close(sockfd);
 230
 231         return ret;
 232 }
 233
 234 static __thread int g_tcp_client_sock = -1;
 235
 236 static int __media_db_get_client_tcp_sock()
 237 {
 238         return g_tcp_client_sock;
 239 }
 240
 241 static int __media_db_prepare_tcp_client_socket()
 242 {
 243         int ret = MS_MEDIA_ERR_NONE;
 244         int sockfd = -1;
 245         struct sockaddr_un serv_addr;
 246
 247         /*Create TCP Socket*/
 248         ret = ms_ipc_create_client_socket(MS_TIMEOUT_SEC_10, &sockfd);
 249         MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
 250
 251         /*Set server Address*/
 252         memset(&serv_addr, 0, sizeof(serv_addr));
 253         serv_addr.sun_family = AF_UNIX;
 254         SAFE_STRLCPY(serv_addr.sun_path, tzplatform_mkpath(TZ_SYS_RUN, MEDIA_IPC_PATH[MS_DB_BATCH_UPDATE_PORT]), sizeof(serv_addr.sun_path));
 255
 256         /* Connecting to the media db server */
 257         if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
 258                 MSAPI_DBG_STRERROR("connect error");
 259                 close(sockfd);
 260                 return MS_MEDIA_ERR_SOCKET_CONN;
 261         }
 262
 263         g_tcp_client_sock = sockfd;
 264
 265         MSAPI_DBG("Connected successfully");
 266
 267         return 0;
 268 }
 269
 270 static int __media_db_close_tcp_client_socket()
 271 {
 272         if (g_tcp_client_sock != -1) {
 273                 if (close(g_tcp_client_sock) < 0) {
 274                         MSAPI_DBG_STRERROR("socket close failed");
 275                         return MS_MEDIA_ERR_SOCKET_INTERNAL;
 276                 }
 277                 g_tcp_client_sock = -1;
 278         }
 279
 280         return MS_MEDIA_ERR_NONE;
 281 }
 282
 283 static int __media_db_request_batch_update(ms_msg_type_e msg_type, const char *request_msg, uid_t uid)
 284 {
 285         int ret = MS_MEDIA_ERR_NONE;
 286         int request_msg_size = 0;
 287         int sockfd = -1;
 288
 289         if (!MS_STRING_VALID(request_msg)) {
 290                 MSAPI_DBG_ERR("invalid query");
 291                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 292         }
 293
 294         request_msg_size = strlen(request_msg);
 295         if (request_msg_size >= MAX_MSG_SIZE) {
 296                 MSAPI_DBG_ERR("Too long query[%d] limit[%d]", request_msg_size, MAX_MSG_SIZE);
 297                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 298         }
 299
 300         MSAPI_DBG_SLOG("querysize[%d] query[%s]", request_msg_size, request_msg);
 301         ms_comm_msg_s send_msg;
 302         memset((void *)&send_msg, 0, sizeof(ms_comm_msg_s));
 303
 304         send_msg.msg_type = msg_type;
 305         send_msg.uid = uid;
 306         SAFE_STRLCPY(send_msg.msg, request_msg, sizeof(send_msg.msg));
 307
 308         sockfd = __media_db_get_client_tcp_sock();
 309         MSAPI_RETV_IF(sockfd <= 0, MS_MEDIA_ERR_SOCKET_CONN);
 310
 311         /* Send request */
 312         if (send(sockfd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
 313                 MSAPI_DBG_STRERROR("send failed");
 314                 return MS_MEDIA_ERR_SOCKET_SEND;
 315         }
 316
 317         /*Receive Response*/
 318         int recv_msg_size = -1;
 319         int recv_msg = -1;
 320         if ((recv_msg_size = recv(sockfd, &recv_msg, sizeof(recv_msg), 0)) < 0) {
 321                 MSAPI_DBG_ERR("recv failed : [%d]", sockfd);
 322                 if (errno == EWOULDBLOCK) {
 323                         MSAPI_DBG_ERR("Timeout. Can't try any more");
 324                         return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
 325                 } else {
 326                         MSAPI_DBG_STRERROR("recv failed");
 327                         return MS_MEDIA_ERR_SOCKET_RECEIVE;
 328                 }
 329         }
 330
 331         MSAPI_DBG("RECEIVE OK [%d]", recv_msg);
 332         ret = recv_msg;
 333
 334         if (ret != MS_MEDIA_ERR_NONE)
 335                 MSAPI_DBG_ERR("batch updated[%d] failed, error [%d]", msg_type, ret);
 336
 337         return ret;
 338 }
 339
 340 #define RETRY_CNT 9
 341 #define SLEEP_TIME 1000 * 1000
 342 static int _media_db_update_directly(sqlite3 *db_handle, const char *sql_str)
 343 {
 344         int ret = MS_MEDIA_ERR_NONE;
 345         char *zErrMsg = NULL;
 346         int retry_count = 0;
 347
 348 EXEC_RETRY:
 349         ret = sqlite3_exec(db_handle, sql_str, NULL, NULL, &zErrMsg);
 350
 351         if (SQLITE_OK != ret) {
 352                 MSAPI_ERR_SLOG("Error[%s],Query[%s]", zErrMsg, sql_str);
 353                 MS_SQL_SAFE_FREE(zErrMsg);
 354                 if (ret == SQLITE_BUSY) {
 355                         ret = MS_MEDIA_ERR_DB_BUSY_FAIL;
 356                 } else if (ret == SQLITE_CONSTRAINT) {
 357                         ret = MS_MEDIA_ERR_DB_CONSTRAINT_FAIL;
 358                 } else if (ret == SQLITE_FULL) {
 359                         ret = MS_MEDIA_ERR_DB_FULL_FAIL;
 360                 } else if (ret == SQLITE_LOCKED) {
 361                         if (retry_count < RETRY_CNT) {
 362                                 MSAPI_DBG_ERR("Locked retry[%d]", retry_count);
 363                                 retry_count++;
 364                                 usleep(SLEEP_TIME);
 365                                 goto EXEC_RETRY;
 366                         }
 367                         ret = MS_MEDIA_ERR_DB_UPDATE_FAIL;
 368                 } else {
 369                         ret = MS_MEDIA_ERR_DB_UPDATE_FAIL;
 370                 }
 371         }
 372
 373         return ret;
 374 }
 375
 376 int media_db_check_integrity(MediaDBHandle *handle)
 377 {
 378         sqlite3 * db_handle = (sqlite3 *)handle;
 379
 380         MSAPI_RETVM_IF(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 381
 382         int ret = 0;
 383         sqlite3_stmt *stmt = NULL;
 384         const char integrity_check_query[] = "PRAGMA integrity_check";
 385
 386         ret = sqlite3_prepare_v2(db_handle, integrity_check_query, strlen(integrity_check_query), &stmt, NULL);
 387         if (ret != SQLITE_OK) {
 388                 MSAPI_DBG_ERR("prepare error, ret = %d, error = %s", ret, sqlite3_errmsg(db_handle));
 389                 return MS_MEDIA_ERR_DB_CORRUPT;
 390         }
 391
 392         ret = sqlite3_step(stmt);
 393         if (ret != SQLITE_ROW) {
 394                 MSAPI_DBG_ERR("integrity_check failed in step");
 395                 sqlite3_finalize(stmt);
 396                 return MS_MEDIA_ERR_DB_CORRUPT;
 397         }
 398
 399         char* check_result = (char*) sqlite3_column_text(stmt, 0);
 400         if (check_result == NULL || strncmp(check_result, "ok", strlen(check_result))) {
 401                 MSAPI_DBG_ERR("integrity_check failed - result(%s)\n", check_result);
 402                 sqlite3_finalize(stmt);
 403                 return MS_MEDIA_ERR_DB_CORRUPT;
 404         }
 405         sqlite3_finalize(stmt);
 406
 407         return MS_MEDIA_ERR_NONE;
 408 }
 409
 410 int media_db_connect(MediaDBHandle **handle, uid_t uid, bool need_write)
 411 {
 412         int ret = MS_MEDIA_ERR_NONE;
 413         sqlite3 * db_handle = NULL;
 414         int retry_cnt = 0;
 415
 416         MSAPI_DBG_FUNC();
 417
 418 RETRY_CONN:
 419         ret = __media_db_connect_db_with_handle(&db_handle, uid, need_write);
 420         if (ret != MS_MEDIA_ERR_NONE) {
 421                 if (ret == MS_MEDIA_ERR_DB_CORRUPT && retry_cnt == 0) {
 422                         retry_cnt++;
 423
 424                         ret = __media_db_request_recovery(uid);
 425                         if (ret == MS_MEDIA_ERR_NONE)
 426                                 goto RETRY_CONN;
 427                         else
 428                                 return MS_MEDIA_ERR_DB_CORRUPT;
 429                 } else {
 430                         return ret;
 431                 }
 432         }
 433
 434         *handle = db_handle;
 435         return MS_MEDIA_ERR_NONE;
 436 }
 437
 438 int media_db_disconnect(MediaDBHandle *handle)
 439 {
 440         sqlite3 * db_handle = (sqlite3 *)handle;
 441
 442         MSAPI_DBG_FUNC();
 443
 444         MSAPI_RETVM_IF(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 445
 446         return __media_db_disconnect_db_with_handle(db_handle);
 447 }
 448
 449 int media_db_request_update_db(const char *query_str, uid_t uid)
 450 {
 451         int ret = MS_MEDIA_ERR_NONE;
 452
 453         MSAPI_DBG_FUNC();
 454
 455         MSAPI_RETVM_IF(!MS_STRING_VALID(query_str), MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid Query");
 456
 457         ret = __media_db_request_update_tcp(MS_MSG_DB_UPDATE, query_str, uid);
 458         if (ret != MS_MEDIA_ERR_NONE)
 459                 MSAPI_DBG_ERR("__media_db_request_update_tcp failed : %d", ret);
 460
 461         return ret;
 462 }
 463
 464 int media_db_request_update_db_batch_start(const char *query_str, uid_t uid)
 465 {
 466         int ret = MS_MEDIA_ERR_NONE;
 467
 468         MSAPI_DBG_FUNC();
 469
 470         MSAPI_RETVM_IF(!MS_STRING_VALID(query_str), MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid Query");
 471
 472         ret = __media_db_prepare_tcp_client_socket();
 473         if (ret != MS_MEDIA_ERR_NONE) {
 474                 MSAPI_DBG_ERR("__media_db_prepare_tcp_client_socket failed : %d", ret);
 475                 __media_db_close_tcp_client_socket();
 476                 return ret;
 477         }
 478
 479         ret = __media_db_request_batch_update(MS_MSG_DB_UPDATE_BATCH_START, query_str, uid);
 480         if (ret != MS_MEDIA_ERR_NONE)
 481                 __media_db_close_tcp_client_socket();
 482
 483         return ret;
 484 }
 485
 486 int media_db_request_update_db_batch(const char *query_str, uid_t uid)
 487 {
 488         int ret = MS_MEDIA_ERR_NONE;
 489
 490         MSAPI_DBG_FUNC();
 491
 492         MSAPI_RETVM_IF(!MS_STRING_VALID(query_str), MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid Query");
 493
 494         ret = __media_db_request_batch_update(MS_MSG_DB_UPDATE_BATCH, query_str, uid);
 495         if (ret != MS_MEDIA_ERR_NONE)
 496                 __media_db_close_tcp_client_socket();
 497
 498         return ret;
 499 }
 500
 501 int media_db_request_update_db_batch_end(const char *query_str, uid_t uid)
 502 {
 503         int ret = MS_MEDIA_ERR_NONE;
 504
 505         MSAPI_DBG_FUNC();
 506
 507         if (!MS_STRING_VALID(query_str)) {
 508                 MSAPI_DBG_ERR("Invalid Query");
 509                 __media_db_close_tcp_client_socket();
 510                 return ret;
 511         }
 512
 513         ret = __media_db_request_batch_update(MS_MSG_DB_UPDATE_BATCH_END, query_str, uid);
 514
 515         __media_db_close_tcp_client_socket();
 516
 517         return ret;
 518 }
 519
 520 int media_db_update_db(MediaDBHandle *handle, const char *query_str)
 521 {
 522         sqlite3 * db_handle = (sqlite3 *)handle;
 523         int ret = MS_MEDIA_ERR_NONE;
 524
 525         MSAPI_RETVM_IF(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 526         MSAPI_RETVM_IF(!MS_STRING_VALID(query_str), MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid Query");
 527
 528         ret = _media_db_update_directly(db_handle, query_str);
 529
 530         return ret;
 531 }
 532
 533 int media_db_update_db_batch_start(const char *query_str)
 534 {
 535         int ret = MS_MEDIA_ERR_NONE;
 536 #if 0
 537         char *query = NULL;
 538
 539         MSAPI_RETVM_IF(!MS_STRING_VALID(query_str), MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid Query");
 540 #endif
 541         if (sql_list != NULL) {
 542                 MSAPI_DBG_ERR("sql_list is already allocated");
 543                 ret = MS_MEDIA_ERR_DB_SERVER_BUSY_FAIL;
 544         } else {
 545                 sql_list = g_array_new(FALSE, FALSE, sizeof(char*));
 546                 MSAPI_RETVM_IF(sql_list == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY, "Out of memory");
 547 #if 0
 548                 query = g_strdup(query_str);
 549                 if (MS_STRING_VALID(query)) {
 550                         g_array_append_val(sql_list, query);
 551                 } else {
 552                         MSAPI_DBG_ERR("query is null");
 553                         __media_db_destroy_sql_list();
 554                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
 555                 }
 556 #endif
 557         }
 558
 559         return ret;
 560 }
 561
 562 int media_db_update_db_batch(const char *query_str)
 563 {
 564         int ret = MS_MEDIA_ERR_NONE;
 565         char *query = NULL;
 566
 567         MSAPI_RETVM_IF(!MS_STRING_VALID(query_str), MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid Query");
 568
 569         if (sql_list) {
 570                 query = g_strdup(query_str);
 571                 if (MS_STRING_VALID(query)) {
 572                         g_array_append_val(sql_list, query);
 573                 } else {
 574                         MSAPI_DBG_ERR("query is null");
 575                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
 576                 }
 577         }
 578
 579         return ret;
 580 }
 581
 582 int media_db_update_db_batch_end(MediaDBHandle *handle, const char *query_str)
 583 {
 584         sqlite3 * db_handle = (sqlite3 *)handle;
 585         int ret = MS_MEDIA_ERR_NONE;
 586 #if 0
 587         char *query = NULL;
 588 #endif
 589         /* Unused  (!MS_STRING_VALID(query_str)) */
 590         if (db_handle == NULL) {
 591                 __media_db_destroy_sql_list();
 592                 MSAPI_DBG_ERR("Handle is NULL");
 593                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 594         }
 595
 596         if (sql_list) {
 597 #if 0
 598                 query = g_strdup(query_str);
 599                 if (MS_STRING_VALID(query)) {
 600                         g_array_append_val(sql_list, query);
 601                 } else {
 602                         __media_db_destroy_sql_list();
 603                         MSAPI_DBG_ERR("query is null");
 604                         return MS_MEDIA_ERR_OUT_OF_MEMORY;
 605                 }
 606 #endif
 607                 while (sql_list->len != 0) {
 608                         char *current_sql = NULL;
 609
 610                         current_sql = g_array_index(sql_list, char *, 0);
 611                         g_array_remove_index(sql_list, 0);
 612
 613                         if (MS_STRING_VALID(current_sql)) {
 614                                 ret = _media_db_update_directly(db_handle, current_sql);
 615                                 if (ret < 0) {
 616 #if 0
 617                                         if (strncmp(current_sql, BATCH_START, strlen(BATCH_START)) == 0 || strncmp(current_sql, BATCH_END, strlen(BATCH_END)) == 0) {
 618                                                 MSAPI_DBG_ERR("Query failed : %s", current_sql);
 619                                                 MS_SAFE_FREE(current_sql);
 620                                                 break;
 621                                         } else {
 622                                                 MSAPI_DBG_ERR("Query failed : %s, but keep going to run remaining queries", current_sql);
 623                                         }
 624 #endif
 625                                         MSAPI_DBG_ERR("Query failed : %s, but keep going to run remaining queries", current_sql);
 626                                 }
 627                         }
 628
 629                         MS_SAFE_FREE(current_sql);
 630                 }
 631         }
 632
 633         __media_db_destroy_sql_list();
 634
 635         return MS_MEDIA_ERR_NONE;
 636 }
 637
 638 int media_db_request_update_db_batch_clear(void)
 639 {
 640         int ret = MS_MEDIA_ERR_NONE;
 641
 642         __media_db_destroy_sql_list();
 643
 644         return ret;
 645 }
 646
 647 static int __media_db_request_recovery(uid_t uid)
 648 {
 649         int ret = MS_MEDIA_ERR_NONE;
 650         int request_msg_size = 0;
 651         int sockfd = -1;
 652         struct sockaddr_un serv_addr;
 653         int retry_count = 0;
 654         char *db_path = NULL;
 655
 656         ret = ms_user_get_media_db_path(uid, &db_path);
 657         MSAPI_RETVM_IF(ret != MS_MEDIA_ERR_NONE, MS_MEDIA_ERR_INVALID_PARAMETER, "ms_user_get_media_db_path failed");
 658
 659         request_msg_size = strlen(db_path);
 660         if (request_msg_size >= MAX_MSG_SIZE) {
 661                 MSAPI_DBG_ERR("Too long query[%d] limit[%d]", request_msg_size, MAX_MSG_SIZE);
 662                 MS_SAFE_FREE(db_path);
 663                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 664         }
 665
 666         /*      MSAPI_DBG("querysize[%d] query[%s]", request_msg_size, request_msg); */
 667
 668         ms_comm_msg_s send_msg;
 669         memset((void *)&send_msg, 0, sizeof(ms_comm_msg_s));
 670
 671         send_msg.msg_type = MS_MSG_MEDIA_DB_MALFORMED;
 672         SAFE_STRLCPY(send_msg.msg, db_path, sizeof(send_msg.msg));
 673         MS_SAFE_FREE(db_path);
 674         send_msg.uid = uid;
 675
 676         /*Create Socket*/
 677         ret = ms_ipc_create_client_socket(MS_TIMEOUT_SEC_10, &sockfd);
 678         MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
 679
 680         /*Set server Address*/
 681         memset(&serv_addr, 0, sizeof(serv_addr));
 682         serv_addr.sun_family = AF_UNIX;
 683         /*      MSAPI_DBG_SLOG("%s", MEDIA_IPC_PATH[port]); */
 684         SAFE_STRLCPY(serv_addr.sun_path, MEDIA_IPC_PATH[MS_SCANNER_PORT], sizeof(serv_addr.sun_path));
 685
 686         /* Connecting to the media db server */
 687         if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
 688                 MSAPI_DBG_STRERROR("connect error");
 689                 close(sockfd);
 690                 return MS_MEDIA_ERR_SOCKET_CONN;
 691         }
 692
 693         /* Send request */
 694         if (send(sockfd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
 695                 MSAPI_DBG_STRERROR("send failed");
 696                 close(sockfd);
 697                 return MS_MEDIA_ERR_SOCKET_SEND;
 698         }
 699
 700         /*Receive Response*/
 701         int recv_msg_size = -1;
 702         ms_comm_msg_s recv_msg;
 703 RETRY:
 704         if ((recv_msg_size = recv(sockfd, &recv_msg, sizeof(recv_msg), 0)) < 0) {
 705                 MSAPI_DBG_ERR("recv failed : [%d]", sockfd);
 706
 707                 if (errno == EINTR) {
 708                         MSAPI_DBG_STRERROR("catch interrupt");
 709                         goto RETRY;
 710                 }
 711
 712                 if (errno == EWOULDBLOCK) {
 713                         if (retry_count < MAX_RETRY_COUNT) {
 714                                 MSAPI_DBG_ERR("TIME OUT[%d]", retry_count);
 715                                 retry_count++;
 716                                 goto RETRY;
 717                         }
 718
 719                         close(sockfd);
 720                         MSAPI_DBG_ERR("Timeout. Can't try any more");
 721                         return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
 722                 } else {
 723                         MSAPI_DBG_STRERROR("recv failed");
 724
 725                         close(sockfd);
 726
 727                         return MS_MEDIA_ERR_SOCKET_RECEIVE;
 728                 }
 729         }
 730
 731         MSAPI_DBG("RECEIVE OK [%d]", recv_msg.result);
 732         ret = recv_msg.result;
 733
 734         close(sockfd);
 735
 736         return ret;
 737 }