Sync with tizen_3.0 branch

Change-Id: I9b59fef7d773668b03420a32a6564eaf09c2a5b4
Signed-off-by: Minje Ahn <minje.ahn@samsung.com>

diff --git a/packaging/media-server.spec b/packaging/media-server.spec
index 962705e..0f461d5 100755 (executable)
--- a/packaging/media-server.spec
+++ b/packaging/media-server.spec
@@ -1,6 +1,6 @@
 Name:       media-server
 Summary:    A server for media content management
-Version:    0.3.27
+Version:    0.3.30
 Release:    0
 Group:      Multimedia/Service
 License:    Apache-2.0

diff --git a/src/common/include/media-common-db-svc.h b/src/common/include/media-common-db-svc.h
index de6c73c..66a6a80 100755 (executable)
--- a/src/common/include/media-common-db-svc.h
+++ b/src/common/include/media-common-db-svc.h
@@ -98,7 +98,7 @@ typedef int (*CHANGE_VALIDITY_ITEM_BATCH)(void *, const char *, const char *, in
 typedef int (*CHECK_DB)(void*, uid_t, char **);
 typedef int (*GET_UUID)(void *, char **, char **);
 typedef int (*GET_MMC_INFO)(void *, char **, char **, int *, bool *, char **);
-typedef int (*CHECK_STORAGE)(void *, const char *, const char *, char **, int *, char **);
+typedef int (*CHECK_STORAGE)(void *, const char *, const char *, char **, int *, uid_t, char **);
 typedef int (*INSERT_STORAGE)(void *, const char *, int, const char *, const char *, uid_t, char **);
 typedef int (*UPDATE_STORAGE)(void *, const char *, const char *, uid_t, char **);
 typedef int (*DELETE_STORAGE)(void *, const char *, const char *, uid_t, char **);
@@ -157,7 +157,7 @@ int ms_change_validity_item_batch(void **handle, const char *storage_id, const c
 int ms_check_db_upgrade(void **handle, uid_t uid);
 int ms_genarate_uuid(void **handle, char **uuid);
 int ms_get_mmc_info(void **handle, char **storage_name, char **storage_path, int *validity, bool *info_exist);
-int ms_check_storage(void **handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity);
+int ms_check_storage(void **handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity, uid_t uid);
 int ms_insert_storage(void **handle, const char *storage_id, const char *storage_name, const char *storage_path, uid_t uid);
 int ms_update_storage(void **handle, const char *storage_id, const char *storage_path, uid_t uid);
 int ms_delete_storage(void **handle, const char *storage_id, const char *storage_name, uid_t uid);

diff --git a/src/common/include/media-common-external-storage.h b/src/common/include/media-common-external-storage.h
index 4049022..2bb932b 100755 (executable)
--- a/src/common/include/media-common-external-storage.h
+++ b/src/common/include/media-common-external-storage.h
@@ -27,6 +27,7 @@
 int ms_present_mmc_status(ms_sdcard_status_type_t status);
 #endif
 
+void ms_make_default_path_mmc(const char *mount_path);
 int ms_get_mmc_id(char **cid);
 int ms_get_stg_changed_event(void);
 

diff --git a/src/common/media-common-db-svc.c b/src/common/media-common-db-svc.c
index 35dc37e..5932f52 100755 (executable)
--- a/src/common/media-common-db-svc.c
+++ b/src/common/media-common-db-svc.c
@@ -1144,7 +1144,7 @@ int ms_get_mmc_info(void **handle, char **storage_name, char **storage_path, int
        return res;
 }
 
-int ms_check_storage(void **handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity)
+int ms_check_storage(void **handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity, uid_t uid)
 {
        int lib_index = 0;
        int res = MS_MEDIA_ERR_NONE;
@@ -1154,7 +1154,7 @@ int ms_check_storage(void **handle, const char *storage_id, const char *storage_
        MS_DBG("ms_check_storage Start");
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((CHECK_STORAGE)func_array[lib_index][eCHECK_STORAGE])(handle[lib_index], storage_id, storage_name, storage_path, validity, &err_msg);
+               ret = ((CHECK_STORAGE)func_array[lib_index][eCHECK_STORAGE])(handle[lib_index], storage_id, storage_name, storage_path, validity, uid, &err_msg);
                if (ret != 0) {
                        MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
                        MS_SAFE_FREE(err_msg);

diff --git a/src/common/media-common-external-storage.c b/src/common/media-common-external-storage.c
index 83e278f..8acfcc1 100755 (executable)
--- a/src/common/media-common-external-storage.c
+++ b/src/common/media-common-external-storage.c
@@ -50,6 +50,57 @@
 
 #define MMC_INFO_SIZE 256
 
+char default_path[][MS_FILE_NAME_LEN_MAX+1] = {
+               {"Images"},
+               {"Videos"},
+               {"Sounds"},
+               {"Downloads"},
+};
+
+#define DIR_NUM        ((int)(sizeof(default_path)/sizeof(default_path[0])))
+
+void ms_make_default_path_mmc(const char *mount_path)
+{
+       int i = 0;
+       int ret = 0;
+       DIR *dp = NULL;
+       char *mmc_path = malloc(MS_FILE_NAME_LEN_MAX+1);
+
+       if (mmc_path == NULL) {
+               MS_DBG_ERR("allocation fail");
+               return;
+       }
+
+       for (i = 0; i < DIR_NUM; ++i) {
+               memset(mmc_path, 0, MS_FILE_NAME_LEN_MAX+1);
+               snprintf(mmc_path, MS_FILE_NAME_LEN_MAX, "%s/%s", mount_path, default_path[i]);
+               dp = opendir(mmc_path);
+               if (dp == NULL) {
+                       MS_DBG("%s path did not exist", mmc_path);
+                       ret = mkdir(mmc_path, 0770);
+                       if (ret < 0) {
+                               MS_DBG_ERR("make fail");
+                       }
+                       /*this fuction for emulator*/
+                       /*at the first time, the directroies are made permission 755*/
+                       ret = chmod(mmc_path, 0770);
+                       if (ret != 0) {
+                               MS_DBG_STRERROR("chmod failed");
+                       }
+                       /*
+                       ret = chown(default_path[i], 5000, 5000);
+                       if (ret != 0) {
+                               MS_DBG_STRERROR("chown failed");
+                       }
+                       */
+               } else {
+                       closedir(dp);
+               }
+       }
+
+       MS_SAFE_FREE(mmc_path);
+}
+
 static int __get_contents(const char *filename, char *buf)
 {
        FILE *fp;

diff --git a/src/server/media-server-device-block.c b/src/server/media-server-device-block.c
index f8fd997..366e46a 100755 (executable)
--- a/src/server/media-server-device-block.c
+++ b/src/server/media-server-device-block.c
@@ -45,9 +45,8 @@ static int __ms_get_added_stroage_path(void **handle, const char *add_path, char
                if (ret == MS_MEDIA_ERR_FILE_NOT_EXIST) {
                        ret = ms_genarate_uuid(handle, &id);
                        ret = ms_write_device_info(add_path , id);
-                       if (ret == MS_MEDIA_ERR_NONE) {
+                       if (ret == MS_MEDIA_ERR_NONE)
                                *device_id = strdup(id);
-                       }
                }
        } else {
                *device_id = strdup(id);
@@ -88,7 +87,7 @@ int ms_usb_insert_handler(const char *mount_path, const char *mount_uuid)
                }
 
                /* update storage information into media DB */
-               ret = ms_check_storage(handle, mount_uuid, NULL, &storage_path, &validity);
+               ret = ms_check_storage(handle, mount_uuid, NULL, &storage_path, &validity, uid);
                if (ret == 0) {
                        if (validity == 1) {
                                MS_DBG_ERR("This storage is already updated. So ignore this event.");
@@ -96,10 +95,10 @@ int ms_usb_insert_handler(const char *mount_path, const char *mount_uuid)
                                goto ERROR;
                        }
 
-                       if (strcmp(mount_path, storage_path)) {
-                               /* update storage path */
+                       /* update storage path */
+                       if (strcmp(mount_path, storage_path))
                                ret = ms_update_storage(handle, mount_uuid, mount_path, uid);
-                       }
+
                        scan_type = MS_SCAN_PART;
                        ms_set_storage_validity(handle, mount_uuid, 1, uid);
                        if (ms_set_storage_scan_status(handle, uuid, MEDIA_SCAN_PREPARE, uid) != MS_MEDIA_ERR_NONE) {
@@ -173,7 +172,7 @@ int ms_usb_remove_handler(const char *mount_path, const char *mount_uuid)
                ms_disconnect_db(&handle);
 
                ms_unload_functions();
-       }
+       }
 
        return ret;
 }
@@ -186,9 +185,8 @@ static ms_dir_scan_type_t __ms_get_mmc_scan_type(const char *cid, const char *st
        MS_DBG("Current MMC info = [%s]", cid);
 
        if (storage_name != NULL) {
-               if (strcmp(storage_name, cid) == 0) {
+               if (strcmp(storage_name, cid) == 0)
                        scan_type = MS_SCAN_PART;
-               }
        }
 
        if (scan_type == MS_SCAN_PART)
@@ -278,6 +276,7 @@ int ms_mmc_insert_handler(const char *mount_path)
        }
 
        ms_present_mmc_status(MS_SDCARD_INSERTED);
+       ms_make_default_path_mmc(mount_path);
 
        ms_get_mmc_id(&cid);
        /* CHECK DB HERE!! */
@@ -336,11 +335,10 @@ int ms_mmc_remove_handler(const char *mount_path)
                return MS_MEDIA_ERR_INTERNAL;
        }
 
-       if (mount_path == NULL) {
-               ret = ms_check_storage(handle, MMC_STORAGE_ID, NULL, &storage_path, &validity);
-       } else {
+       if (mount_path == NULL)
+               ret = ms_check_storage(handle, MMC_STORAGE_ID, NULL, &storage_path, &validity, uid);
+       else
                storage_path = strdup(mount_path);
-       }
 
        if (storage_path != NULL) {
                MS_DBG_WARN("mmc_path[%s]", storage_path);
@@ -435,7 +433,7 @@ static void __ms_usb_add_event(const char *mount_path)
 
                if (storage_id != NULL) {
                        /* update storage information into media DB */
-                       ret = ms_check_storage(handle, storage_id, NULL, &storage_path, &validity);
+                       ret = ms_check_storage(handle, storage_id, NULL, &storage_path, &validity, uid);
                        if (ret == 0) {
                                if (validity == 1) {
                                        MS_DBG_ERR("This storage is already updated. So ignore this event.");
@@ -448,7 +446,7 @@ static void __ms_usb_add_event(const char *mount_path)
                                }
                                scan_type = MS_SCAN_PART;
                                ms_set_storage_validity(handle, storage_id, 1, uid);
-                               if (ms_set_storage_scan_status(handle, storage_id, MEDIA_SCAN_PREPARE, uid) != MS_MEDIA_ERR_NONE){
+                               if (ms_set_storage_scan_status(handle, storage_id, MEDIA_SCAN_PREPARE, uid) != MS_MEDIA_ERR_NONE) {
                                        MS_DBG_ERR("ms_set_storage_scan_status failed");
                                }
                        } else {
@@ -462,7 +460,7 @@ static void __ms_usb_add_event(const char *mount_path)
 
                /* update storage_id table set validity=0 first */
                ms_validaty_change_all_items(handle, storage_id, MS_STORAGE_EXTERNAL_USB, false, uid);
-               //ms_set_folder_validity(handle, storage_id, mount_path, MS_INVALID, TRUE);
+               /*ms_set_folder_validity(handle, storage_id, mount_path, MS_INVALID, TRUE); */
                /* update folder table set scan_status=0 first */
                ms_set_folder_scan_status(handle, storage_id, NULL, MS_DIR_SCAN_NONE, uid);
 
@@ -497,7 +495,7 @@ static void __ms_usb_remove_event(const char *mount_path)
 
                ms_connect_db(&handle, uid);
 
-               while(1) {
+               while (1) {
                        memset(device_id, 0x0, sizeof(device_id));
                        ret = ms_get_storage_id(handle, mount_path, device_id, uid);
 
@@ -507,7 +505,7 @@ static void __ms_usb_remove_event(const char *mount_path)
                                ms_set_storage_validity(handle, device_id, 0, uid);
 
                                /* folder validity set 0 under the start_path in folder table*/
-                               if(ms_set_folder_validity(handle, device_id, mount_path, MS_INVALID, TRUE, uid) != MS_MEDIA_ERR_NONE) {
+                               if (ms_set_folder_validity(handle, device_id, mount_path, MS_INVALID, TRUE, uid) != MS_MEDIA_ERR_NONE) {
                                        MS_DBG_ERR("set_folder_validity failed");
                                }
 
@@ -532,7 +530,7 @@ static void __ms_usb_remove_event(const char *mount_path)
 
 void ms_device_block_changed_cb(usb_device_h usb_device, char *action, void *user_data)
 {
-       char *mount_path = NULL;
+       char *mount_path = NULL;
        bool is_reset = FALSE;
        uid_t uid = MEDIA_DEFAULT_UID;
 
@@ -591,25 +589,25 @@ static int __ms_check_mounted_storage_list(GArray **added_list)
                count = usb_device_list_get_count(list);
                if (count > 0) {
                        int i = 0;
-                       for(i = 0; i < count; i++) {
-                               if(i == 0) {
+                       for (i = 0; i < count; i++) {
+                               if (i == 0) {
                                        if (0 == usb_device_list_get_first(list, &device) && device != NULL) {
                                                mount_path = usb_device_get_mountpath(device);
                                                if (mount_path != NULL) {
                                                        MS_DBG_WARN("mount_path [%s]", mount_path);
                                                        storage_path = strdup(mount_path);
-                                                       g_array_append_val (*added_list, storage_path);
+                                                       g_array_append_val(*added_list, storage_path);
                                                }
                                        } else {
                                                MS_DBG_ERR(" FAILED TO usb_device_list_get_first \n");
                                        }
                                } else {
-                                       if(0 == usb_device_list_get_next(list, &device) && device != NULL ) {
+                                       if (0 == usb_device_list_get_next(list, &device) && device != NULL) {
                                                mount_path = usb_device_get_mountpath(device);
                                                if (mount_path != NULL) {
                                                        MS_DBG_WARN("mount_path [%s]", mount_path);
                                                        storage_path = strdup(mount_path);
-                                                       g_array_append_val (*added_list, storage_path);
+                                                       g_array_append_val(*added_list, storage_path);
                                                }
                                        } else {
                                                MS_DBG_ERR(" FAILED TO usb_device_list_get_next \n");
@@ -635,7 +633,6 @@ int ms_check_mounted_storage(uid_t uid)
        int i = 0;
        GArray *added_list = NULL;
        char *mounted_path = NULL;
-       //char *id = NULL;
        char *storage_id = NULL;
        ms_dir_scan_type_t scan_type = MS_SCAN_ALL;
        void **handle = NULL;
@@ -662,7 +659,7 @@ int ms_check_mounted_storage(uid_t uid)
        if (added_list != NULL) {
                count = added_list->len;
 
-               for (i = 0; i < count; i ++) {
+               for (i = 0; i < count; i++) {
                        mounted_path = g_array_index(added_list, char *, i);
                        /* read deive information */
                        ret = ms_read_device_info(mounted_path, &storage_id);
@@ -688,11 +685,11 @@ int ms_check_mounted_storage(uid_t uid)
                                int validity = 0;
                                char *db_storage_path = NULL;
 
-                               ret = ms_check_storage(handle, storage_id, NULL, &db_storage_path, &validity);
+                               ret = ms_check_storage(handle, storage_id, NULL, &db_storage_path, &validity, uid);
                                if (ret == 0) {
                                        if (validity == 1) {
                                                MS_DBG_ERR("This storage is already updated.");
-                                               MS_SAFE_FREE (db_storage_path);
+                                               MS_SAFE_FREE(db_storage_path);
                                                continue;
                                        }
 
@@ -710,7 +707,7 @@ int ms_check_mounted_storage(uid_t uid)
                                                ms_set_folder_validity(handle, storage_id, mounted_path, MS_INVALID, TRUE, uid);
                                                /* update folder table set scan_status=0 first */
                                                ms_set_folder_scan_status(handle, storage_id, NULL, MS_DIR_SCAN_NONE, uid);
-                                               
+
                                                scan_type = MS_SCAN_PART;
                                                MS_SAFE_FREE(db_storage_path);
                                        } else {
@@ -737,7 +734,7 @@ int ms_check_mounted_storage(uid_t uid)
                        MS_SAFE_FREE(storage_id);
                }
 
-               for (i = 0; i < count; i ++) {
+               for (i = 0; i < count; i++) {
                        mounted_path = g_array_index(added_list, char*, 0);
                        MS_SAFE_FREE(mounted_path);
                        g_array_remove_index(added_list, 0);

diff --git a/src/server/media-server-main.c b/src/server/media-server-main.c
index b98960c..af11166 100755 (executable)
--- a/src/server/media-server-main.c
+++ b/src/server/media-server-main.c
@@ -78,22 +78,19 @@ bool __ms_deal_reset_status()
        int value = 0;
        uid_t uid = MEDIA_DEFAULT_UID;
 
-       if(!ms_config_get_int(MS_VCONF_KEY_RESET_STATUS, &value))
-       {
+       if (!ms_config_get_int(MS_VCONF_KEY_RESET_STATUS, &value)) {
                MS_DBG_ERR("get db/media_server/reset_status failed\n");
                return false;
        }
 
        MS_DBG_WARN("db/media_server/reset_status is [%d]\n", value);
 
-       if(value == 1 || value == 2)
-       {
+       if (value == 1 || value == 2) {
                MS_DBG_WARN("POWER_OFF_REASON_FACTORY_RESET or SERVICE RESET");
-               
+
                ms_reset_mediadb(uid);
 
-               if(!ms_config_set_int(MS_VCONF_KEY_RESET_STATUS, 0))
-               {
+               if (!ms_config_set_int(MS_VCONF_KEY_RESET_STATUS, 0)) {
                        MS_DBG_ERR("set db/media_server/reset_status failed\n");
                        return false;
                }
@@ -120,12 +117,12 @@ void _ms_smarthub_vconf_cb(void *data)
 
                smarthub_reset = TRUE;
 
-               if (status == 0 ) {
+               if (status == 0) {
                        scanner_pid = ms_get_scanner_pid();
                        thumb_pid = ms_thumb_get_server_pid();
 
                        /*Kill the running child process*/
-                       if (scanner_pid > 0 ) {
+                       if (scanner_pid > 0) {
                                if (kill(scanner_pid, SIGKILL) < 0) {
                                        MS_DBG_ERR("kill failed");
                                        MS_DBG_STRERROR();
@@ -133,7 +130,7 @@ void _ms_smarthub_vconf_cb(void *data)
                        }
                        MS_DBG("KILL SCANNER");
 
-                       if (thumb_pid > 0 ) {
+                       if (thumb_pid > 0) {
                                if (kill(thumb_pid, SIGKILL) < 0) {
                                        MS_DBG_ERR("kill failed");
                                        MS_DBG_STRERROR();
@@ -158,12 +155,14 @@ void _ms_datadisc_vconf_cb(void *data)
 {
        int ret = MS_MEDIA_ERR_NONE;
        int disc_state = 0;
+       int validity = 0;
        char *disc_type = NULL;
        char *disc_path = NULL;
        char *valid_type = "data";
        ms_dir_scan_type_t scan_type = MS_SCAN_PART;
        uid_t uid = MEDIA_DEFAULT_UID;
-       char storage_path[11] = {0,};
+       char mnt_path[11] = { 0, };
+       char *storage_path = NULL;
        void **handle = NULL;
 
        /*check disc type */
@@ -195,24 +194,44 @@ void _ms_datadisc_vconf_cb(void *data)
                }
 
                MS_DBG("[disc path] %s", disc_path);
-               memset(storage_path, 0x0, sizeof(storage_path));
-               strncpy(storage_path, disc_path, sizeof(storage_path)-1);
+               memset(mnt_path, 0x0, sizeof(mnt_path));
+               strncpy(mnt_path, disc_path, sizeof(mnt_path)-1);
 
                if (disc_state == 1) {
-                       MS_DBG_WARN("[DISC INSERTED][%s]",disc_type);
-               
-                       MS_DBG_WARN("MOUNT PATH [%s]", storage_path);
+                       MS_DBG_WARN("[DISC INSERTED][%s]", disc_type);
+                       MS_DBG_WARN("MOUNT PATH [%s]", mnt_path);
+
+                       /* update storage information into media DB */
+                       ret = ms_check_storage(handle, DATADISC_STORAGE_ID, NULL, &storage_path, &validity, uid);
+                       if (ret == 0) {
+                               ms_set_storage_validity(handle, DATADISC_STORAGE_ID, 1, uid);
+                               if (ms_set_storage_scan_status(handle, DATADISC_STORAGE_ID, MEDIA_SCAN_PREPARE, uid) != MS_MEDIA_ERR_NONE) {
+                                       MS_DBG_ERR("ms_set_storage_scan_status failed");
+                                       goto END;
+                               }
+
+                               MS_DBG_WARN("init storage data in DB");
+                               /* update storage_id table set validity=0 first */
+                               ms_validaty_change_all_items(handle, DATADISC_STORAGE_ID, MS_STORAGE_EXTERNAL, false, uid);
+                               /*update folder table set validity = 0*/
+                               ms_set_folder_validity(handle, DATADISC_STORAGE_ID, mnt_path, MS_INVALID, TRUE, uid);
+                               /* update folder table set scan_status=0 first */
+                               ms_set_folder_scan_status(handle, DATADISC_STORAGE_ID, NULL, MS_DIR_SCAN_NONE, uid);
+                               MS_DBG_WARN("init storage data in DB end");
 
-                       ret = ms_insert_storage(handle, DATADISC_STORAGE_ID, NULL, storage_path, uid);
-                       if (ret != MS_MEDIA_ERR_NONE) {
-                               MS_DBG_ERR("ms_insert_storage failed");
                        } else {
-                               ms_send_storage_scan_request(storage_path, DATADISC_STORAGE_ID, scan_type, uid);
+                               ret = ms_insert_storage(handle, DATADISC_STORAGE_ID, NULL, mnt_path, uid);
+                               if (ret != MS_MEDIA_ERR_NONE) {
+                                       MS_DBG_ERR("ms_insert_storage failed");
+                                       goto END;
+                               }
                        }
+
+                       ms_send_storage_scan_request(mnt_path, DATADISC_STORAGE_ID, scan_type, uid);
                } else {
                        MS_DBG_WARN("[DISC REMOVED]");
                        ms_set_storage_validity(handle, DATADISC_STORAGE_ID, 0, uid);
-                       ms_set_folder_validity(handle, DATADISC_STORAGE_ID, storage_path, false, true, uid);
+                       ms_set_folder_validity(handle, DATADISC_STORAGE_ID, mnt_path, false, true, uid);
                        ms_validaty_change_all_items(handle, DATADISC_STORAGE_ID, MS_STORAGE_EXTERNAL_USB, false, uid);
                }
 
@@ -676,6 +695,7 @@ static int __ms_check_usb_status(void)
        return MS_MEDIA_ERR_NONE;
 }
 
+#ifdef _USE_SENIOR_MODE
 static int __ms_check_disc_status(void)
 {
        int ret = MS_MEDIA_ERR_NONE;
@@ -699,7 +719,7 @@ static int __ms_check_disc_status(void)
                }
 
                if (strcmp(disc_type, valid_type) == 0) {
-                       MS_DBG_WARN("[DISC INSERTED][%s]",disc_type);
+                       MS_DBG_WARN("[DISC INSERTED][%s]", disc_type);
                        MS_DBG_WARN("MOUNT PATH [%s]", mnt_path);
 
                        /* check mount path */
@@ -723,12 +743,13 @@ static int __ms_check_disc_status(void)
 
                        ms_connect_db(&handle, uid);
 
-                                       /* update storage information into media DB */
-                       ret = ms_check_storage(handle, DATADISC_STORAGE_ID, NULL, &storage_path, &validity);
+                       /* update storage information into media DB */
+                       ret = ms_check_storage(handle, DATADISC_STORAGE_ID, NULL, &storage_path, &validity, uid);
                        if (ret == 0) {
                                ms_set_storage_validity(handle, DATADISC_STORAGE_ID, 1, uid);
                                if (ms_set_storage_scan_status(handle, DATADISC_STORAGE_ID, MEDIA_SCAN_PREPARE, uid) != MS_MEDIA_ERR_NONE) {
                                        MS_DBG_ERR("ms_set_storage_scan_status failed");
+                                       goto END;
                                }
 
                                MS_DBG_WARN("init storage data in DB");
@@ -765,6 +786,7 @@ END:
 
        return MS_MEDIA_ERR_NONE;
 }
+#endif
 
 static void __ms_check_mediadb(void)
 {
@@ -805,7 +827,7 @@ static void __ms_check_mediadb(void)
                MS_DBG_ERR("ms_set_all_storage_validity fail");
 
 #ifdef _USE_SENIOR_MODE
-       if(ms_is_support_senior_mode()) {
+       if (ms_is_support_senior_mode()) {
                ms_send_storage_scan_request_senior_mode(db_handle);
        }
 #endif

diff --git a/src/server/media-server-socket.c b/src/server/media-server-socket.c
index bebb73c..da9ba9b 100755 (executable)
--- a/src/server/media-server-socket.c
+++ b/src/server/media-server-socket.c
@@ -93,10 +93,6 @@ static int __ms_add_owner(int pid, int client_sock, char *path)
                        if (path[len -1] == '/')
                                path[len -1] = '\0';
                        owner_data->req_path = strdup(path);
-               //      MS_DBG("the length of array : %d", owner_list->len);
-               //      MS_DBG("pid : %d", owner_data->pid);
-               //      MS_DBG("client_addr : %p", owner_data->client_addr);
-
                        owner_data->index = -1;
                        g_array_append_val(owner_list, owner_data);
                }
@@ -154,13 +150,13 @@ int ms_reset_ownerlist()
        ms_req_owner_data *data = NULL;
        ms_comm_msg_s send_msg = {0,};
 
-       if(owner_list != NULL) {
+       if (owner_list != NULL) {
                len = owner_list->len;
                MS_DBG("length list :  %d", len);
 
-               for (i=0; i < len; i++) {
+               for (i = 0; i < len; i++) {
                        data = g_array_index(owner_list, ms_req_owner_data*, 0);
-                       g_array_remove_index (owner_list, 0);
+                       g_array_remove_index(owner_list, 0);
                        MS_DBG("%d", data->pid);
                        MS_DBG("%s", data->req_path);
                        send_msg.pid = data->pid;
@@ -168,13 +164,13 @@ int ms_reset_ownerlist()
                        send_msg.msg_type = MS_MSG_MEDIA_DB_RESET;
                        send_msg.msg_size = strlen(data->req_path);
                        strncpy(send_msg.msg, data->req_path, send_msg.msg_size);
-                       
+
                        /* owner data exists */
                        /* send result to the owner of request */
                        ms_ipc_send_msg_to_client_tcp(data->client_sockfd, &send_msg, NULL);
 
                        close(data->client_sockfd);
-               }
+               }
        }
 
        return MS_MEDIA_ERR_NONE;
@@ -234,7 +230,7 @@ static int __ms_recovery_media_db(uid_t uid)
        void **handle = NULL;
 
        /* stop the child process */
-       
+
        /*reset */
        ms_config_set_int(MS_DB_RESET, 1);
        ms_reset_ownerlist();
@@ -247,18 +243,18 @@ static int __ms_recovery_media_db(uid_t uid)
                MS_DBG_ERR("function load failed [%d]", err);
                return err;
        }
-       
+
        ms_connect_db(&handle, uid);
-       
+
        MS_DBG_WARN("START WRITE SCHEMA");
        if (ms_check_db_upgrade(handle, uid)  != MS_MEDIA_ERR_NONE) {
                MS_DBG_ERR("ms_check_db_upgrade fail");
        }
        MS_DBG_WARN("END WRITE SCHEMA");
-       
+
        /*disconnect form media db*/
        if (handle) ms_disconnect_db(&handle);
-       
+
        /*unload functions*/
        ms_unload_functions();
 
@@ -353,22 +349,22 @@ ERROR:
                memset(&res_msg, 0x0, sizeof(ms_comm_msg_s));
 
                switch (req_num) {
-                       case MS_MSG_DIRECTORY_SCANNING:
-                       case MS_MSG_DIRECTORY_SCANNING_NON_RECURSIVE:
-                               res_msg.msg_type = MS_MSG_SCANNER_RESULT;
-                               break;
-                       case MS_MSG_BULK_INSERT:
-                       case MS_MSG_BURSTSHOT_INSERT:
-                               res_msg.msg_type = MS_MSG_SCANNER_BULK_RESULT;
-                               break;
-                       case MS_MSG_RECEIVE_MSG_FAILED:
-                               res_msg.msg_type = MS_MSG_RECEIVE_MSG_FAILED;
-                               break;
-                       case MS_MSG_MEDIA_DB_MALFORMED:
-                               res_msg.msg_type = MS_MSG_MEDIA_DB_MALFORMED;
-                               break;
-                       default :
-                               break;
+               case MS_MSG_DIRECTORY_SCANNING:
+               case MS_MSG_DIRECTORY_SCANNING_NON_RECURSIVE:
+                       res_msg.msg_type = MS_MSG_SCANNER_RESULT;
+                       break;
+               case MS_MSG_BULK_INSERT:
+               case MS_MSG_BURSTSHOT_INSERT:
+                       res_msg.msg_type = MS_MSG_SCANNER_BULK_RESULT;
+                       break;
+               case MS_MSG_RECEIVE_MSG_FAILED:
+                       res_msg.msg_type = MS_MSG_RECEIVE_MSG_FAILED;
+                       break;
+               case MS_MSG_MEDIA_DB_MALFORMED:
+                       res_msg.msg_type = MS_MSG_MEDIA_DB_MALFORMED;
+                       break;
+               default:
+                       break;
                }
 
                res_msg.result = res;
@@ -467,23 +463,23 @@ int ms_send_storage_scan_request(const char *root_path, const char *storage_id,
 
        /* msg_type */
        switch (scan_type) {
-               case MS_SCAN_PART:
-                       scan_msg.msg_type = MS_MSG_STORAGE_PARTIAL;
-                       break;
-               case MS_SCAN_ALL:
-                       scan_msg.msg_type = MS_MSG_STORAGE_ALL;
-                       break;
-               case MS_SCAN_INVALID:
-                       scan_msg.msg_type = MS_MSG_STORAGE_INVALID;
-                       break;
-               case MS_SCAN_META:
-                       scan_msg.msg_type = MS_MSG_STORAGE_META;
-                       break;
-               default:
-                       ret = MS_MEDIA_ERR_INVALID_PARAMETER;
-                       MS_DBG_ERR("ms_send_storage_scan_request invalid parameter");
-                       goto ERROR;
-                       break;
+       case MS_SCAN_PART:
+               scan_msg.msg_type = MS_MSG_STORAGE_PARTIAL;
+               break;
+       case MS_SCAN_ALL:
+               scan_msg.msg_type = MS_MSG_STORAGE_ALL;
+               break;
+       case MS_SCAN_INVALID:
+               scan_msg.msg_type = MS_MSG_STORAGE_INVALID;
+               break;
+       case MS_SCAN_META:
+               scan_msg.msg_type = MS_MSG_STORAGE_META;
+               break;
+       default:
+               ret = MS_MEDIA_ERR_INVALID_PARAMETER;
+               MS_DBG_ERR("ms_send_storage_scan_request invalid parameter");
+               goto ERROR;
+               break;
        }
 
        /* msg_size & msg */
@@ -520,7 +516,7 @@ int ms_send_storage_scan_request_senior_mode(void **handle)
 
        ms_sys_get_uid(&uid);
 
-       ret = ms_check_storage(handle, storage_id, NULL, &storage_path, &validity);
+       ret = ms_check_storage(handle, storage_id, NULL, &storage_path, &validity, uid);
        if (ret == 0) {
                if (storage_path != NULL) {
                        MS_DBG_WARN("##[senior mode]####[path [%s], %s]###", path, storage_path);
@@ -530,7 +526,7 @@ int ms_send_storage_scan_request_senior_mode(void **handle)
                                ret = ms_update_storage(handle, storage_id, path, uid);
                        }
 
-                       if (validity== 0) {
+                       if (validity == 0) {
                                ms_set_storage_validity(handle, storage_id, 1, uid);
                                /* update storage_id table set validity=0 first */
                                ms_validaty_change_all_items(handle, storage_id, MS_STORAGE_EXTERNAL, false, uid);
@@ -660,8 +656,6 @@ void _ms_process_tcp_message(gpointer data, gpointer user_data)
 
        memset((void *)&recv_msg, 0, sizeof(ms_comm_msg_s));
 
-//     MS_DBG_ERR("client sokcet : %d", client_sock);
-
        while (1) {
                if (power_off == TRUE) {
                        MS_DBG_WARN("in the power off sequence");
@@ -704,7 +698,6 @@ void _ms_process_tcp_message(gpointer data, gpointer user_data)
                                MS_DBG_STRERROR("send failed");
                        }
 
-//                     MS_DBG_ERR("client sokcet : %d", client_sock);
                        if (recv_msg.msg_type == MS_MSG_DB_UPDATE_BATCH_END) {
                                MS_DBG_WARN("Batch job is successfull!client sockfd [%d]", client_sock);
                                break;
@@ -873,11 +866,10 @@ gboolean ms_receive_message_from_scanner(GIOChannel *src, GIOCondition condition
                (msg_type == MS_MSG_DIRECTORY_SCANNING_CANCEL)) {
                MS_DBG_WARN("DB UPDATING IS DONE[%d]", msg_type);
 
-               if((msg_type == MS_MSG_SCANNER_RESULT) ||
+               if ((msg_type == MS_MSG_SCANNER_RESULT) ||
                (msg_type == MS_MSG_SCANNER_BULK_RESULT) ||
                (msg_type == MS_MSG_EXTRACTOR_COMPLETE) ||
-               (msg_type == MS_MSG_DIRECTORY_SCANNING_CANCEL))
-               {
+               (msg_type == MS_MSG_DIRECTORY_SCANNING_CANCEL)) {
                        ms_req_num--;
                        MS_DBG_WARN("ms_req_num-- [%d]", ms_req_num);
                }
@@ -944,20 +936,20 @@ int ms_send_storage_otg_scan_request(const char *path, const char *device_uuid,
 
        /* msg_type */
        switch (scan_type) {
-               case MS_SCAN_PART:
-                       scan_msg.msg_type = MS_MSG_STORAGE_PARTIAL;
-                       break;
-               case MS_SCAN_ALL:
-                       scan_msg.msg_type = MS_MSG_STORAGE_ALL;
-                       break;
-               case MS_SCAN_INVALID:
-                       scan_msg.msg_type = MS_MSG_STORAGE_INVALID;
-                       break;
-               default:
-                       ret = MS_MEDIA_ERR_INVALID_PARAMETER;
-                       MS_DBG_ERR("ms_send_storage_scan_request invalid parameter");
-                       goto ERROR;
-                       break;
+       case MS_SCAN_PART:
+               scan_msg.msg_type = MS_MSG_STORAGE_PARTIAL;
+               break;
+       case MS_SCAN_ALL:
+               scan_msg.msg_type = MS_MSG_STORAGE_ALL;
+               break;
+       case MS_SCAN_INVALID:
+               scan_msg.msg_type = MS_MSG_STORAGE_INVALID;
+               break;
+       default:
+               ret = MS_MEDIA_ERR_INVALID_PARAMETER;
+               MS_DBG_ERR("ms_send_storage_scan_request invalid parameter");
+               goto ERROR;
+               break;
        }
 
        /* msg_size & msg */