src/common/media-svc-storage.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 "media-util-err.h"
  23 #include "media-svc-debug.h"
  24 #include "media-svc-env.h"
  25 #include "media-svc-db-utils.h"
  26 #include "media-svc-util.h"
  27 #include "media-svc-storage.h"
  28
  29 int _media_svc_init_storage(sqlite3 *handle, uid_t uid)
  30 {
  31         int ret = MS_MEDIA_ERR_NONE;
  32         char *sql = NULL;
  33         sqlite3_stmt *sql_stmt = NULL;
  34         int storage_cnt = 0;
  35
  36         /*Add Internal storage*/
  37         sql = sqlite3_mprintf("SELECT COUNT(*) FROM '%s' WHERE storage_uuid='%s' AND storage_name='%s'", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_MEDIA);
  38         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
  39         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
  40
  41         storage_cnt = sqlite3_column_int(sql_stmt, 0);
  42         SQLITE3_FINALIZE(sql_stmt);
  43
  44         if (storage_cnt == 0) {
  45                 char *internal_path = _media_svc_get_path(uid);
  46                 sql = sqlite3_mprintf("INSERT INTO %s (storage_uuid, storage_name, storage_path, storage_type) VALUES ('%s', '%s', '%s', 0);",
  47                                                 MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_MEDIA, internal_path);
  48
  49                 ret = _media_svc_sql_query(sql, uid);
  50                 SQLITE3_SAFE_FREE(sql);
  51                 SAFE_FREE(internal_path);
  52                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
  53         }
  54
  55         return ret;
  56 }
  57
  58 int _media_svc_get_mmc_info(MediaSvcHandle *handle, char **storage_name, char **storage_path, int *validity, bool *info_exist)
  59 {
  60         int ret = MS_MEDIA_ERR_NONE;
  61         sqlite3_stmt *sql_stmt = NULL;
  62         char *sql = NULL;
  63
  64         sql = sqlite3_mprintf("SELECT * FROM '%s' WHERE storage_uuid=%Q", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_MEDIA);
  65
  66         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
  67         if (ret != MS_MEDIA_ERR_NONE) {
  68                 *storage_name = NULL;
  69                 *storage_path = NULL;
  70                 *validity = 0;
  71                 *info_exist = FALSE;
  72
  73                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
  74                         *info_exist = FALSE;
  75
  76                 return ret;
  77         }
  78
  79         *storage_name = g_strdup((const char *)sqlite3_column_text(sql_stmt, 1));
  80         *storage_path = g_strdup((const char *)sqlite3_column_text(sql_stmt, 2));
  81         *validity = sqlite3_column_int(sql_stmt, 6);
  82
  83         *info_exist = TRUE;
  84
  85         SQLITE3_FINALIZE(sql_stmt);
  86
  87         return MS_MEDIA_ERR_NONE;
  88 }
  89
  90 int _media_svc_check_storage(sqlite3 *handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity, uid_t uid)
  91 {
  92         int ret = MS_MEDIA_ERR_NONE;
  93         sqlite3_stmt *sql_stmt = NULL;
  94         char *sql = NULL;
  95
  96         *storage_path = NULL;
  97         *validity = 0;
  98
  99         if (storage_name != NULL)
 100                 sql = sqlite3_mprintf("SELECT * FROM '%s' WHERE storage_uuid=%Q AND storage_name=%Q", MEDIA_SVC_DB_TABLE_STORAGE, storage_id, storage_name);
 101         else
 102                 sql = sqlite3_mprintf("SELECT * FROM '%s' WHERE storage_uuid=%Q", MEDIA_SVC_DB_TABLE_STORAGE, storage_id);
 103
 104         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 105
 106         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 107
 108         *storage_path = g_strdup((const char *)sqlite3_column_text(sql_stmt, 2));
 109         *validity = sqlite3_column_int(sql_stmt, 6);
 110
 111         SQLITE3_FINALIZE(sql_stmt);
 112
 113         /*check storage media table*/
 114         if (STRING_VALID(storage_id)) {
 115                 int table_cnt = 0;
 116
 117                 /*Select list of storage*/
 118                 sql = sqlite3_mprintf("SELECT COUNT(*) FROM SQLITE_MASTER WHERE type='table' and name='%q'", storage_id);
 119                 ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 120                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 121
 122                 table_cnt = sqlite3_column_int(sql_stmt, 0);
 123                 SQLITE3_FINALIZE(sql_stmt);
 124
 125                 if (table_cnt > 0) {
 126                         /*DO NOT THING*/
 127                 } else {
 128                         media_svc_error("media table not exist for storage [%s]", storage_id);
 129                         /*make storage media table*/
 130                         ret = _media_svc_create_media_table_with_id(storage_id, uid);
 131                         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "create media table failed : %d", ret);
 132                 }
 133         }
 134
 135         return MS_MEDIA_ERR_NONE;
 136 }
 137
 138 int _media_svc_append_storage(const char *storage_id, const char *storage_name, const char *storage_path, media_svc_storage_type_e storage_type, uid_t uid)
 139 {
 140         int ret = MS_MEDIA_ERR_NONE;
 141         char *sql = sqlite3_mprintf("INSERT INTO %s (storage_uuid, storage_name, storage_path, storage_type) values (%Q, %Q, %Q, %d); ",
 142                                                 MEDIA_SVC_DB_TABLE_STORAGE, storage_id, storage_name, storage_path, storage_type);
 143
 144         ret = _media_svc_sql_query(sql, uid);
 145         SQLITE3_SAFE_FREE(sql);
 146
 147         return ret;
 148 }
 149
 150 int _media_svc_update_storage_path(sqlite3 *handle, const char *storage_id, const char *path, uid_t uid)
 151 {
 152         int ret = MS_MEDIA_ERR_NONE;
 153         char *sql = NULL;
 154         char *old_storage_path = NULL;
 155         int validity = 0;
 156
 157         /*Get old path*/
 158         ret = _media_svc_check_storage(handle, storage_id, NULL, &old_storage_path, &validity, uid);
 159         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 160
 161         /*Storage table update*/
 162         sql = sqlite3_mprintf("UPDATE '%s' SET storage_path=%Q WHERE storage_uuid=%Q;", MEDIA_SVC_DB_TABLE_STORAGE, path, storage_id);
 163         ret = _media_svc_sql_query(sql, uid);
 164         SQLITE3_SAFE_FREE(sql);
 165         if (ret != MS_MEDIA_ERR_NONE) {
 166                 G_SAFE_FREE(old_storage_path);
 167                 return ret;
 168         }
 169
 170         /*Folder table update*/
 171         sql = sqlite3_mprintf("UPDATE '%s' SET path=REPLACE(path, %Q, %Q) WHERE storage_uuid=%Q;", MEDIA_SVC_DB_TABLE_FOLDER, old_storage_path, path, storage_id);
 172         ret = _media_svc_sql_query(sql, uid);
 173         SQLITE3_SAFE_FREE(sql);
 174         if (ret != MS_MEDIA_ERR_NONE) {
 175                 G_SAFE_FREE(old_storage_path);
 176                 return ret;
 177         }
 178
 179         /*Media table update*/
 180         sql = sqlite3_mprintf("UPDATE '%s' SET path=REPLACE(path, %Q, %Q);", storage_id, old_storage_path, path);
 181         ret = _media_svc_sql_query(sql, uid);
 182         SQLITE3_SAFE_FREE(sql);
 183         G_SAFE_FREE(old_storage_path);
 184         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 185
 186         return ret;
 187 }
 188
 189 int _media_svc_delete_storage(const char *storage_id, const char *storage_name, uid_t uid)
 190 {
 191         int ret = MS_MEDIA_ERR_NONE;
 192         char *sql = NULL;
 193
 194         if (storage_name != NULL)
 195                         sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid=%Q AND storage_name=%Q;", MEDIA_SVC_DB_TABLE_STORAGE, storage_id, storage_name);
 196         else if (storage_id != NULL)
 197                 sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid=%Q;", MEDIA_SVC_DB_TABLE_STORAGE, storage_id);
 198
 199         ret = _media_svc_sql_query(sql, uid);
 200         SQLITE3_SAFE_FREE(sql);
 201
 202         return ret;
 203 }
 204
 205 int _media_svc_update_storage_validity(const char *storage_id, int validity, uid_t uid)
 206 {
 207         int ret = MS_MEDIA_ERR_NONE;
 208         char *sql = NULL;
 209
 210         if (storage_id == NULL)
 211                 sql = sqlite3_mprintf("UPDATE '%s' SET validity=%d WHERE storage_uuid != 'media';", MEDIA_SVC_DB_TABLE_STORAGE, validity);
 212         else
 213                 sql = sqlite3_mprintf("UPDATE '%s' SET validity=%d WHERE storage_uuid=%Q;", MEDIA_SVC_DB_TABLE_STORAGE, validity, storage_id);
 214
 215         ret = _media_svc_sql_query(sql, uid);
 216         SQLITE3_SAFE_FREE(sql);
 217
 218         return ret;
 219 }
 220
 221 int _media_svc_get_storage_uuid(sqlite3 *handle, const char *path, char *storage_id, uid_t uid)
 222 {
 223         int ret = MS_MEDIA_ERR_NONE;
 224         sqlite3_stmt *sql_stmt = NULL;
 225         char *sql = NULL;
 226         char *storage_path = NULL;
 227         char *remain_path = NULL;
 228         int remain_len = 0;
 229         char *internal_path = NULL;
 230
 231         internal_path = _media_svc_get_path(uid);
 232
 233         if (STRING_VALID(internal_path) && strncmp(path, internal_path, strlen(internal_path)) == 0) {
 234                 _strncpy_safe(storage_id, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_UUID_SIZE+1);
 235                 SAFE_FREE(internal_path);
 236                 return MS_MEDIA_ERR_NONE;
 237         }
 238
 239         SAFE_FREE(internal_path);
 240
 241         remain_path = strstr(path + (STRING_VALID(MEDIA_ROOT_PATH_USB) ? strlen(MEDIA_ROOT_PATH_USB) : 0) + 1, "/");
 242         if (remain_path != NULL)
 243                 remain_len = strlen(remain_path);
 244
 245         storage_path = strndup(path, strlen(path) - remain_len);
 246
 247         sql = sqlite3_mprintf("SELECT storage_uuid FROM '%s' WHERE validity=1 AND storage_path = '%s'", MEDIA_SVC_DB_TABLE_STORAGE, storage_path);
 248
 249         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 250
 251         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 252         if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 0)))
 253                 _strncpy_safe(storage_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE+1);
 254
 255         SQLITE3_FINALIZE(sql_stmt);
 256         SAFE_FREE(storage_path);
 257
 258         if (!STRING_VALID(storage_id)) {
 259                 media_svc_error("Not found valid storage id [%s]", path);
 260                 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
 261         }
 262
 263         return ret;
 264 }
 265
 266 int _media_svc_get_storage_type(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e *storage_type)
 267 {
 268         int ret = MS_MEDIA_ERR_NONE;
 269         sqlite3_stmt *sql_stmt = NULL;
 270         char *sql = NULL;
 271
 272         if (!STRING_VALID(storage_id)) {
 273                 media_svc_error("Invalid storage_id");
 274                 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
 275         }
 276
 277         sql = sqlite3_mprintf("SELECT storage_type FROM '%s' WHERE storage_uuid=%Q", MEDIA_SVC_DB_TABLE_STORAGE, storage_id);
 278
 279         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 280
 281         if (ret != MS_MEDIA_ERR_NONE) {
 282                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 283                         media_svc_debug("there is no storage.");
 284                 else
 285                         media_svc_error("error when _media_svc_get_storage_type. err = [%d]", ret);
 286
 287                 return ret;
 288         }
 289
 290         *storage_type = sqlite3_column_int(sql_stmt, 0);
 291
 292         SQLITE3_FINALIZE(sql_stmt);
 293
 294         return ret;
 295 }
 296
 297 int _media_svc_get_storage_path(sqlite3 *handle, const char *storage_id, char **storage_path)
 298 {
 299         int ret = MS_MEDIA_ERR_NONE;
 300         sqlite3_stmt *sql_stmt = NULL;
 301         char *sql = NULL;
 302
 303         if (!STRING_VALID(storage_id)) {
 304                 media_svc_error("Invalid storage_id");
 305                 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
 306         }
 307
 308         sql = sqlite3_mprintf("SELECT storage_path FROM '%s' WHERE (storage_uuid=%Q AND validity=1)", MEDIA_SVC_DB_TABLE_STORAGE, storage_id);
 309
 310         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 311
 312         if (ret != MS_MEDIA_ERR_NONE) {
 313                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 314                         media_svc_debug("there is no storage.");
 315                 else
 316                         media_svc_error("error when _media_svc_get_storage_type. err = [%d]", ret);
 317
 318                 return ret;
 319         }
 320
 321         *storage_path = g_strdup((char *)sqlite3_column_text(sql_stmt, 0));
 322
 323         SQLITE3_FINALIZE(sql_stmt);
 324
 325         return ret;
 326 }
 327
 328 int _media_svc_get_storage_scan_status(sqlite3 *handle, const char *storage_id, media_svc_scan_status_type_e *scan_status)
 329 {
 330         int ret = MS_MEDIA_ERR_NONE;
 331         sqlite3_stmt *sql_stmt = NULL;
 332         char *sql = NULL;
 333
 334         if (!STRING_VALID(storage_id)) {
 335                 media_svc_error("Invalid storage_id");
 336                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 337         }
 338
 339         sql = sqlite3_mprintf("SELECT scan_status FROM '%s' WHERE (storage_uuid=%Q AND validity=1)", MEDIA_SVC_DB_TABLE_STORAGE, storage_id);
 340
 341         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 342         if (ret != MS_MEDIA_ERR_NONE) {
 343                 if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
 344                         media_svc_debug("there is no storage.");
 345                 else
 346                         media_svc_error("error when _media_svc_get_storage_scan_status. err = [%d]", ret);
 347
 348                 return ret;
 349         }
 350
 351         *scan_status = sqlite3_column_int(sql_stmt, 0);
 352
 353         SQLITE3_FINALIZE(sql_stmt);
 354
 355         return ret;
 356 }
 357
 358 int _media_svc_set_storage_scan_status(const char *storage_id, media_svc_scan_status_type_e scan_status, uid_t uid)
 359 {
 360         int ret = MS_MEDIA_ERR_NONE;
 361         char *sql = NULL;
 362
 363         if (storage_id == NULL)
 364                 sql = sqlite3_mprintf("UPDATE '%s' SET scan_status=%d WHERE storage_uuid != 'media';", MEDIA_SVC_DB_TABLE_STORAGE, scan_status);
 365         else
 366                 sql = sqlite3_mprintf("UPDATE '%s' SET scan_status=%d WHERE storage_uuid=%Q;", MEDIA_SVC_DB_TABLE_STORAGE, scan_status, storage_id);
 367
 368         ret = _media_svc_sql_query(sql, uid);
 369         SQLITE3_SAFE_FREE(sql);
 370
 371         return ret;
 372 }
 373
 374 static int __media_svc_count_all_storage(sqlite3 *handle, int *count)
 375 {
 376         int ret = MS_MEDIA_ERR_NONE;
 377         sqlite3_stmt *sql_stmt = NULL;
 378         char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE validity = 1", MEDIA_SVC_DB_TABLE_STORAGE);
 379
 380         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 381         if (ret != MS_MEDIA_ERR_NONE) {
 382                 media_svc_error("error when _media_svc_sql_prepare_to_step. err = [%d]", ret);
 383                 return ret;
 384         }
 385
 386         *count = sqlite3_column_int(sql_stmt, 0);
 387
 388         SQLITE3_FINALIZE(sql_stmt);
 389
 390         return MS_MEDIA_ERR_NONE;
 391 }
 392
 393 int _media_svc_get_all_storage(sqlite3 *handle, char ***storage_list, char ***storage_id_list, int **scan_status_list, int *count)
 394 {
 395         int ret = MS_MEDIA_ERR_NONE;
 396         int idx = 0;
 397         sqlite3_stmt *sql_stmt = NULL;
 398         char *sql = NULL;
 399         int cnt = 0;
 400
 401         ret = __media_svc_count_all_storage(handle, &cnt);
 402         if (ret != MS_MEDIA_ERR_NONE) {
 403                 media_svc_error("error when __media_svc_count_all_folders. err = [%d]", ret);
 404                 return ret;
 405         }
 406
 407         if (cnt > 0) {
 408                 sql = sqlite3_mprintf("SELECT storage_path, storage_uuid, scan_status FROM '%s' WHERE validity = 1", MEDIA_SVC_DB_TABLE_STORAGE);
 409         } else {
 410                 *storage_list = NULL;
 411                 *scan_status_list = NULL;
 412                 return MS_MEDIA_ERR_NONE;
 413         }
 414
 415         *storage_list = malloc(sizeof(char *) * cnt);
 416         *storage_id_list = malloc(sizeof(char *) * cnt);
 417         *scan_status_list = malloc(sizeof(int) * cnt);
 418
 419         ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 420         if (ret != MS_MEDIA_ERR_NONE) {
 421                 media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
 422                 SAFE_FREE(*storage_list);
 423                 SAFE_FREE(*scan_status_list);
 424                 return ret;
 425         }
 426
 427         media_svc_debug("QEURY OK");
 428
 429         while (1) {
 430                 (*storage_list)[idx] = g_strdup((char *)sqlite3_column_text(sql_stmt, 0));
 431                 (*storage_id_list)[idx] = g_strdup((char *)sqlite3_column_text(sql_stmt, 1));
 432                 (*scan_status_list)[idx] = (int)sqlite3_column_int(sql_stmt, 2);
 433                 if (sqlite3_step(sql_stmt) != SQLITE_ROW)
 434                         break;
 435                 idx++;
 436         }
 437
 438         if (cnt == idx + 1) {
 439                 *count = cnt;
 440                 media_svc_debug("OK");
 441         } else {
 442                 /* free all data */
 443                 int i = 0;
 444                 for (i = 0; i < idx; i++) {
 445                         SAFE_FREE((*storage_list)[i]);
 446                         SAFE_FREE((*storage_id_list)[i]);
 447                 }
 448                 SAFE_FREE(*storage_list);
 449                 SAFE_FREE(*storage_id_list);
 450                 SAFE_FREE(*scan_status_list);
 451                 *count = 0;
 452                 ret = MS_MEDIA_ERR_INTERNAL;
 453         }
 454
 455         SQLITE3_FINALIZE(sql_stmt);
 456
 457         return ret;
 458 }