src/common/media-svc-media-folder.c

   1 /*
   2  * libmedia-service
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.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 <glib/gstdio.h>
  23 #include <media-util-err.h>
  24 #include "media-svc-media-folder.h"
  25 #include "media-svc-debug.h"
  26 #include "media-svc-env.h"
  27 #include "media-svc-util.h"
  28 #include "media-svc-db-utils.h"
  29
  30 #define FOLDER_SCAN_DONE 4
  31
  32 extern __thread GList *g_media_svc_move_item_query_list;
  33 static __thread GList *g_media_svc_insert_folder_query_list;
  34
  35 static int __media_svc_is_root_path(const char *folder_path, bool *is_root, uid_t uid)
  36 {
  37         media_svc_retvm_if(!STRING_VALID(folder_path), MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
  38
  39         *is_root = FALSE;
  40         int i = 0;
  41         int start_len = 0;
  42         int path_len = 0;
  43         char *internal_path = NULL;
  44         int ret = MS_MEDIA_ERR_NONE;
  45
  46         ret = ms_user_get_internal_root_path(uid, &internal_path);
  47         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "Fail to get root path");
  48
  49         if (STRING_VALID(internal_path) && (strcmp(folder_path, internal_path) == 0)) {
  50                 media_svc_debug("ROOT PATH [%s]", folder_path);
  51                 *is_root = TRUE;
  52
  53                 SAFE_FREE(internal_path);
  54
  55                 return MS_MEDIA_ERR_NONE;
  56         }
  57         SAFE_FREE(internal_path);
  58
  59         if (STRING_VALID(MEDIA_ROOT_PATH_SDCARD) && strncmp(folder_path, MEDIA_ROOT_PATH_SDCARD, strlen(MEDIA_ROOT_PATH_SDCARD)) == 0) {
  60
  61                 start_len = strlen(MEDIA_ROOT_PATH_SDCARD);
  62                 path_len = strlen(folder_path);
  63
  64                 for (i = start_len; i < path_len; i++) {
  65                         if (folder_path[i] == '/')
  66                                 return MS_MEDIA_ERR_NONE;
  67                 }
  68
  69                 media_svc_debug("ROOT PATH [%s]", folder_path);
  70                 *is_root = TRUE;
  71         } else if (STRING_VALID(MEDIA_ROOT_PATH_DISC) && strcmp(folder_path, MEDIA_ROOT_PATH_DISC) == 0) {
  72                 media_svc_debug("ROOT PATH [%s]", folder_path);
  73                 *is_root = TRUE;
  74         }
  75
  76         return MS_MEDIA_ERR_NONE;
  77 }
  78
  79 static int __media_svc_parent_is_ext_root_path(const char *folder_path, bool *is_root)
  80 {
  81         char *parent_folder_path = NULL;
  82
  83         media_svc_retvm_if(!STRING_VALID(folder_path), MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
  84
  85         *is_root = FALSE;
  86
  87         parent_folder_path = g_path_get_dirname(folder_path);
  88
  89         if (!STRING_VALID(parent_folder_path)) {
  90                 media_svc_error("error : g_path_get_dirname falied");
  91                 SAFE_FREE(parent_folder_path);
  92                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
  93         }
  94
  95         if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && (strcmp(parent_folder_path, MEDIA_ROOT_PATH_EXTERNAL) == 0)) {
  96                 media_svc_debug("parent folder is ROOT PATH [%s]", parent_folder_path);
  97                 *is_root = TRUE;
  98         }
  99
 100         SAFE_FREE(parent_folder_path);
 101
 102         return MS_MEDIA_ERR_NONE;
 103 }
 104
 105 int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *storage_id, const char *folder_name, char *folder_id, uid_t uid)
 106 {
 107         int ret = MS_MEDIA_ERR_NONE;
 108         sqlite3_stmt *sql_stmt = NULL;
 109         char *sql = NULL;
 110         char parent_folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0, };
 111         char *temp_parent_uuid = NULL;
 112         char *parent_folder_path = NULL;
 113
 114         sql = sqlite3_mprintf("SELECT folder_uuid, parent_folder_uuid FROM '%s' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_name);
 115
 116         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 117
 118         if (ret != MS_MEDIA_ERR_NONE) {
 119                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 120                         media_svc_debug("there is no folder.");
 121                 else
 122                         media_svc_error("error when _media_svc_get_folder_id_by_foldername. err = [%d]", ret);
 123
 124                 return ret;
 125         }
 126
 127         memset(parent_folder_uuid, 0, sizeof(parent_folder_uuid));
 128
 129         _strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE + 1);
 130         if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1)))       /*root path can be null*/
 131                 _strncpy_safe(parent_folder_uuid, (const char *)sqlite3_column_text(sql_stmt, 1), MEDIA_SVC_UUID_SIZE+1);
 132
 133         SQLITE3_FINALIZE(sql_stmt);
 134
 135         /*root path can be null*/
 136         if (!STRING_VALID(parent_folder_uuid)) {
 137                 bool is_root = FALSE;
 138
 139                 ret = __media_svc_is_root_path(folder_name, &is_root, uid);
 140                 if (is_root)
 141                         return MS_MEDIA_ERR_NONE;
 142
 143                 ret = __media_svc_parent_is_ext_root_path(folder_name, &is_root);
 144                 if (is_root)
 145                         return MS_MEDIA_ERR_NONE;
 146         }
 147
 148         /* Notice : Below code is the code only for inserting parent folder uuid when upgrade the media db version 3 to 4 */
 149         /* Check parent folder uuid */
 150         if (!STRING_VALID(parent_folder_uuid)) {
 151                 /* update parent_uuid */
 152                 media_svc_error("[No-Error] there is no parent folder uuid. PLEASE CHECK IT");
 153
 154                 parent_folder_path = g_path_get_dirname(folder_name);
 155                 if (!STRING_VALID(parent_folder_path)) {
 156                         media_svc_error("error : g_path_get_dirname falied.");
 157                         return MS_MEDIA_ERR_OUT_OF_MEMORY;
 158                 }
 159
 160                 if (STRING_VALID(storage_id))
 161                         sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, parent_folder_path);
 162                 else
 163                         sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, parent_folder_path);
 164
 165                 SAFE_FREE(parent_folder_path);
 166
 167                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 168                 if (ret == MS_MEDIA_ERR_NONE) {
 169                         temp_parent_uuid = (char *)sqlite3_column_text(sql_stmt, 0);
 170                         if (temp_parent_uuid != NULL)
 171                                 _strncpy_safe(parent_folder_uuid, temp_parent_uuid, MEDIA_SVC_UUID_SIZE+1);
 172
 173                         SQLITE3_FINALIZE(sql_stmt);
 174                 }
 175
 176                 if (STRING_VALID(parent_folder_uuid)) {
 177                         if (STRING_VALID(storage_id))
 178                                 sql = sqlite3_mprintf("UPDATE %q SET parent_folder_uuid = '%q' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, parent_folder_uuid, storage_id, folder_name);
 179                         else
 180                                 sql = sqlite3_mprintf("UPDATE %q SET parent_folder_uuid = '%q' WHERE path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, parent_folder_uuid, folder_name);
 181                         ret = _media_svc_sql_query(sql, uid);
 182                         SQLITE3_SAFE_FREE(sql);
 183                 } else {
 184                         media_svc_error("error when get parent folder uuid");
 185                 }
 186         }
 187
 188         return ret;
 189 }
 190
 191 static int __media_svc_append_folder(const char *storage_id, media_svc_storage_type_e storage_type,
 192                         const char *folder_id, const char *folder_path, const char *parent_folder_uuid, bool stack_query, uid_t uid)
 193 {
 194         int ret = MS_MEDIA_ERR_NONE;
 195         char *folder_name = NULL;
 196         int folder_modified_date = 0;
 197
 198         folder_name = g_path_get_basename(folder_path);
 199         folder_modified_date = _media_svc_get_file_time(folder_path);
 200
 201         /*Update Pinyin If Support Pinyin*/
 202         char *folder_name_pinyin = NULL;
 203         if (_media_svc_check_pinyin_support())
 204                 _media_svc_get_pinyin_str(folder_name, &folder_name_pinyin);
 205         /* Sometime SQLITE3 returns NO_RECORD, so need to consider conflict case.. */
 206         media_svc_debug("UNIQUE:path[%s], storage_uuid[%s]", folder_path, storage_id);
 207         char *sql = sqlite3_mprintf("INSERT OR IGNORE INTO %s (folder_uuid, path, name, storage_uuid, storage_type, modified_time, name_pinyin, parent_folder_uuid) \
 208                                                         values (%Q, %Q, %Q, %Q, '%d', '%d', %Q, %Q); ",
 209                                                         MEDIA_SVC_DB_TABLE_FOLDER, folder_id, folder_path, folder_name, storage_id, storage_type, folder_modified_date, folder_name_pinyin, parent_folder_uuid);
 210
 211         if (!stack_query) {
 212                 ret = _media_svc_sql_query(sql, uid);
 213                 SQLITE3_SAFE_FREE(sql);
 214         } else {
 215                 _media_svc_sql_query_add(&g_media_svc_insert_folder_query_list, &sql);
 216         }
 217
 218         SAFE_FREE(folder_name);
 219         SAFE_FREE(folder_name_pinyin);
 220
 221         return ret;
 222 }
 223
 224 int _media_svc_update_folder_modified_time_by_folder_uuid(const char *folder_uuid, const char *folder_path, bool stack_query, uid_t uid)
 225 {
 226         int ret = MS_MEDIA_ERR_NONE;
 227         int modified_time = 0;
 228
 229         modified_time = _media_svc_get_file_time(folder_path);
 230
 231         char *sql = sqlite3_mprintf("UPDATE %s SET modified_time=%d WHERE folder_uuid=%Q;", MEDIA_SVC_DB_TABLE_FOLDER, modified_time, folder_uuid);
 232
 233         if (!stack_query) {
 234                 ret = _media_svc_sql_query(sql, uid);
 235                 SQLITE3_SAFE_FREE(sql);
 236         } else {
 237                 _media_svc_sql_query_add(&g_media_svc_move_item_query_list, &sql);
 238         }
 239
 240         return ret;
 241 }
 242
 243 static int __media_svc_get_and_append_parent_folder(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, uid_t uid)
 244 {
 245         int ret = MS_MEDIA_ERR_NONE;
 246         unsigned int next_pos = 0;
 247         char *next = NULL;
 248         char *dir_path = NULL;
 249         const char *token = "/";
 250         char *folder_uuid = NULL;
 251         char parent_folder_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0, };
 252         bool folder_search_end = FALSE;
 253         char *internal_path = NULL;
 254
 255         memset(parent_folder_uuid, 0, sizeof(parent_folder_uuid));
 256         ret = ms_user_get_internal_root_path(uid, &internal_path);
 257         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "Fail to get root path");
 258
 259         if (STRING_VALID(internal_path) && (strncmp(path, internal_path, strlen(internal_path)) == 0))
 260                 next_pos = strlen(internal_path);
 261         else if (STRING_VALID(MEDIA_ROOT_PATH_SDCARD) && strncmp(path, MEDIA_ROOT_PATH_SDCARD, strlen(MEDIA_ROOT_PATH_SDCARD)) == 0)
 262                 next_pos = strlen(MEDIA_ROOT_PATH_SDCARD);
 263         else if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && strncmp(path, MEDIA_ROOT_PATH_EXTERNAL, strlen(MEDIA_ROOT_PATH_EXTERNAL)) == 0)
 264                 next_pos = strlen(MEDIA_ROOT_PATH_EXTERNAL);
 265         else if (STRING_VALID(MEDIA_ROOT_PATH_DISC) && strncmp(path, MEDIA_ROOT_PATH_DISC, strlen(MEDIA_ROOT_PATH_DISC)) == 0)
 266                 next_pos = strlen(MEDIA_ROOT_PATH_DISC);
 267         else {
 268                 media_svc_error("Invalid Path");
 269                 media_svc_sec_error("Invalid Path [%s], internal_path [%s]", path, internal_path);
 270                 SAFE_FREE(internal_path);
 271                 return MS_MEDIA_ERR_INTERNAL;
 272         }
 273
 274         SAFE_FREE(internal_path);
 275
 276         while (!folder_search_end) {
 277                 next = strstr(path + next_pos, token);
 278                 if (next != NULL) {
 279                         next_pos = (next - path);
 280                         dir_path = strndup(path, next_pos);
 281                         next_pos++;
 282                 } else {
 283                         dir_path = strndup(path, strlen(path));
 284                         folder_search_end = TRUE;
 285                         media_svc_error("[No-Error] End Path [%s]", dir_path);
 286                 }
 287
 288                 if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && (g_strcmp0(dir_path, MEDIA_ROOT_PATH_EXTERNAL) == 0)) {
 289                         /*To avoid insert MEDIA_ROOT_PATH_EXTERNAL path*/
 290                         SAFE_FREE(dir_path);
 291                         continue;
 292                 }
 293
 294                 ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, dir_path, parent_folder_uuid, uid);
 295                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 296                         folder_uuid = _media_info_generate_uuid();
 297                         if (folder_uuid == NULL) {
 298                                 media_svc_error("Invalid UUID");
 299                                 SAFE_FREE(dir_path);
 300                                 return MS_MEDIA_ERR_INTERNAL;
 301                         }
 302
 303                         ret = __media_svc_append_folder(storage_id, storage_type, folder_uuid, dir_path, parent_folder_uuid, FALSE, uid);
 304                         if (ret != MS_MEDIA_ERR_NONE)
 305                                 media_svc_error("__media_svc_append_folder is failed");
 306
 307                         media_svc_error("[No-Error] New Appended folder path [%s], folder_uuid [%s], parent_folder_uuid [%s]", dir_path, folder_uuid, parent_folder_uuid);
 308                         _strncpy_safe(parent_folder_uuid, folder_uuid, MEDIA_SVC_UUID_SIZE + 1);
 309                 } else {
 310                         media_svc_error("EXIST dir path : %s\n", dir_path);
 311                 }
 312
 313                 SAFE_FREE(dir_path);
 314         }
 315
 316         if (STRING_VALID(folder_uuid)) {
 317                 _strncpy_safe(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE + 1);
 318         } else {
 319                 media_svc_error("Fail to get folder_uuid");
 320                 return MS_MEDIA_ERR_INTERNAL;
 321         }
 322
 323         return MS_MEDIA_ERR_NONE;
 324 }
 325
 326 int _media_svc_get_and_append_folder(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, uid_t uid)
 327 {
 328         int ret = MS_MEDIA_ERR_NONE;
 329
 330         ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, path, folder_id, uid);
 331
 332         if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 333                 ret = __media_svc_get_and_append_parent_folder(handle, storage_id, path, storage_type, folder_id, uid);
 334
 335         return ret;
 336 }
 337
 338 int _media_svc_get_and_append_folder_id_by_path(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, uid_t uid)
 339 {
 340         char *dir_path = NULL;
 341         int ret = MS_MEDIA_ERR_NONE;
 342
 343         dir_path = g_path_get_dirname(path);
 344
 345         ret = _media_svc_get_and_append_folder(handle, storage_id, dir_path, storage_type, folder_id, uid);
 346
 347         SAFE_FREE(dir_path);
 348
 349         return ret;
 350 }
 351
 352 int _media_svc_update_folder_table(const char *storage_id, uid_t uid)
 353 {
 354         int ret = MS_MEDIA_ERR_NONE;
 355         char *sql = NULL;
 356
 357         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE folder_uuid IN (SELECT folder_uuid FROM '%s' WHERE folder_uuid NOT IN (SELECT folder_uuid FROM '%s'));",
 358                 MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_FOLDER, storage_id);
 359
 360         ret = _media_svc_sql_query(sql, uid);
 361         SQLITE3_SAFE_FREE(sql);
 362
 363         return ret;
 364 }
 365
 366 static int __media_svc_count_all_folders(sqlite3 *handle, char *start_path, int *count)
 367 {
 368         int ret = MS_MEDIA_ERR_NONE;
 369         sqlite3_stmt *sql_stmt = NULL;
 370         char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE path LIKE '%q%%'", MEDIA_SVC_DB_TABLE_FOLDER, start_path);
 371
 372         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 373         if (ret != MS_MEDIA_ERR_NONE) {
 374                 media_svc_error("error when _media_svc_sql_prepare_to_step. err = [%d]", ret);
 375                 return ret;
 376         }
 377
 378         *count = sqlite3_column_int(sql_stmt, 0);
 379
 380         SQLITE3_FINALIZE(sql_stmt);
 381
 382         return MS_MEDIA_ERR_NONE;
 383 }
 384
 385 int _media_svc_get_all_folders(sqlite3 *handle, char *start_path, char ***folder_list, time_t **modified_time_list, int **item_num_list, int *count)
 386 {
 387         int ret = MS_MEDIA_ERR_NONE;
 388         int idx = 0;
 389         sqlite3_stmt *sql_stmt = NULL;
 390         char *sql = NULL;
 391         int cnt = 0;
 392         char **folder_uuid = NULL;
 393         int i = 0;
 394
 395         ret = __media_svc_count_all_folders(handle, start_path, &cnt);
 396         if (ret != MS_MEDIA_ERR_NONE) {
 397                 media_svc_error("error when __media_svc_count_all_folders. err = [%d]", ret);
 398                 return ret;
 399         }
 400
 401         if (cnt > 0) {
 402                 sql = sqlite3_mprintf("SELECT path, modified_time, folder_uuid FROM '%s' WHERE path LIKE '%q%%'", MEDIA_SVC_DB_TABLE_FOLDER, start_path);
 403         } else {
 404                 *folder_list = NULL;
 405                 *modified_time_list = NULL;
 406                 *item_num_list = NULL;
 407                 return MS_MEDIA_ERR_NONE;
 408         }
 409
 410         *folder_list = malloc(sizeof(char *) * cnt);
 411         *modified_time_list = malloc(sizeof(int) * cnt);
 412         *item_num_list = malloc(sizeof(int) * cnt);
 413         folder_uuid = malloc(sizeof(char *) * cnt);
 414
 415         if ((*folder_list == NULL) || (*modified_time_list == NULL) || (*item_num_list == NULL) || (folder_uuid == NULL)) {
 416                 media_svc_error("Out of memory");
 417                 goto ERROR;
 418         }
 419         memset(folder_uuid, 0x0, sizeof(char *) * cnt);
 420         memset(*folder_list, 0x0, sizeof(char *) * cnt);
 421
 422         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 423         if (ret != MS_MEDIA_ERR_NONE) {
 424                 media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 425                 goto ERROR;
 426         }
 427
 428         media_svc_debug("QEURY OK");
 429
 430         while (idx < cnt) {
 431                 (*folder_list)[idx] = g_strdup((char *)sqlite3_column_text(sql_stmt, 0));
 432                 (*modified_time_list)[idx] = (int)sqlite3_column_int(sql_stmt, 1);
 433
 434                 /* get the folder's id */
 435                 folder_uuid[idx] = g_strdup((char *)sqlite3_column_text(sql_stmt, 2));
 436
 437                 idx++;
 438
 439                 if (sqlite3_step(sql_stmt) != SQLITE_ROW)
 440                         break;
 441         }
 442         SQLITE3_FINALIZE(sql_stmt);
 443
 444         /*get the numbder of item in the folder by using folder's id */
 445         for (i = 0; i < idx; i++) {
 446                 if (STRING_VALID(folder_uuid[i])) {
 447                         sql = sqlite3_mprintf("SELECT COUNT(*) FROM %s WHERE (folder_uuid='%q' AND validity = 1)", MEDIA_SVC_DB_TABLE_MEDIA, folder_uuid[i]);
 448                         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 449                         if (ret != MS_MEDIA_ERR_NONE) {
 450                                 media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 451                                 goto ERROR;
 452                         }
 453
 454                         (*item_num_list)[i] = (int)sqlite3_column_int(sql_stmt, 0);
 455
 456                         SQLITE3_FINALIZE(sql_stmt);
 457                 } else {
 458                         media_svc_error("Invalid Folder Id");
 459                 }
 460         }
 461
 462         if (cnt == idx) {
 463                 *count = cnt;
 464                 media_svc_debug("Get Folder is OK");
 465         } else {
 466                 media_svc_error("Fail to get folder");
 467                 ret = MS_MEDIA_ERR_INTERNAL;
 468                 goto ERROR;
 469         }
 470
 471         /* free all data */
 472         for (i = 0; i < idx; i++)
 473                 SAFE_FREE(folder_uuid[i]);
 474
 475         SAFE_FREE(folder_uuid);
 476
 477         return ret;
 478
 479 ERROR:
 480
 481         /* free all data */
 482         for (i = 0; i < idx; i++) {
 483                 SAFE_FREE((*folder_list)[i]);
 484                 SAFE_FREE(folder_uuid[i]);
 485         }
 486         SAFE_FREE(*folder_list);
 487         SAFE_FREE(*modified_time_list);
 488         SAFE_FREE(*item_num_list);
 489         SAFE_FREE(folder_uuid);
 490
 491         *count = 0;
 492
 493         return ret;
 494 }
 495
 496 int _media_svc_get_folder_info_by_foldername(sqlite3 *handle, const char *storage_id, const char *folder_name, char *folder_id, time_t *modified_time)
 497 {
 498         int ret = MS_MEDIA_ERR_NONE;
 499         sqlite3_stmt *sql_stmt = NULL;
 500
 501         char *sql = sqlite3_mprintf("SELECT folder_uuid, modified_time FROM %s WHERE (storage_uuid = '%q' AND path = '%q');", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_name);
 502
 503         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 504
 505         if (ret != MS_MEDIA_ERR_NONE) {
 506                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 507                         media_svc_debug("there is no folder.");
 508                 else
 509                         media_svc_error("error when _media_svc_get_folder_id_by_foldername. err = [%d]", ret);
 510
 511                 return ret;
 512         }
 513
 514         _strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE + 1);
 515         *modified_time = (int)sqlite3_column_int(sql_stmt, 1);
 516
 517         SQLITE3_FINALIZE(sql_stmt);
 518
 519         return ret;
 520 }
 521
 522 int _media_svc_get_and_append_folder_id_by_folder_path(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, bool stack_query, uid_t uid)
 523 {
 524         char *path_name = NULL;
 525         int ret = MS_MEDIA_ERR_NONE;
 526         char *sql = NULL;
 527
 528         path_name = strdup(path);
 529         if (path_name == NULL) {
 530                 media_svc_error("out of memory");
 531                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
 532         }
 533
 534         ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, path_name, folder_id, uid);
 535         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 536                 bool is_root = FALSE;
 537                 bool is_parent_root = FALSE;
 538
 539                 ret = __media_svc_is_root_path(path_name, &is_root, uid);
 540                 ret = __media_svc_parent_is_ext_root_path(path_name, &is_parent_root);
 541
 542                 char parent_folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0, };
 543                 memset(parent_folder_uuid, 0x00, sizeof(parent_folder_uuid));
 544
 545                 if ((is_root == FALSE) && (is_parent_root == FALSE)) {
 546                         /*get parent folder id*/
 547                         char *parent_path_name = g_path_get_dirname(path_name);
 548
 549                         ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, parent_path_name, parent_folder_uuid, uid);
 550                         if (ret != MS_MEDIA_ERR_NONE) {
 551                                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 552                                 /*if No-Root directory scanning start before doing storage scanning, parent_folder_uuid can be NULL.
 553                                 You can remove above logic if use below logic always. but I keep above code for the performance issue.
 554                                 Most case (except No-Root directory scanning start before doing storage scanning) get parent_folder_uuid well*/
 555                                 media_svc_error("[No-Error] There is no proper parent_folder_uuid. so try to make it");
 556                                 ret = _media_svc_get_and_append_folder(handle, storage_id, path, storage_type, folder_id, uid);
 557                                 } else {
 558                                         media_svc_error("error when _media_svc_get_parent_folder_id_by_foldername. err = [%d]", ret);
 559                                 }
 560
 561                                 SAFE_FREE(path_name);
 562                                 SAFE_FREE(parent_path_name);
 563
 564                                 return ret;
 565                         }
 566                 }
 567
 568                 char *folder_uuid = _media_info_generate_uuid();
 569                 if (folder_uuid == NULL) {
 570                         media_svc_error("Invalid UUID");
 571                         SAFE_FREE(path_name);
 572                         return MS_MEDIA_ERR_INTERNAL;
 573                 }
 574
 575                 ret = __media_svc_append_folder(storage_id, storage_type, folder_uuid, path_name, parent_folder_uuid, stack_query, uid);
 576
 577                 _strncpy_safe(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE+1);
 578
 579         } else {
 580                 sql = sqlite3_mprintf("UPDATE '%s' SET validity=1 WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 581
 582                 if (!stack_query) {
 583                         ret = _media_svc_sql_query(sql, uid);
 584                         SQLITE3_SAFE_FREE(sql);
 585                 } else {
 586                         _media_svc_sql_query_add(&g_media_svc_insert_folder_query_list, &sql);
 587                 }
 588         }
 589
 590         SAFE_FREE(path_name);
 591
 592         return ret;
 593 }
 594
 595 int _media_svc_delete_invalid_folder(const char *storage_id, int storage_type, uid_t uid)
 596 {
 597         int ret = MS_MEDIA_ERR_NONE;
 598         char *sql = NULL;
 599
 600         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid = '%q' AND storage_type = %d AND validity = 0;", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, storage_type);
 601         ret = _media_svc_sql_query(sql, uid);
 602
 603         SQLITE3_SAFE_FREE(sql);
 604
 605         return ret;
 606 }
 607
 608 int _media_svc_set_folder_validity(sqlite3 *handle, const char *storage_id, const char *start_path, int validity, bool is_recursive, uid_t uid)
 609 {
 610         int ret = MS_MEDIA_ERR_NONE;
 611         char *sql = NULL;
 612         char start_path_id[MEDIA_SVC_UUID_SIZE+1] = {0,};
 613
 614         if (is_recursive) {
 615                 ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, start_path, start_path_id, uid);
 616                 media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "_media_svc_get_folder_id_by_foldername fail");
 617                 media_svc_retvm_if(!STRING_VALID(start_path_id), MS_MEDIA_ERR_INVALID_PARAMETER, "start_path_id is NULL");
 618
 619                 sql = sqlite3_mprintf("UPDATE '%s' SET validity = %d WHERE storage_uuid = '%q' AND (path LIKE '%q/%%' OR folder_uuid ='%q')",
 620                                                 MEDIA_SVC_DB_TABLE_FOLDER, validity, storage_id, start_path, start_path_id);
 621         } else {
 622                 sql = sqlite3_mprintf("UPDATE '%s' SET validity = %d WHERE storage_uuid = '%q' AND path = '%q';",
 623                                                 MEDIA_SVC_DB_TABLE_FOLDER, validity, storage_id, start_path);
 624         }
 625
 626         ret = _media_svc_sql_query(sql, uid);
 627
 628         SQLITE3_SAFE_FREE(sql);
 629
 630         return ret;
 631 }
 632
 633 int _media_svc_delete_folder_by_storage_id(const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid)
 634 {
 635         int ret = MS_MEDIA_ERR_NONE;
 636         char *sql = NULL;
 637
 638         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid = '%q' AND storage_type = %d;", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, storage_type);
 639         ret = _media_svc_sql_query(sql, uid);
 640
 641         SQLITE3_SAFE_FREE(sql);
 642
 643         return ret;
 644 }
 645
 646 GList **_media_svc_get_folder_list_ptr(void)
 647 {
 648         return &g_media_svc_insert_folder_query_list;
 649 }
 650
 651 int _media_svc_get_folder_scan_status(sqlite3 *handle, const char *storage_id, const char *path, int *scan_status)
 652 {
 653         int ret = MS_MEDIA_ERR_NONE;
 654         sqlite3_stmt *sql_stmt = NULL;
 655         char *sql = NULL;
 656
 657         if (!STRING_VALID(path)) {
 658                 media_svc_error("Not found valid path");
 659                 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
 660         }
 661
 662         sql = sqlite3_mprintf("SELECT scan_status FROM '%s' WHERE path = '%q' AND storage_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, path, storage_id);
 663
 664         ret = _media_svc_sql_prepare_to_step_simple(handle, sql, &sql_stmt);
 665
 666         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 667
 668         while (sqlite3_step(sql_stmt) == SQLITE_ROW)
 669                 *scan_status = sqlite3_column_int(sql_stmt, 0);
 670
 671         SQLITE3_FINALIZE(sql_stmt);
 672
 673         return ret;
 674 }
 675
 676 int _media_svc_set_folder_scan_status(const char *storage_id, const char *path, int scan_status, uid_t uid)
 677 {
 678         int ret = MS_MEDIA_ERR_NONE;
 679         char *sql = NULL;
 680
 681         if (path)
 682                 sql = sqlite3_mprintf("UPDATE '%s' SET scan_status=%d WHERE path = '%q' AND storage_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, scan_status, path, storage_id);
 683         else
 684                 sql = sqlite3_mprintf("UPDATE '%s' SET scan_status=%d WHERE storage_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, scan_status, storage_id);
 685
 686         ret = _media_svc_sql_query(sql, uid);
 687         SQLITE3_SAFE_FREE(sql);
 688
 689         return ret;
 690 }
 691
 692 int _media_svc_get_folder_modified_time_by_path(sqlite3 *handle, const char *path, const char *storage_id, time_t *modified_time)
 693 {
 694         int ret = MS_MEDIA_ERR_NONE;
 695         sqlite3_stmt *sql_stmt = NULL;
 696
 697         char *sql = sqlite3_mprintf("SELECT modified_time FROM '%s' WHERE path = '%q' AND storage_uuid = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, path, storage_id);
 698
 699         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 700
 701         if (ret != MS_MEDIA_ERR_NONE) {
 702                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 703                         media_svc_debug("there is no folder.");
 704                 else
 705                         media_svc_error("error when _media_svc_get_folder_modified_time_by_path. err = [%d]", ret);
 706
 707                 return ret;
 708         }
 709
 710         *modified_time = (int)sqlite3_column_int(sql_stmt, 0);
 711
 712         SQLITE3_FINALIZE(sql_stmt);
 713
 714         return ret;
 715 }
 716
 717 int _media_svc_get_null_scan_folder_list(sqlite3 *handle, const char *storage_id, const char *path, char ***folder_list, int *count)
 718 {
 719         int ret = MS_MEDIA_ERR_NONE;
 720         int idx = 0;
 721         int cnt = 0;
 722         char *sql = NULL;
 723         char folder_id[MEDIA_SVC_UUID_SIZE+1] = {0,};
 724         sqlite3_stmt *sql_stmt = NULL;
 725
 726         if (path == NULL) {
 727                 sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE storage_uuid = '%q' AND scan_status!=%d", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, FOLDER_SCAN_DONE);
 728                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 729
 730                 if (ret != MS_MEDIA_ERR_NONE) {
 731                         if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 732                                 media_svc_debug("there is no folder.");
 733                         else
 734                                 media_svc_error("error when get folder_id by path. err = [%d]", ret);
 735
 736                         *folder_list = NULL;
 737                         *count = 0;
 738
 739                         return ret;
 740                 }
 741
 742                 cnt = sqlite3_column_int(sql_stmt, 0);
 743                 SQLITE3_FINALIZE(sql_stmt);
 744                 if (cnt > 0) {
 745                         sql = sqlite3_mprintf("SELECT path FROM '%s' WHERE storage_uuid = '%q' AND scan_status!=%d", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, FOLDER_SCAN_DONE);
 746                 } else {
 747                         *folder_list = NULL;
 748                         *count = 0;
 749
 750                         return MS_MEDIA_ERR_INTERNAL;
 751                 }
 752
 753                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 754
 755                 if (ret != MS_MEDIA_ERR_NONE) {
 756                         media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 757
 758                         *folder_list = NULL;
 759                         *count = 0;
 760
 761                         return ret;
 762                 }
 763         } else {
 764                 sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE storage_uuid = '%q' AND path = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 765                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 766
 767                 if (ret != MS_MEDIA_ERR_NONE) {
 768                         if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 769                                 media_svc_debug("there is no folder.");
 770                         else
 771                                 media_svc_error("error when get folder_id by path [%s]. err = [%d]", path, ret);
 772
 773                         return ret;
 774                 }
 775
 776                 _strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE+1);
 777
 778                 SQLITE3_FINALIZE(sql_stmt);
 779
 780                 sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE path LIKE '%q%%' AND parent_folder_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, path, folder_id);
 781
 782                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 783
 784                 if (ret != MS_MEDIA_ERR_NONE) {
 785                         media_svc_error("error when _media_svc_sql_prepare_to_step. err = [%d]", ret);
 786                         return ret;
 787                 }
 788
 789                 cnt = sqlite3_column_int(sql_stmt, 0);
 790                 SQLITE3_FINALIZE(sql_stmt);
 791                 if (cnt > 0) {
 792                         sql = sqlite3_mprintf("SELECT path FROM '%s' WHERE path LIKE '%q%%' AND parent_folder_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, path, folder_id);
 793                 } else {
 794                         *folder_list = NULL;
 795                         *count = 0;
 796
 797                         return MS_MEDIA_ERR_NONE;
 798                 }
 799
 800                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 801
 802                 if (ret != MS_MEDIA_ERR_NONE) {
 803                         media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 804
 805                         *folder_list = NULL;
 806                         *count = 0;
 807
 808                         return ret;
 809                 }
 810         }
 811
 812         *folder_list = malloc(sizeof(char *) * cnt);
 813
 814         while (1) {
 815                 (*folder_list)[idx] = strdup((char *)sqlite3_column_text(sql_stmt, 0));
 816
 817                 if (sqlite3_step(sql_stmt) != SQLITE_ROW)
 818                         break;
 819                 idx++;
 820         }
 821
 822         if (cnt == idx + 1) {
 823                 *count = cnt;
 824                 media_svc_debug("OK");
 825         } else {
 826                 /* free all data */
 827                 int i = 0;
 828                 for (i  = 0; i < idx; i++)
 829                         SAFE_FREE((*folder_list)[i]);
 830
 831                 SAFE_FREE(*folder_list);
 832                 *count = 0;
 833                 ret = MS_MEDIA_ERR_INTERNAL;
 834         }
 835
 836         SQLITE3_FINALIZE(sql_stmt);
 837
 838         return ret;
 839 }
 840
 841 int _media_svc_delete_invalid_folder_by_path(sqlite3 *handle, const char *storage_id, const char *folder_path, uid_t uid, int *delete_count)
 842 {
 843         int ret = MS_MEDIA_ERR_NONE;
 844         char *sql = NULL;
 845         int del_count = 0;
 846         sqlite3_stmt *sql_stmt = NULL;
 847
 848         if (folder_path == NULL)
 849                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 850
 851         /*check the number of the deleted folder*/
 852         sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE (storage_uuid = '%q' AND validity = 0 AND PATH LIKE '%q/%%');", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_path);
 853
 854         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 855         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 856
 857         del_count = sqlite3_column_int(sql_stmt, 0);
 858
 859         SQLITE3_FINALIZE(sql_stmt);
 860         sql = NULL;
 861
 862         /*delete invalid folder*/
 863         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE (storage_uuid = '%q' AND validity = 0 AND PATH LIKE '%q%%');", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_path);
 864         ret = _media_svc_sql_query(sql, uid);
 865
 866         SQLITE3_SAFE_FREE(sql);
 867
 868         *delete_count = del_count;
 869
 870         return ret;
 871 }
 872
 873 int _media_svc_count_folder_with_path(sqlite3 *handle, const char *storage_id, const char *path, int *count)
 874 {
 875         int ret = MS_MEDIA_ERR_NONE;
 876         sqlite3_stmt *sql_stmt = NULL;
 877
 878         char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE (storage_uuid='%q' AND path='%q')", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 879
 880         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 881
 882         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 883
 884         *count = sqlite3_column_int(sql_stmt, 0);
 885
 886         SQLITE3_FINALIZE(sql_stmt);
 887
 888         return MS_MEDIA_ERR_NONE;
 889 }
 890
 891 int _media_svc_count_subfolder_with_path(sqlite3 *handle, const char *storage_id, const char *path, int *count)
 892 {
 893         int ret = MS_MEDIA_ERR_NONE;
 894         sqlite3_stmt *sql_stmt = NULL;
 895
 896         char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE (storage_uuid='%q' AND path LIKE'%q/%%')", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 897
 898         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 899
 900         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 901
 902         *count = sqlite3_column_int(sql_stmt, 0);
 903
 904         SQLITE3_FINALIZE(sql_stmt);
 905
 906         return MS_MEDIA_ERR_NONE;
 907 }
 908
 909 int _media_svc_get_folder_uuid(sqlite3 *handle, const char *storage_id, const char *path, char *folder_id)
 910 {
 911         int ret = MS_MEDIA_ERR_NONE;
 912         sqlite3_stmt *sql_stmt = NULL;
 913         char *sql = NULL;
 914
 915         sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE (storage_uuid='%q' AND path='%q')", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 916
 917         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 918
 919         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 920
 921         _strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE+1);
 922
 923         SQLITE3_FINALIZE(sql_stmt);
 924
 925         if (!STRING_VALID(folder_id)) {
 926                 media_svc_error("Not found valid storage id [%s]", path);
 927                 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
 928         }
 929
 930         return ret;
 931 }
 932