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 int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *storage_id, const char *folder_name, char *folder_id, uid_t uid)
  36 {
  37         int ret = MS_MEDIA_ERR_NONE;
  38         sqlite3_stmt *sql_stmt = NULL;
  39         char *sql = NULL;
  40
  41         sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_name);
  42
  43         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
  44         if (ret != MS_MEDIA_ERR_NONE) {
  45                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
  46                         media_svc_debug("there is no folder.");
  47                 else
  48                         media_svc_error("error when _media_svc_get_folder_id_by_foldername. err = [%d]", ret);
  49
  50                 return ret;
  51         }
  52
  53         SAFE_STRLCPY(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE + 1);
  54
  55         SQLITE3_FINALIZE(sql_stmt);
  56
  57         return ret;
  58 }
  59
  60 int _media_svc_get_folder_id_by_foldername_with_validity(sqlite3 *handle, const char *storage_id, const char *folder_name, char *folder_id, uid_t uid, int *validity)
  61 {
  62         int ret = MS_MEDIA_ERR_NONE;
  63         sqlite3_stmt *sql_stmt = NULL;
  64         char *sql = NULL;
  65
  66         sql = sqlite3_mprintf("SELECT folder_uuid, validity FROM '%s' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_name);
  67
  68         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
  69         if (ret != MS_MEDIA_ERR_NONE) {
  70                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
  71                         media_svc_debug("there is no folder.");
  72                 else
  73                         media_svc_error("error when _media_svc_get_folder_id_by_foldername_with_validity. err = [%d]", ret);
  74
  75                 return ret;
  76         }
  77
  78         SAFE_STRLCPY(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE + 1);
  79         *validity = (int)sqlite3_column_int(sql_stmt, 1);
  80
  81         SQLITE3_FINALIZE(sql_stmt);
  82
  83         return ret;
  84 }
  85
  86 static int __media_svc_append_folder(const char *storage_id, media_svc_storage_type_e storage_type,
  87                         const char *folder_id, const char *folder_path, bool stack_query, uid_t uid)
  88 {
  89         int ret = MS_MEDIA_ERR_NONE;
  90         char *folder_name = NULL;
  91         int folder_modified_date = 0;
  92
  93         folder_name = g_path_get_basename(folder_path);
  94         folder_modified_date = _media_svc_get_file_time(folder_path);
  95
  96         /*Update Pinyin If Support Pinyin*/
  97         char *folder_name_pinyin = NULL;
  98         if (_media_svc_check_pinyin_support())
  99                 _media_svc_get_pinyin_str(folder_name, &folder_name_pinyin);
 100         /* Sometime SQLITE3 returns NO_RECORD, so need to consider conflict case.. */
 101         media_svc_debug("UNIQUE:path[%s], storage_uuid[%s]", folder_path, storage_id);
 102         char *sql = sqlite3_mprintf("INSERT OR IGNORE INTO %s (folder_uuid, path, name, storage_uuid, storage_type, modified_time, name_pinyin) values (%Q, %Q, %Q, %Q, '%d', '%d', %Q); ",
 103                                 MEDIA_SVC_DB_TABLE_FOLDER, folder_id, folder_path, folder_name, storage_id, storage_type, folder_modified_date, folder_name_pinyin);
 104
 105         if (!stack_query) {
 106                 ret = _media_svc_sql_query(sql, uid);
 107                 SQLITE3_SAFE_FREE(sql);
 108         } else {
 109                 _media_svc_sql_query_add(&g_media_svc_insert_folder_query_list, &sql);
 110         }
 111
 112         SAFE_FREE(folder_name);
 113         SAFE_FREE(folder_name_pinyin);
 114
 115         return ret;
 116 }
 117
 118 int _media_svc_update_folder_modified_time_by_folder_uuid(const char *folder_uuid, const char *folder_path, bool stack_query, uid_t uid)
 119 {
 120         int ret = MS_MEDIA_ERR_NONE;
 121         int modified_time = 0;
 122
 123         modified_time = _media_svc_get_file_time(folder_path);
 124
 125         char *sql = sqlite3_mprintf("UPDATE %s SET modified_time=%d WHERE folder_uuid=%Q;", MEDIA_SVC_DB_TABLE_FOLDER, modified_time, folder_uuid);
 126
 127         if (!stack_query) {
 128                 ret = _media_svc_sql_query(sql, uid);
 129                 SQLITE3_SAFE_FREE(sql);
 130         } else {
 131                 _media_svc_sql_query_add(&g_media_svc_move_item_query_list, &sql);
 132         }
 133
 134         return ret;
 135 }
 136
 137 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)
 138 {
 139         int ret = MS_MEDIA_ERR_NONE;
 140         unsigned int next_pos = 0;
 141         char *next = NULL;
 142         char *dir_path = NULL;
 143         const char *token = "/";
 144         char *folder_uuid = NULL;
 145         char tmp_folder_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0, };
 146         bool folder_search_end = FALSE;
 147         char *internal_path = NULL;
 148
 149         memset(tmp_folder_uuid, 0, sizeof(tmp_folder_uuid));
 150         ret = ms_user_get_internal_root_path(uid, &internal_path);
 151         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "Fail to get root path");
 152
 153         if (STRING_VALID(internal_path) && (strncmp(path, internal_path, strlen(internal_path)) == 0))
 154                 next_pos = strlen(internal_path);
 155         else if (STRING_VALID(MEDIA_ROOT_PATH_SDCARD) && strncmp(path, MEDIA_ROOT_PATH_SDCARD, strlen(MEDIA_ROOT_PATH_SDCARD)) == 0)
 156                 next_pos = strlen(MEDIA_ROOT_PATH_SDCARD);
 157         else if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && strncmp(path, MEDIA_ROOT_PATH_EXTERNAL, strlen(MEDIA_ROOT_PATH_EXTERNAL)) == 0)
 158                 next_pos = strlen(MEDIA_ROOT_PATH_EXTERNAL);
 159         else if (STRING_VALID(MEDIA_ROOT_PATH_DISC) && strncmp(path, MEDIA_ROOT_PATH_DISC, strlen(MEDIA_ROOT_PATH_DISC)) == 0)
 160                 next_pos = strlen(MEDIA_ROOT_PATH_DISC);
 161         else {
 162                 media_svc_error("Invalid Path");
 163                 media_svc_sec_error("Invalid Path [%s], internal_path [%s]", path, internal_path);
 164                 SAFE_FREE(internal_path);
 165                 return MS_MEDIA_ERR_INTERNAL;
 166         }
 167
 168         SAFE_FREE(internal_path);
 169
 170         while (!folder_search_end) {
 171                 next = strstr(path + next_pos, token);
 172                 if (next != NULL) {
 173                         next_pos = (next - path);
 174                         dir_path = strndup(path, next_pos);
 175                         next_pos++;
 176                 } else {
 177                         dir_path = strndup(path, strlen(path));
 178                         folder_search_end = TRUE;
 179                         media_svc_error("[No-Error] End Path [%s]", dir_path);
 180                 }
 181
 182                 if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && (g_strcmp0(dir_path, MEDIA_ROOT_PATH_EXTERNAL) == 0)) {
 183                         /*To avoid insert MEDIA_ROOT_PATH_EXTERNAL path*/
 184                         SAFE_FREE(dir_path);
 185                         continue;
 186                 }
 187
 188                 ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, dir_path, tmp_folder_uuid, uid);
 189                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 190                         folder_uuid = _media_info_generate_uuid();
 191                         if (folder_uuid == NULL) {
 192                                 media_svc_error("Invalid UUID");
 193                                 SAFE_FREE(dir_path);
 194                                 return MS_MEDIA_ERR_INTERNAL;
 195                         }
 196
 197                         ret = __media_svc_append_folder(storage_id, storage_type, folder_uuid, dir_path, FALSE, uid);
 198                         if (ret != MS_MEDIA_ERR_NONE)
 199                                 media_svc_error("__media_svc_append_folder is failed");
 200
 201                         media_svc_error("[No-Error] New Appended folder path [%s], folder_uuid [%s]", dir_path, folder_uuid);
 202                 } else {
 203                         media_svc_error("EXIST dir path : %s", dir_path);
 204                 }
 205
 206                 SAFE_FREE(dir_path);
 207         }
 208
 209         if (STRING_VALID(folder_uuid)) {
 210                 SAFE_STRLCPY(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE + 1);
 211         } else {
 212                 media_svc_error("Fail to get folder_uuid");
 213                 return MS_MEDIA_ERR_INTERNAL;
 214         }
 215
 216         return MS_MEDIA_ERR_NONE;
 217 }
 218
 219 static int __media_svc_update_parent_folder_validity(sqlite3 *handle, const char *storage_id, const char *path, uid_t uid)
 220 {
 221         int ret = MS_MEDIA_ERR_NONE;
 222         unsigned int next_pos = 0;
 223         char *next = NULL;
 224         char *dir_path = NULL;
 225         const char *token = "/";
 226         bool folder_search_end = FALSE;
 227         char *internal_path = NULL;
 228
 229         ret = ms_user_get_internal_root_path(uid, &internal_path);
 230         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "Fail to get root path");
 231
 232         if (STRING_VALID(internal_path) && (strncmp(path, internal_path, strlen(internal_path)) == 0))
 233                 next_pos = strlen(internal_path);
 234         else if (STRING_VALID(MEDIA_ROOT_PATH_SDCARD) && strncmp(path, MEDIA_ROOT_PATH_SDCARD, strlen(MEDIA_ROOT_PATH_SDCARD)) == 0)
 235                 next_pos = strlen(MEDIA_ROOT_PATH_SDCARD);
 236         else if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && strncmp(path, MEDIA_ROOT_PATH_EXTERNAL, strlen(MEDIA_ROOT_PATH_EXTERNAL)) == 0)
 237                 next_pos = strlen(MEDIA_ROOT_PATH_EXTERNAL);
 238         else if (STRING_VALID(MEDIA_ROOT_PATH_DISC) && strncmp(path, MEDIA_ROOT_PATH_DISC, strlen(MEDIA_ROOT_PATH_DISC)) == 0)
 239                 next_pos = strlen(MEDIA_ROOT_PATH_DISC);
 240         else {
 241                 media_svc_error("Invalid Path");
 242                 media_svc_sec_error("Invalid Path [%s], internal_path [%s]", path, internal_path);
 243                 SAFE_FREE(internal_path);
 244                 return MS_MEDIA_ERR_INTERNAL;
 245         }
 246
 247         SAFE_FREE(internal_path);
 248
 249         while (!folder_search_end) {
 250                 next = strstr(path + next_pos, token);
 251                 if (next != NULL) {
 252                         next_pos = (next - path);
 253                         dir_path = strndup(path, next_pos);
 254                         next_pos++;
 255                 } else {
 256                         dir_path = strndup(path, strlen(path));
 257                         folder_search_end = TRUE;
 258                         media_svc_error("[No-Error] End Path [%s]", dir_path);
 259                 }
 260
 261                 if (STRING_VALID(MEDIA_ROOT_PATH_EXTERNAL) && (g_strcmp0(dir_path, MEDIA_ROOT_PATH_EXTERNAL) == 0)) {
 262                         /*To avoid insert MEDIA_ROOT_PATH_EXTERNAL path*/
 263                         SAFE_FREE(dir_path);
 264                         continue;
 265                 }
 266
 267                 ret = _media_svc_set_folder_validity(handle, storage_id, dir_path, 1, false, uid);
 268                 SAFE_FREE(dir_path);
 269                 media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "Fail to set folder validity");
 270         }
 271
 272         return MS_MEDIA_ERR_NONE;
 273 }
 274
 275 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)
 276 {
 277         int ret = MS_MEDIA_ERR_NONE;
 278         int validity = -1;
 279
 280         ret = _media_svc_get_folder_id_by_foldername_with_validity(handle, storage_id, path, folder_id, uid, &validity);
 281
 282         if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 283                 ret = __media_svc_get_and_append_parent_folder(handle, storage_id, path, storage_type, folder_id, uid);
 284         else if (ret == MS_MEDIA_ERR_NONE && validity == 0)
 285                 ret = __media_svc_update_parent_folder_validity(handle, storage_id, path, uid);
 286
 287         return ret;
 288 }
 289
 290 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)
 291 {
 292         char *dir_path = NULL;
 293         int ret = MS_MEDIA_ERR_NONE;
 294
 295         dir_path = g_path_get_dirname(path);
 296
 297         ret = _media_svc_get_and_append_folder(handle, storage_id, dir_path, storage_type, folder_id, uid);
 298
 299         SAFE_FREE(dir_path);
 300
 301         return ret;
 302 }
 303
 304 int _media_svc_update_folder_table(const char *storage_id, uid_t uid)
 305 {
 306         int ret = MS_MEDIA_ERR_NONE;
 307         char *sql = NULL;
 308
 309         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'));",
 310                 MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_FOLDER, storage_id);
 311
 312         ret = _media_svc_sql_query(sql, uid);
 313         SQLITE3_SAFE_FREE(sql);
 314
 315         return ret;
 316 }
 317
 318 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)
 319 {
 320         int ret = MS_MEDIA_ERR_NONE;
 321         sqlite3_stmt *sql_stmt = NULL;
 322
 323         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);
 324
 325         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 326
 327         if (ret != MS_MEDIA_ERR_NONE) {
 328                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 329                         media_svc_debug("there is no folder.");
 330                 else
 331                         media_svc_error("error when _media_svc_get_folder_id_by_foldername. err = [%d]", ret);
 332
 333                 return ret;
 334         }
 335
 336         SAFE_STRLCPY(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE + 1);
 337         *modified_time = (int)sqlite3_column_int(sql_stmt, 1);
 338
 339         SQLITE3_FINALIZE(sql_stmt);
 340
 341         return ret;
 342 }
 343
 344 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)
 345 {
 346         char *path_name = NULL;
 347         int ret = MS_MEDIA_ERR_NONE;
 348         char *sql = NULL;
 349
 350         path_name = strdup(path);
 351         if (path_name == NULL) {
 352                 media_svc_error("out of memory");
 353                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
 354         }
 355
 356         ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, path_name, folder_id, uid);
 357         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 358                 ret = __media_svc_get_and_append_parent_folder(handle, storage_id, path_name, storage_type, folder_id, uid);
 359         } else {
 360                 sql = sqlite3_mprintf("UPDATE '%s' SET validity=1 WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 361                 if (!stack_query) {
 362                         ret = _media_svc_sql_query(sql, uid);
 363                         SQLITE3_SAFE_FREE(sql);
 364                 } else {
 365                         _media_svc_sql_query_add(&g_media_svc_insert_folder_query_list, &sql);
 366                 }
 367         }
 368
 369         SAFE_FREE(path_name);
 370
 371         return ret;
 372 }
 373
 374 int _media_svc_delete_invalid_folder(const char *storage_id, int storage_type, uid_t uid)
 375 {
 376         int ret = MS_MEDIA_ERR_NONE;
 377         char *sql = NULL;
 378
 379         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);
 380         ret = _media_svc_sql_query(sql, uid);
 381
 382         SQLITE3_SAFE_FREE(sql);
 383
 384         return ret;
 385 }
 386
 387 int _media_svc_set_folder_validity(sqlite3 *handle, const char *storage_id, const char *start_path, int validity, bool is_recursive, uid_t uid)
 388 {
 389         int ret = MS_MEDIA_ERR_NONE;
 390         char *sql = NULL;
 391         char start_path_id[MEDIA_SVC_UUID_SIZE+1] = {0,};
 392
 393         if (is_recursive) {
 394                 ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, start_path, start_path_id, uid);
 395                 media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "_media_svc_get_folder_id_by_foldername fail");
 396                 media_svc_retvm_if(!STRING_VALID(start_path_id), MS_MEDIA_ERR_INVALID_PARAMETER, "start_path_id is NULL");
 397
 398                 sql = sqlite3_mprintf("UPDATE '%s' SET validity = %d WHERE storage_uuid = '%q' AND (path LIKE '%q/%%' OR folder_uuid ='%q');",
 399                                                 MEDIA_SVC_DB_TABLE_FOLDER, validity, storage_id, start_path, start_path_id);
 400         } else {
 401                 sql = sqlite3_mprintf("UPDATE '%s' SET validity = %d WHERE storage_uuid = '%q' AND path = '%q';",
 402                                                 MEDIA_SVC_DB_TABLE_FOLDER, validity, storage_id, start_path);
 403         }
 404
 405         ret = _media_svc_sql_query(sql, uid);
 406
 407         SQLITE3_SAFE_FREE(sql);
 408
 409         return ret;
 410 }
 411
 412 int _media_svc_delete_folder_by_storage_id(const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid)
 413 {
 414         int ret = MS_MEDIA_ERR_NONE;
 415         char *sql = NULL;
 416
 417         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid = '%q' AND storage_type = %d;", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, storage_type);
 418         ret = _media_svc_sql_query(sql, uid);
 419
 420         SQLITE3_SAFE_FREE(sql);
 421
 422         return ret;
 423 }
 424
 425 GList **_media_svc_get_folder_list_ptr(void)
 426 {
 427         return &g_media_svc_insert_folder_query_list;
 428 }
 429
 430 int _media_svc_get_folder_scan_status(sqlite3 *handle, const char *storage_id, const char *path, int *scan_status)
 431 {
 432         int ret = MS_MEDIA_ERR_NONE;
 433         sqlite3_stmt *sql_stmt = NULL;
 434         char *sql = NULL;
 435
 436         if (!STRING_VALID(path)) {
 437                 media_svc_error("Not found valid path");
 438                 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
 439         }
 440
 441         sql = sqlite3_mprintf("SELECT scan_status FROM '%s' WHERE path = '%q' AND storage_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, path, storage_id);
 442
 443         ret = _media_svc_sql_prepare_to_step_simple(handle, sql, &sql_stmt);
 444
 445         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 446
 447         while (sqlite3_step(sql_stmt) == SQLITE_ROW)
 448                 *scan_status = sqlite3_column_int(sql_stmt, 0);
 449
 450         SQLITE3_FINALIZE(sql_stmt);
 451
 452         return ret;
 453 }
 454
 455 int _media_svc_set_folder_scan_status(const char *storage_id, const char *path, int scan_status, uid_t uid)
 456 {
 457         int ret = MS_MEDIA_ERR_NONE;
 458         char *sql = NULL;
 459
 460         if (path)
 461                 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);
 462         else
 463                 sql = sqlite3_mprintf("UPDATE '%s' SET scan_status=%d WHERE storage_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, scan_status, storage_id);
 464
 465         ret = _media_svc_sql_query(sql, uid);
 466         SQLITE3_SAFE_FREE(sql);
 467
 468         return ret;
 469 }
 470
 471 int _media_svc_get_folder_modified_time_by_path(sqlite3 *handle, const char *path, const char *storage_id, time_t *modified_time)
 472 {
 473         int ret = MS_MEDIA_ERR_NONE;
 474         sqlite3_stmt *sql_stmt = NULL;
 475
 476         char *sql = sqlite3_mprintf("SELECT modified_time FROM '%s' WHERE path = '%q' AND storage_uuid = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, path, storage_id);
 477
 478         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 479
 480         if (ret != MS_MEDIA_ERR_NONE) {
 481                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 482                         media_svc_debug("there is no folder.");
 483                 else
 484                         media_svc_error("error when _media_svc_get_folder_modified_time_by_path. err = [%d]", ret);
 485
 486                 return ret;
 487         }
 488
 489         *modified_time = (int)sqlite3_column_int(sql_stmt, 0);
 490
 491         SQLITE3_FINALIZE(sql_stmt);
 492
 493         return ret;
 494 }
 495
 496 int _media_svc_get_null_scan_folder_list(sqlite3 *handle, const char *storage_id, const char *path, char ***folder_list, int *count)
 497 {
 498         int ret = MS_MEDIA_ERR_NONE;
 499         int idx = 0;
 500         int cnt = 0;
 501         char *sql = NULL;
 502         sqlite3_stmt *sql_stmt = NULL;
 503
 504         if (path == NULL) {
 505                 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);
 506                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 507
 508                 if (ret != MS_MEDIA_ERR_NONE) {
 509                         if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 510                                 media_svc_debug("there is no folder.");
 511                         else
 512                                 media_svc_error("error when get folder_id by path. err = [%d]", ret);
 513
 514                         *folder_list = NULL;
 515                         *count = 0;
 516
 517                         return ret;
 518                 }
 519
 520                 cnt = sqlite3_column_int(sql_stmt, 0);
 521                 SQLITE3_FINALIZE(sql_stmt);
 522                 if (cnt > 0) {
 523                         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);
 524                 } else {
 525                         *folder_list = NULL;
 526                         *count = 0;
 527
 528                         return MS_MEDIA_ERR_INTERNAL;
 529                 }
 530
 531                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 532
 533                 if (ret != MS_MEDIA_ERR_NONE) {
 534                         media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 535
 536                         *folder_list = NULL;
 537                         *count = 0;
 538
 539                         return ret;
 540                 }
 541         } else {
 542                 sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE path IN (SELECT DISTINCT '%q/'||name from '%s' WHERE path LIKE '%q/%%')",
 543                         MEDIA_SVC_DB_TABLE_FOLDER, path, MEDIA_SVC_DB_TABLE_FOLDER, path);
 544                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 545
 546                 if (ret != MS_MEDIA_ERR_NONE) {
 547                         media_svc_error("error when _media_svc_sql_prepare_to_step. err = [%d]", ret);
 548                         return ret;
 549                 }
 550
 551                 cnt = sqlite3_column_int(sql_stmt, 0);
 552                 SQLITE3_FINALIZE(sql_stmt);
 553                 if (cnt > 0) {
 554                         sql = sqlite3_mprintf("SELECT path FROM '%s' WHERE path IN (SELECT DISTINCT '%q/'||name from '%s' WHERE path LIKE '%q/%%')",
 555                                 MEDIA_SVC_DB_TABLE_FOLDER, path, MEDIA_SVC_DB_TABLE_FOLDER, path);
 556                 } else {
 557                         *folder_list = NULL;
 558                         *count = 0;
 559
 560                         return MS_MEDIA_ERR_NONE;
 561                 }
 562
 563                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 564
 565                 if (ret != MS_MEDIA_ERR_NONE) {
 566                         media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 567
 568                         *folder_list = NULL;
 569                         *count = 0;
 570
 571                         return ret;
 572                 }
 573         }
 574
 575         *folder_list = malloc(sizeof(char *) * cnt);
 576         if (*folder_list == NULL) {
 577                 media_svc_error("Allocation failed");
 578
 579                 *folder_list = NULL;
 580                 *count = 0;
 581
 582                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
 583         }
 584
 585         while (1) {
 586                 (*folder_list)[idx] = strdup((char *)sqlite3_column_text(sql_stmt, 0));
 587
 588                 if (sqlite3_step(sql_stmt) != SQLITE_ROW)
 589                         break;
 590                 idx++;
 591         }
 592
 593         if (cnt == idx + 1) {
 594                 *count = cnt;
 595                 media_svc_debug("OK");
 596         } else {
 597                 /* free all data */
 598                 int i = 0;
 599                 for (i  = 0; i < idx; i++)
 600                         SAFE_FREE((*folder_list)[i]);
 601
 602                 SAFE_FREE(*folder_list);
 603                 *count = 0;
 604                 ret = MS_MEDIA_ERR_INTERNAL;
 605         }
 606
 607         SQLITE3_FINALIZE(sql_stmt);
 608
 609         return ret;
 610 }
 611
 612 int _media_svc_count_folder_with_path(sqlite3 *handle, const char *storage_id, const char *path, int *count)
 613 {
 614         int ret = MS_MEDIA_ERR_NONE;
 615         sqlite3_stmt *sql_stmt = NULL;
 616
 617         char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE (storage_uuid='%q' AND path='%q')", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 618
 619         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 620
 621         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 622
 623         *count = sqlite3_column_int(sql_stmt, 0);
 624
 625         SQLITE3_FINALIZE(sql_stmt);
 626
 627         return MS_MEDIA_ERR_NONE;
 628 }
 629
 630 int _media_svc_get_folder_uuid(sqlite3 *handle, const char *storage_id, const char *path, char *folder_id)
 631 {
 632         int ret = MS_MEDIA_ERR_NONE;
 633         sqlite3_stmt *sql_stmt = NULL;
 634         char *sql = NULL;
 635
 636         sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE (storage_uuid='%q' AND path='%q')", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
 637
 638         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 639
 640         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 641
 642         SAFE_STRLCPY(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE+1);
 643
 644         SQLITE3_FINALIZE(sql_stmt);
 645
 646         if (!STRING_VALID(folder_id)) {
 647                 media_svc_error("Not found valid storage id [%s]", path);
 648                 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
 649         }
 650
 651         return ret;
 652 }
 653