Delete err_msg

This is old code.
No more error msgs are required.
Use return value instead.

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

diff --git a/src/common/include/media-common-db-svc.h b/src/common/include/media-common-db-svc.h
index 6ca490b..c24fabe 100755 (executable)
--- a/src/common/include/media-common-db-svc.h
+++ b/src/common/include/media-common-db-svc.h
@@ -52,58 +52,58 @@ typedef enum {
        MS_ITEM_UPDATE  = 2,
 } ms_noti_type_e;
 
-typedef int (*CONNECT)(void**, uid_t, char **);
-typedef int (*DISCONNECT)(void*, char **);
-typedef int (*CLEANUP_DB)(void*, uid_t, char **);
-typedef int (*INSERT_ITEM_BEGIN)(void*, int, int, int, char **);
-typedef int (*INSERT_ITEM_END)(void*, uid_t, char **);
-typedef int (*SET_ITEM_VALIDITY_BEGIN)(void*, int, char **);
-typedef int (*SET_ITEM_VALIDITY_END)(void*, uid_t, char **);
-
-typedef int (*SEND_DIR_UPDATE_NOTI)(void *, const char *, const char *, const char *, int, int, char **);
-typedef int (*CHECK_ITEM_EXIST)(void*, const char *, const char *, bool *, char **);
-typedef int (*INSERT_ITEM)(void *, const char *, const char *, int, uid_t, char **);
-typedef int (*SET_ALL_STORAGE_ITEMS_VALIDITY)(void *, const char *, int, int, uid_t, char **);
-typedef int (*SET_FOLDER_ITEM_VALIDITY)(void *, const char *, const char *, int, int, uid_t, char**);
-typedef int (*SET_ITEM_VALIDITY)(void *, const char *, const char *, int, int, uid_t, char **);
-typedef int (*DELETE_ITEM)(void *, const char *, const char *, uid_t, char **);
-typedef int (*DELETE_ALL_INVALID_ITMES_IN_STORAGE)(void *, const char *, int, uid_t, char **);
-typedef int (*DELETE_ALL_INVALID_ITEMS_IN_FOLDER)(void *, const char *, const char *, bool, uid_t, char**);
-typedef int (*UPDATE_FOLDER_TIME)(void *, const char *, const char *, uid_t, char **);
-typedef int (*GET_STORAGE_ID)(void *, const char *, char *, uid_t uid, char **);
-typedef int (*SET_STORAGE_SCAN_STATUS)(void *, const char *, int, uid_t, char **);
-typedef int (*GET_STORAGE_LIST)(void *, char ***, char ***, int *, char **);
-typedef int (*INSERT_FOLDER)(void *, const char *, const char *, int, uid_t, char **);
-typedef int (*DELETE_INVALID_FOLDER)(void *, const char *, int, uid_t, char **);
-typedef int (*SET_FOLDER_VALIDITY)(void *, const char *, const char *, int, bool, uid_t, char **);
-typedef int (*INSERT_FOLDER_BEGIN)(void *, int, char **);
-typedef int (*INSERT_FOLDER_END)(void *, uid_t, char **);
-typedef int (*INSERT_ITEM_SCAN)(void *, const char *, const char *, int, uid_t, char **);
-typedef int (*GET_FOLDER_SCAN_STATUS)(void *, const char *, const char *, int *, char **);
-typedef int (*SET_FOLDER_SCAN_STATUS)(void *, const char *, const char *, int, uid_t, char **);
-typedef int (*CHECK_FOLDER_MODIFIED)(void *, const char *, const char *, bool *, char **);
-typedef int (*GET_NULL_SCAN_FOLDER_LIST)(void *, const char *, const char *, char ***, int *, char **);
-typedef int (*CHANGE_VALIDITY_ITEM_BATCH)(void *, const char *, const char *, int, int, uid_t, char **);
-
-typedef int (*CHECK_DB)(void*, uid_t, char **);
-typedef int (*GET_UUID)(void *, char **, char **);
-typedef int (*CHECK_STORAGE)(void *, const char *, char **, int *, uid_t, char **);
-typedef int (*INSERT_STORAGE)(void *, const char *, int, const char *, uid_t, char **);
-typedef int (*UPDATE_STORAGE)(void *, const char *, const char *, uid_t, char **);
-typedef int (*SET_STORAGE_VALIDITY)(void *, const char *, int, uid_t uid, char **);
-typedef int (*SET_ALL_STORAGE_VALIDITY)(void *, int, uid_t, char **);
-
-typedef int (*UPDATE_ITEM_META)(void *, const char *, const char *, int, uid_t, char **);
-typedef int (*UPDATE_ITEM_BEGIN)(void *, int, char **);
-typedef int (*UPDATE_ITEM_END)(void *, uid_t, char **);
-
-typedef int (*DELETE_INVALID_FOLDER_BY_PATH)(void *, const char *, const char *, uid_t, char **);
-typedef int (*CHECK_FOLDER_EXIST)(void*, const char*, const char*, char **);
-typedef int (*GET_FOLDER_ID)(void *, const char *, const char *, char *, char **);
-typedef int (*GET_EXTRACT_LIST)(void*, const char*, int, int, const char*, uid_t, void*, char**);
-typedef int (*UPDATE_ONE_EXTRACT_ITEM)(void*, const char*, int, void*, char**);
-typedef int (*QUERY_DO_UPDATE_LIST)(void*, char**);
-typedef int (*GET_MEDIA_TYPE)(void *, const char *, int *, char **);
+typedef int (*CONNECT)(void**, uid_t);
+typedef int (*DISCONNECT)(void*);
+typedef int (*CLEANUP_DB)(void*, uid_t);
+typedef int (*INSERT_ITEM_BEGIN)(void*, int, int, int);
+typedef int (*INSERT_ITEM_END)(void*, uid_t);
+typedef int (*SET_ITEM_VALIDITY_BEGIN)(void*, int);
+typedef int (*SET_ITEM_VALIDITY_END)(void*, uid_t);
+
+typedef int (*SEND_DIR_UPDATE_NOTI)(void *, const char *, const char *, const char *, int, int);
+typedef int (*CHECK_ITEM_EXIST)(void*, const char *, const char *, bool *);
+typedef int (*INSERT_ITEM)(void *, const char *, const char *, int, uid_t);
+typedef int (*SET_ALL_STORAGE_ITEMS_VALIDITY)(void *, const char *, int, int, uid_t);
+typedef int (*SET_FOLDER_ITEM_VALIDITY)(void *, const char *, const char *, int, int, uid_t);
+typedef int (*SET_ITEM_VALIDITY)(void *, const char *, const char *, int, int, uid_t);
+typedef int (*DELETE_ITEM)(void *, const char *, const char *, uid_t);
+typedef int (*DELETE_ALL_INVALID_ITMES_IN_STORAGE)(void *, const char *, int, uid_t);
+typedef int (*DELETE_ALL_INVALID_ITEMS_IN_FOLDER)(void *, const char *, const char *, bool, uid_t);
+typedef int (*UPDATE_FOLDER_TIME)(void *, const char *, const char *, uid_t);
+typedef int (*GET_STORAGE_ID)(void *, const char *, char *, uid_t uid);
+typedef int (*SET_STORAGE_SCAN_STATUS)(void *, const char *, int, uid_t);
+typedef int (*GET_STORAGE_LIST)(void *, char ***, char ***, int *);
+typedef int (*INSERT_FOLDER)(void *, const char *, const char *, int, uid_t);
+typedef int (*DELETE_INVALID_FOLDER)(void *, const char *, int, uid_t);
+typedef int (*SET_FOLDER_VALIDITY)(void *, const char *, const char *, int, bool, uid_t);
+typedef int (*INSERT_FOLDER_BEGIN)(void *, int);
+typedef int (*INSERT_FOLDER_END)(void *, uid_t);
+typedef int (*INSERT_ITEM_SCAN)(void *, const char *, const char *, int, uid_t);
+typedef int (*GET_FOLDER_SCAN_STATUS)(void *, const char *, const char *, int *);
+typedef int (*SET_FOLDER_SCAN_STATUS)(void *, const char *, const char *, int, uid_t);
+typedef int (*CHECK_FOLDER_MODIFIED)(void *, const char *, const char *, bool *);
+typedef int (*GET_NULL_SCAN_FOLDER_LIST)(void *, const char *, const char *, char ***, int *);
+typedef int (*CHANGE_VALIDITY_ITEM_BATCH)(void *, const char *, const char *, int, int, uid_t);
+
+typedef int (*CHECK_DB)(void*, uid_t);
+typedef int (*GET_UUID)(void *, char **);
+typedef int (*CHECK_STORAGE)(void *, const char *, char **, int *, uid_t);
+typedef int (*INSERT_STORAGE)(void *, const char *, int, const char *, uid_t);
+typedef int (*UPDATE_STORAGE)(void *, const char *, const char *, uid_t);
+typedef int (*SET_STORAGE_VALIDITY)(void *, const char *, int, uid_t uid);
+typedef int (*SET_ALL_STORAGE_VALIDITY)(void *, int, uid_t);
+
+typedef int (*UPDATE_ITEM_META)(void *, const char *, const char *, int, uid_t);
+typedef int (*UPDATE_ITEM_BEGIN)(void *, int);
+typedef int (*UPDATE_ITEM_END)(void *, uid_t);
+
+typedef int (*DELETE_INVALID_FOLDER_BY_PATH)(void *, const char *, const char *, uid_t);
+typedef int (*CHECK_FOLDER_EXIST)(void*, const char*, const char*);
+typedef int (*GET_FOLDER_ID)(void *, const char *, const char *, char *);
+typedef int (*GET_EXTRACT_LIST)(void*, const char*, int, int, const char*, uid_t, void*);
+typedef int (*UPDATE_ONE_EXTRACT_ITEM)(void*, const char*, int, void*);
+typedef int (*QUERY_DO_UPDATE_LIST)(void*);
+typedef int (*GET_MEDIA_TYPE)(void *, const char *, int *);
 
 int ms_load_functions(void);
 void ms_unload_functions(void);

diff --git a/src/common/media-common-db-svc.c b/src/common/media-common-db-svc.c
index c837865..c8d4823 100755 (executable)
--- a/src/common/media-common-db-svc.c
+++ b/src/common/media-common-db-svc.c
@@ -314,7 +314,6 @@ int ms_connect_db(void ***handle, uid_t uid)
 {
        int lib_index = 0;
        int ret = MS_MEDIA_ERR_NONE;
-       char * err_msg = NULL;
 
        /*Lock mutex for openning db*/
        g_mutex_lock(&db_mutex);
@@ -326,37 +325,22 @@ int ms_connect_db(void ***handle, uid_t uid)
                return MS_MEDIA_ERR_OUT_OF_MEMORY;
        }
 
-       for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((CONNECT)func_array[lib_index][eCONNECT])(&((*handle)[lib_index]), uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       g_mutex_unlock(&db_mutex);
-
-                       return MS_MEDIA_ERR_DB_CONNECT_FAIL;
-               }
-       }
-
-       MS_DBG_INFO("connect Media DB");
+       for (lib_index = 0; lib_index < lib_num; lib_index++)
+               ret = ((CONNECT)func_array[lib_index][eCONNECT])(&((*handle)[lib_index]), uid); /*dlopen*/
 
        g_mutex_unlock(&db_mutex);
 
-       return MS_MEDIA_ERR_NONE;
+       return ret;
 }
 
 int ms_disconnect_db(void ***handle)
 {
        int lib_index;
        int ret;
-       char * err_msg = NULL;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((DISCONNECT)func_array[lib_index][eDISCONNECT])((*handle)[lib_index], &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       return MS_MEDIA_ERR_DB_DISCONNECT_FAIL;
-               }
+               ret = ((DISCONNECT)func_array[lib_index][eDISCONNECT])((*handle)[lib_index]); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        MS_SAFE_FREE(*handle);
@@ -370,15 +354,10 @@ int ms_cleanup_db(void **handle, uid_t uid)
 {
        int lib_index;
        int ret;
-       char * err_msg = NULL;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((CLEANUP_DB)func_array[lib_index][eCLEANUP_DB])(handle[lib_index], uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       return MS_MEDIA_ERR_DB_INTERNAL;
-               }
+               ret = ((CLEANUP_DB)func_array[lib_index][eCLEANUP_DB])(handle[lib_index], uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        MS_DBG_INFO("Cleanup Media DB");
@@ -389,116 +368,80 @@ int ms_cleanup_db(void **handle, uid_t uid)
 int ms_validate_item(void **handle, const char *storage_id, const char *path, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
        bool modified = FALSE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
                /*check exist in Media DB, If file is not exist, insert data in DB. */
-               ret = ((CHECK_ITEM_EXIST)func_array[lib_index][eEXIST])(handle[lib_index], storage_id, path, &modified, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_SAFE_FREE(err_msg);
+               ret = ((CHECK_ITEM_EXIST)func_array[lib_index][eEXIST])(handle[lib_index], storage_id, path, &modified); /*dlopen*/
+               if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
                        ret = ms_insert_item_batch(handle, storage_id, path, uid);
-                       if (ret != 0)
-                               res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               } else {
+               } else if (ret == MS_MEDIA_ERR_NONE) {
                        if (modified == FALSE) {
                                /*if meta data of file exist, change valid field to "1" */
-                               ret = ((SET_ITEM_VALIDITY)func_array[lib_index][eSET_VALIDITY])(handle[lib_index], storage_id, path, true, true, uid, &err_msg); /*dlopen*/
-                               if (ret != 0) {
-                                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
-                                       MS_SAFE_FREE(err_msg);
-                                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-                               }
+                               ret = ((SET_ITEM_VALIDITY)func_array[lib_index][eSET_VALIDITY])(handle[lib_index], storage_id, path, true, true, uid); /*dlopen*/
+                               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s [%s]", g_array_index(so_array, char*, lib_index), path);
                        } else {
                                /* the file has same name but it is changed, so we have to update DB */
-                               ret = ((DELETE_ITEM)func_array[lib_index][eDELETE_ITEM])(handle[lib_index], storage_id, path, uid, &err_msg); /*dlopen*/
-                               if (ret != 0) {
-                                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
-                                       MS_SAFE_FREE(err_msg);
-                                       res = MS_MEDIA_ERR_DB_DELETE_FAIL;
-                               } else {
-                                       ret = ms_insert_item_batch(handle, storage_id, path, uid);
-                                       if (ret != 0)
-                                               res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-                               }
+                               ret = ((DELETE_ITEM)func_array[lib_index][eDELETE_ITEM])(handle[lib_index], storage_id, path, uid); /*dlopen*/
+                               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s [%s]", g_array_index(so_array, char*, lib_index), path);
+                               ret = ms_insert_item_batch(handle, storage_id, path, uid);
                        }
+               } else {
+                       MS_DBG_ERR("check_item_exist failed [%d]", ret);
                }
        }
 
-       return res;
+       return ret;
 }
 
 int ms_scan_validate_item(void **handle, const char *storage_id, const char *path, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
        bool modified = FALSE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
                /*check exist in Media DB, If file is not exist, insert data in DB. */
-               ret = ((CHECK_ITEM_EXIST)func_array[lib_index][eEXIST])(handle[lib_index], storage_id, path, &modified, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_SAFE_FREE(err_msg);
+               ret = ((CHECK_ITEM_EXIST)func_array[lib_index][eEXIST])(handle[lib_index], storage_id, path, &modified); /*dlopen*/
+               if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
                        ret = ms_scan_item_batch(handle, storage_id, path, uid);
-                       if (ret != 0)
-                               res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               } else {
+               } else if (ret == MS_MEDIA_ERR_NONE) {
                        if (modified == FALSE) {
                                /*if meta data of file exist, change valid field to "1" */
-                               ret = ((SET_ITEM_VALIDITY)func_array[lib_index][eSET_VALIDITY])(handle[lib_index], storage_id, path, true, true, uid, &err_msg); /*dlopen*/
-                               if (ret != 0) {
-                                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
-                                       MS_SAFE_FREE(err_msg);
-                                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-                               }
+                               ret = ((SET_ITEM_VALIDITY)func_array[lib_index][eSET_VALIDITY])(handle[lib_index], storage_id, path, true, true, uid); /*dlopen*/
+                               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s [%s]", g_array_index(so_array, char*, lib_index), path);
                        } else {
                                /* the file has same name but it is changed, so we have to update DB */
-                               ret = ((DELETE_ITEM)func_array[lib_index][eDELETE_ITEM])(handle[lib_index], storage_id, path, uid, &err_msg); /*dlopen*/
-                               if (ret != 0) {
-                                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
-                                       MS_SAFE_FREE(err_msg);
-                                       res = MS_MEDIA_ERR_DB_DELETE_FAIL;
-                               } else {
-                                       ret = ms_scan_item_batch(handle, storage_id, path, uid);
-                                       if (ret != 0)
-                                               res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-                               }
+                               ret = ((DELETE_ITEM)func_array[lib_index][eDELETE_ITEM])(handle[lib_index], storage_id, path, uid); /*dlopen*/
+                               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s [%s]", g_array_index(so_array, char*, lib_index), path);
+                               ret = ms_scan_item_batch(handle, storage_id, path, uid);
                        }
+               } else {
+                       MS_DBG_ERR("check_item_exist failed [%d]", ret);
                }
        }
 
-       return res;
+       return ret;
 }
 
 int ms_validaty_change_all_items(void **handle, const char *storage_id, ms_user_storage_type_e storage_type, bool validity , uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((SET_ALL_STORAGE_ITEMS_VALIDITY)func_array[lib_index][eSET_ALL_VALIDITY])(handle[lib_index], storage_id, storage_type, validity, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((SET_ALL_STORAGE_ITEMS_VALIDITY)func_array[lib_index][eSET_ALL_VALIDITY])(handle[lib_index], storage_id, storage_type, validity, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 int ms_insert_item_batch(void **handle, const char* storage_id, const char *path, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
        int ret = MS_MEDIA_ERR_NONE;
-       char *err_msg = NULL;
        ms_user_storage_type_e storage_type = -1;
 
        MS_DBG_FENTER();
@@ -507,23 +450,17 @@ int ms_insert_item_batch(void **handle, const char* storage_id, const char *path
        MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Fail to get storage type");
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((INSERT_ITEM)func_array[lib_index][eINSERT_BATCH])(handle[lib_index], storage_id, path, storage_type, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((INSERT_ITEM)func_array[lib_index][eINSERT_BATCH])(handle[lib_index], storage_id, path, storage_type, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 int ms_scan_item_batch(void **handle, const char* storage_id, const char *path, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
        int ret = MS_MEDIA_ERR_NONE;
-       char *err_msg = NULL;
        ms_user_storage_type_e storage_type;
 
        MS_DBG_FENTER();
@@ -532,90 +469,60 @@ int ms_scan_item_batch(void **handle, const char* storage_id, const char *path,
        MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Fail to get storage type");
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((INSERT_ITEM_SCAN)func_array[lib_index][eINSERT_SCAN])(handle[lib_index], storage_id, path, storage_type, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((INSERT_ITEM_SCAN)func_array[lib_index][eINSERT_SCAN])(handle[lib_index], storage_id, path, storage_type, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 int ms_get_extract_list(void** handle, const char* storage_id, int storage_type, int scan_type, const char* path, uid_t uid, void* array)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((GET_EXTRACT_LIST)func_array[lib_index][eGET_EXTRACT_LIST])(handle[lib_index], storage_id, storage_type, scan_type, path, uid, array, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((GET_EXTRACT_LIST)func_array[lib_index][eGET_EXTRACT_LIST])(handle[lib_index], storage_id, storage_type, scan_type, path, uid, array); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 int ms_update_one_extract_item(void** handle, const char* storage_id, int storage_type, void* data)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((UPDATE_ONE_EXTRACT_ITEM)func_array[lib_index][eUPDATE_ONE_EXTRACT_ITEM])(handle[lib_index], storage_id, storage_type, data, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       if (ret == -2)
-                               res = MS_MEDIA_ERR_FILE_IO;
-                       else
-                               res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((UPDATE_ONE_EXTRACT_ITEM)func_array[lib_index][eUPDATE_ONE_EXTRACT_ITEM])(handle[lib_index], storage_id, storage_type, data); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 int ms_query_do_update_list(void** handle)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((QUERY_DO_UPDATE_LIST)func_array[lib_index][eQUERY_DO_UPDATE_LIST])(handle[lib_index], &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((QUERY_DO_UPDATE_LIST)func_array[lib_index][eQUERY_DO_UPDATE_LIST])(handle[lib_index]); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 bool ms_delete_invalid_items(void **handle, const char *storage_id, ms_user_storage_type_e storage_type, uid_t uid)
 {
        int lib_index;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((DELETE_ALL_INVALID_ITMES_IN_STORAGE)func_array[lib_index][eDELETE_INVALID_ITEMS])(handle[lib_index], storage_id, storage_type, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       return false;
-               }
+               ret = ((DELETE_ALL_INVALID_ITMES_IN_STORAGE)func_array[lib_index][eDELETE_INVALID_ITEMS])(handle[lib_index], storage_id, storage_type, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, false, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        return true;
@@ -624,127 +531,94 @@ bool ms_delete_invalid_items(void **handle, const char *storage_id, ms_user_stor
 int ms_set_folder_item_validity(void **handle, const char *storage_id, const char *path, int validity, int recursive, uid_t uid)
 {
        int lib_index;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((SET_FOLDER_ITEM_VALIDITY)func_array[lib_index][eSET_FOLDER_ITEM_VALIDITY])(handle[lib_index], storage_id, path, validity, recursive, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       return MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((SET_FOLDER_ITEM_VALIDITY)func_array[lib_index][eSET_FOLDER_ITEM_VALIDITY])(handle[lib_index], storage_id, path, validity, recursive, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return MS_MEDIA_ERR_NONE;
+       return ret;
 }
 
 int ms_delete_invalid_items_in_folder(void **handle, const char* storage_id, const char*path, bool is_recursive, uid_t uid)
 {
        int lib_index;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((DELETE_ALL_INVALID_ITEMS_IN_FOLDER)func_array[lib_index][eDELETE_FOLDER])(handle[lib_index], storage_id, path, is_recursive, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       return MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((DELETE_ALL_INVALID_ITEMS_IN_FOLDER)func_array[lib_index][eDELETE_FOLDER])(handle[lib_index], storage_id, path, is_recursive, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return MS_MEDIA_ERR_NONE;
+       return ret;
 }
 
 int ms_send_dir_update_noti(void **handle, const char* storage_id, const char*path, const char*folder_id, ms_noti_type_e noti_type, int pid)
 {
        int lib_index;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((SEND_DIR_UPDATE_NOTI)func_array[lib_index][eSEND_DIR_UPDATE_NOTI])(handle[lib_index], storage_id, path, folder_id, (int)noti_type, pid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       return MS_MEDIA_ERR_SEND_NOTI_FAIL;
-               }
+               ret = ((SEND_DIR_UPDATE_NOTI)func_array[lib_index][eSEND_DIR_UPDATE_NOTI])(handle[lib_index], storage_id, path, folder_id, (int)noti_type, pid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return MS_MEDIA_ERR_NONE;
+       return ret;
 }
 
 int ms_update_folder_time(void **handle, const char *storage_id, char *folder_path, uid_t uid)
 {
        int lib_index;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((UPDATE_FOLDER_TIME)func_array[lib_index][eUPDATE_FOLDER_TIME])(handle[lib_index], storage_id, folder_path, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       return MS_MEDIA_ERR_INTERNAL;
-               }
+               ret = ((UPDATE_FOLDER_TIME)func_array[lib_index][eUPDATE_FOLDER_TIME])(handle[lib_index], storage_id, folder_path, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return MS_MEDIA_ERR_NONE;
+       return ret;
 }
 
 int ms_get_storage_id(void **handle, const char *path, char *storage_id, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        MS_DBG_FENTER();
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((GET_STORAGE_ID)func_array[lib_index][eGET_STORAGE_ID])(handle[lib_index], path, storage_id, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((GET_STORAGE_ID)func_array[lib_index][eGET_STORAGE_ID])(handle[lib_index], path, storage_id, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        MS_DBG("storage_id [%s]", storage_id);
 
-       return res;
+       return ret;
 }
 
 int ms_set_storage_scan_status(void **handle, char *storage_id, media_scan_status_e scan_status, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
        int status = scan_status;
 
        MS_DBG_FENTER();
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((SET_STORAGE_SCAN_STATUS)func_array[lib_index][eSET_STORAGE_SCAN_STATUS])(handle[lib_index], storage_id, status, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((SET_STORAGE_SCAN_STATUS)func_array[lib_index][eSET_STORAGE_SCAN_STATUS])(handle[lib_index], storage_id, status, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        MS_DBG("storage_id [%s], scan_status [%d]", storage_id, scan_status);
 
-       return res;
+       return ret;
 }
 
 int ms_get_storage_list(void **handle, GArray **storage_array)
 {
        int lib_index;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        char **storage_list = NULL;
        char **storage_id_list = NULL;
@@ -754,12 +628,8 @@ int ms_get_storage_list(void **handle, GArray **storage_array)
        ms_stg_info_s* stg_info = NULL;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((GET_STORAGE_LIST)func_array[lib_index][eGET_STORAGE_LIST])(handle[lib_index], &storage_list, &storage_id_list, &count, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       return MS_MEDIA_ERR_INTERNAL;
-               }
+               ret = ((GET_STORAGE_LIST)func_array[lib_index][eGET_STORAGE_LIST])(handle[lib_index], &storage_list, &storage_id_list, &count); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        *storage_array = g_array_new(FALSE, FALSE, sizeof(ms_stg_info_s*));
@@ -783,137 +653,100 @@ int ms_get_storage_list(void **handle, GArray **storage_array)
        MS_SAFE_FREE(storage_list);
        MS_SAFE_FREE(storage_id_list);
 
-       return MS_MEDIA_ERR_NONE;
+       return ret;
 }
 
 int ms_insert_folder(void **handle, const char *storage_id, const char *path, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
        int ret = MS_MEDIA_ERR_NONE;
-       char *err_msg = NULL;
        ms_user_storage_type_e storage_type;
 
        ret = ms_user_get_storage_type(uid, path, &storage_type);
        MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Fail to get storage type");
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((INSERT_FOLDER)func_array[lib_index][eINSERT_FOLDER])(handle[lib_index], storage_id, path, storage_type, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((INSERT_FOLDER)func_array[lib_index][eINSERT_FOLDER])(handle[lib_index], storage_id, path, storage_type, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s [%s]", g_array_index(so_array, char*, lib_index), path);
        }
 
-       return res;
+       return ret;
 }
 
 int ms_delete_invalid_folder(void **handle, const char *storage_id, int storage_type, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((DELETE_INVALID_FOLDER)func_array[lib_index][eDELETE_INVALID_FOLDER])(handle[lib_index], storage_id, storage_type, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, storage_id);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((DELETE_INVALID_FOLDER)func_array[lib_index][eDELETE_INVALID_FOLDER])(handle[lib_index], storage_id, storage_type, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s [%s]", g_array_index(so_array, char*, lib_index), storage_id);
        }
 
-       return res;
+       return ret;
 }
 
 int ms_set_folder_validity(void **handle, const char *storage_id, const char *path, int validity, bool is_recursive, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((SET_FOLDER_VALIDITY)func_array[lib_index][eSET_FOLDER_VALIDITY])(handle[lib_index], storage_id, path, validity, is_recursive, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, storage_id);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((SET_FOLDER_VALIDITY)func_array[lib_index][eSET_FOLDER_VALIDITY])(handle[lib_index], storage_id, path, validity, is_recursive, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s [%s]", g_array_index(so_array, char*, lib_index), storage_id);
        }
 
-       return res;
+       return ret;
 }
 
 int ms_check_db_upgrade(void **handle, uid_t uid)
 {
        int lib_index = 0;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        MS_DBG_FENTER();
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((CHECK_DB)func_array[lib_index][eCHECK_DB])(handle[lib_index], 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);
-                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((CHECK_DB)func_array[lib_index][eCHECK_DB])(handle[lib_index], uid);
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
        MS_DBG_FLEAVE();
 
-       return res;
+       return ret;
 }
 
 int ms_genarate_uuid(void **handle, char **uuid)
 {
        int lib_index = 0;
-       int ret;
-       char * err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
-       ret = ((GET_UUID)func_array[lib_index][eGET_UUID])(NULL, uuid, &err_msg); /*dlopen*/
-       if (ret != 0) {
-               MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-               MS_SAFE_FREE(err_msg);
-               return MS_MEDIA_ERR_DB_DISCONNECT_FAIL;
-       }
+       ret = ((GET_UUID)func_array[lib_index][eGET_UUID])(NULL, uuid); /*dlopen*/
+       MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
 
-       return MS_MEDIA_ERR_NONE;
+       return ret;
 }
 
 int ms_check_storage(void **handle, const char *storage_id, char **storage_path, int *validity, uid_t uid)
 {
        int lib_index = 0;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret = 0;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        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_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);
-                       res = MS_MEDIA_ERR_INTERNAL;
-               }
+               ret = ((CHECK_STORAGE)func_array[lib_index][eCHECK_STORAGE])(handle[lib_index], storage_id, storage_path, validity, uid);
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        MS_DBG("ms_check_storage End");
 
-       return res;
+       return ret;
 }
 
 int ms_insert_storage(void **handle, const char *storage_id, const char *storage_path, uid_t uid)
 {
        int lib_index = 0;
-       int res = MS_MEDIA_ERR_NONE;
        int ret = MS_MEDIA_ERR_NONE;
-       char *err_msg = NULL;
        ms_user_storage_type_e storage_type;
 
        MS_DBG("ms_insert_storage Start");
@@ -922,86 +755,62 @@ int ms_insert_storage(void **handle, const char *storage_id, const char *storage
        MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Fail to get storage type");
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((INSERT_STORAGE)func_array[lib_index][eINSERT_STORAGE])(handle[lib_index], storage_id, storage_type, storage_path, 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);
-                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((INSERT_STORAGE)func_array[lib_index][eINSERT_STORAGE])(handle[lib_index], storage_id, storage_type, storage_path, uid);
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        MS_DBG("ms_insert_storage End");
 
-       return res;
+       return ret;
 }
 
 int ms_update_storage(void **handle, const char *storage_id, const char *storage_path, uid_t uid)
 {
        int lib_index = 0;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret = 0;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        MS_DBG("ms_update_storage Start");
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((UPDATE_STORAGE)func_array[lib_index][eUPDATE_STORAGE])(handle[lib_index], storage_id, storage_path, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((UPDATE_STORAGE)func_array[lib_index][eUPDATE_STORAGE])(handle[lib_index], storage_id, storage_path, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        MS_DBG("ms_update_storage End");
 
-       return res;
+       return ret;
 }
 
 int ms_set_storage_validity(void **handle, const char *storage_id, int validity, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((SET_STORAGE_VALIDITY)func_array[lib_index][eSET_STORAGE_VALIDITY])(handle[lib_index], storage_id, validity, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((SET_STORAGE_VALIDITY)func_array[lib_index][eSET_STORAGE_VALIDITY])(handle[lib_index], storage_id, validity, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 int ms_set_all_storage_validity(void **handle, int validity, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((SET_ALL_STORAGE_VALIDITY)func_array[lib_index][eSET_ALL_STORAGE_VALIDITY])(handle[lib_index], validity, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((SET_ALL_STORAGE_VALIDITY)func_array[lib_index][eSET_ALL_STORAGE_VALIDITY])(handle[lib_index], validity, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 int ms_update_meta_batch(void **handle, const char *path, const char *storage_id, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
        int ret = MS_MEDIA_ERR_NONE;
-       char *err_msg = NULL;
        ms_user_storage_type_e storage_type;
 
        ret = ms_user_get_storage_type(uid, path, &storage_type);
@@ -1010,72 +819,50 @@ int ms_update_meta_batch(void **handle, const char *path, const char *storage_id
        MS_DBG_FENTER();
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((UPDATE_ITEM_META)func_array[lib_index][eUPDATE_ITEM_META])(handle[lib_index], path, storage_id, storage_type, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((UPDATE_ITEM_META)func_array[lib_index][eUPDATE_ITEM_META])(handle[lib_index], path, storage_id, storage_type, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 int ms_delete_invalid_folder_by_path(void **handle, const char *storage_id, const char *folder_path, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((DELETE_INVALID_FOLDER_BY_PATH)func_array[lib_index][eDELETE_INVALID_FOLDER_BY_PATH])(handle[lib_index], storage_id, folder_path, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, storage_id);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((DELETE_INVALID_FOLDER_BY_PATH)func_array[lib_index][eDELETE_INVALID_FOLDER_BY_PATH])(handle[lib_index], storage_id, folder_path, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 int ms_check_folder_exist(void **handle, const char *storage_id, const char *folder_path)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((CHECK_FOLDER_EXIST)func_array[lib_index][eCHECK_FOLDER_EXIST])(handle[lib_index], storage_id, folder_path, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, storage_id);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((CHECK_FOLDER_EXIST)func_array[lib_index][eCHECK_FOLDER_EXIST])(handle[lib_index], storage_id, folder_path); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 int ms_get_folder_id(void **handle, const char *storage_id, const char *path, char **folder_id)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
        char folder_uuid[MS_UUID_SIZE] = {0,};
 
        MS_DBG_FENTER();
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((GET_FOLDER_ID)func_array[lib_index][eGET_FOLDER_ID])(handle[lib_index], storage_id, path, folder_uuid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((GET_FOLDER_ID)func_array[lib_index][eGET_FOLDER_ID])(handle[lib_index], storage_id, path, folder_uuid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        if (strlen(folder_uuid) == (MS_UUID_SIZE-1))
@@ -1085,21 +872,19 @@ int ms_get_folder_id(void **handle, const char *storage_id, const char *path, ch
 
        MS_DBG("folder_id [%s]", *folder_id);
 
-       return res;
+       return ret;
 }
 
 /* FOR BULK COMMIT */
 void ms_register_start(void **handle, ms_noti_switch_e noti_status, int pid)
 {
        int lib_index;
-       int ret = 0;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((INSERT_ITEM_BEGIN)func_array[lib_index][eINSERT_BEGIN])(handle[lib_index], MSC_REGISTER_COUNT, noti_status, pid, &err_msg);/*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
+               ret = ((INSERT_ITEM_BEGIN)func_array[lib_index][eINSERT_BEGIN])(handle[lib_index], MSC_REGISTER_COUNT, noti_status, pid);/*dlopen*/
+               if (ret != MS_MEDIA_ERR_NONE) {
+                       MS_DBG_ERR("error : %s", g_array_index(so_array, char*, lib_index));
                }
        }
 }
@@ -1107,14 +892,12 @@ void ms_register_start(void **handle, ms_noti_switch_e noti_status, int pid)
 void ms_register_end(void **handle, uid_t uid)
 {
        int lib_index;
-       int ret = 0;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((INSERT_ITEM_END)func_array[lib_index][eINSERT_END])(handle[lib_index], uid, &err_msg);/*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
+               ret = ((INSERT_ITEM_END)func_array[lib_index][eINSERT_END])(handle[lib_index], uid);/*dlopen*/
+               if (ret != MS_MEDIA_ERR_NONE) {
+                       MS_DBG_ERR("error : %s", g_array_index(so_array, char*, lib_index));
                }
        }
 }
@@ -1122,14 +905,12 @@ void ms_register_end(void **handle, uid_t uid)
 void ms_validate_start(void **handle)
 {
        int lib_index;
-       int ret = 0;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((SET_ITEM_VALIDITY_BEGIN)func_array[lib_index][eSET_VALIDITY_BEGIN])(handle[lib_index], MSC_VALID_COUNT, &err_msg);/*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
+               ret = ((SET_ITEM_VALIDITY_BEGIN)func_array[lib_index][eSET_VALIDITY_BEGIN])(handle[lib_index], MSC_VALID_COUNT);/*dlopen*/
+               if (ret != MS_MEDIA_ERR_NONE) {
+                       MS_DBG_ERR("error : %s", g_array_index(so_array, char*, lib_index));
                }
        }
 }
@@ -1137,14 +918,12 @@ void ms_validate_start(void **handle)
 void ms_validate_end(void **handle, uid_t uid)
 {
        int lib_index;
-       int ret = 0;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((SET_ITEM_VALIDITY_END)func_array[lib_index][eSET_VALIDITY_END])(handle[lib_index], uid, &err_msg);/*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
+               ret = ((SET_ITEM_VALIDITY_END)func_array[lib_index][eSET_VALIDITY_END])(handle[lib_index], uid);/*dlopen*/
+               if (ret != MS_MEDIA_ERR_NONE) {
+                       MS_DBG_ERR("error : %s", g_array_index(so_array, char*, lib_index));
                }
        }
 }
@@ -1152,14 +931,12 @@ void ms_validate_end(void **handle, uid_t uid)
 void ms_insert_folder_start(void **handle)
 {
        int lib_index;
-       int ret = 0;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((INSERT_FOLDER_BEGIN)func_array[lib_index][eINSERT_FOLDER_BEGIN])(handle[lib_index], MSC_REGISTER_COUNT, &err_msg);/*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
+               ret = ((INSERT_FOLDER_BEGIN)func_array[lib_index][eINSERT_FOLDER_BEGIN])(handle[lib_index], MSC_REGISTER_COUNT);/*dlopen*/
+               if (ret != MS_MEDIA_ERR_NONE) {
+                       MS_DBG_ERR("error : %s", g_array_index(so_array, char*, lib_index));
                }
        }
 }
@@ -1167,14 +944,12 @@ void ms_insert_folder_start(void **handle)
 void ms_insert_folder_end(void **handle, uid_t uid)
 {
        int lib_index;
-       int ret = 0;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((INSERT_FOLDER_END)func_array[lib_index][eINSERT_FOLDER_END])(handle[lib_index], uid, &err_msg);/*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
+               ret = ((INSERT_FOLDER_END)func_array[lib_index][eINSERT_FOLDER_END])(handle[lib_index], uid);/*dlopen*/
+               if (ret != MS_MEDIA_ERR_NONE) {
+                       MS_DBG_ERR("error : %s", g_array_index(so_array, char*, lib_index));
                }
        }
 }
@@ -1182,14 +957,12 @@ void ms_insert_folder_end(void **handle, uid_t uid)
 void ms_update_start(void **handle)
 {
        int lib_index;
-       int ret = 0;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((UPDATE_ITEM_BEGIN)func_array[lib_index][eUPDATE_ITEM_BEGIN])(handle[lib_index], MSC_VALID_COUNT, &err_msg);/*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
+               ret = ((UPDATE_ITEM_BEGIN)func_array[lib_index][eUPDATE_ITEM_BEGIN])(handle[lib_index], MSC_VALID_COUNT);/*dlopen*/
+               if (ret != MS_MEDIA_ERR_NONE) {
+                       MS_DBG_ERR("error : %s", g_array_index(so_array, char*, lib_index));
                }
        }
 }
@@ -1197,14 +970,12 @@ void ms_update_start(void **handle)
 void ms_update_end(void **handle, uid_t uid)
 {
        int lib_index;
-       int ret = 0;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((UPDATE_ITEM_END)func_array[lib_index][eUPDATE_ITEM_END])(handle[lib_index], uid, &err_msg);/*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
+               ret = ((UPDATE_ITEM_END)func_array[lib_index][eUPDATE_ITEM_END])(handle[lib_index], uid);/*dlopen*/
+               if (ret != MS_MEDIA_ERR_NONE) {
+                       MS_DBG_ERR("error : %s", g_array_index(so_array, char*, lib_index));
                }
        }
 }
@@ -1212,49 +983,36 @@ void ms_update_end(void **handle, uid_t uid)
 int ms_get_folder_scan_status(void **handle, const char *storage_id, const char *path, int *scan_status)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
        int status = 0;
 
        //MS_DBG("");
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((GET_FOLDER_SCAN_STATUS)func_array[lib_index][eGET_FOLDER_SCAN_STATUS])(handle[lib_index], storage_id, path, &status, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               } else {
-                       *scan_status = status;
-               }
+               ret = ((GET_FOLDER_SCAN_STATUS)func_array[lib_index][eGET_FOLDER_SCAN_STATUS])(handle[lib_index], storage_id, path, &status); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
+               *scan_status = status;
        }
 
        MS_DBG("OK path = [%s], scan_status = [%d]", path, *scan_status);
 
-       return res;
+       return ret;
 }
 
 int ms_set_folder_scan_status(void **handle, const char *storage_id, const char *path, int scan_status, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
        int status = scan_status;
 
        //MS_DBG("");
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((SET_FOLDER_SCAN_STATUS)func_array[lib_index][eSET_FOLDER_SCAN_STATUS])(handle[lib_index], storage_id, path, status, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_UPDATE_FAIL;
-               }
+               ret = ((SET_FOLDER_SCAN_STATUS)func_array[lib_index][eSET_FOLDER_SCAN_STATUS])(handle[lib_index], storage_id, path, status, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        MS_DBG("OK path = [%s], scan_status = [%d]", path, scan_status);
 
-       return res;
+       return ret;
 }
 
 int ms_check_folder_modified(void **handle, const char *path, const char *storage_id, bool *modified)
@@ -1262,19 +1020,14 @@ int ms_check_folder_modified(void **handle, const char *path, const char *storag
        MS_DBG("path = [%s], storage_id = [%s]", path, storage_id);
 
        int lib_index;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((CHECK_FOLDER_MODIFIED)func_array[lib_index][eCHECK_FOLDER_MODIFIED])(handle[lib_index], path, storage_id, modified, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       return MS_MEDIA_ERR_INTERNAL;
-               }
+               ret = ((CHECK_FOLDER_MODIFIED)func_array[lib_index][eCHECK_FOLDER_MODIFIED])(handle[lib_index], path, storage_id, modified); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return MS_MEDIA_ERR_NONE;
+       return ret;
 }
 
 int ms_get_null_scan_folder_list(void **handle, const char *stroage_id, const char *path, GArray **dir_array)
@@ -1282,20 +1035,15 @@ int ms_get_null_scan_folder_list(void **handle, const char *stroage_id, const ch
        //MS_DBG("folder stroage_id: %s", stroage_id);
 
        int lib_index;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
        char **folder_list = NULL;
        char *sub_path = NULL;
        int count = 0;
        int i = 0;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((GET_NULL_SCAN_FOLDER_LIST)func_array[lib_index][eGET_NULL_SCAN_FOLDER_LIST])(handle[lib_index], stroage_id, path, &folder_list, &count, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
-                       MS_SAFE_FREE(err_msg);
-                       return MS_MEDIA_ERR_INTERNAL;
-               }
+               ret = ((GET_NULL_SCAN_FOLDER_LIST)func_array[lib_index][eGET_NULL_SCAN_FOLDER_LIST])(handle[lib_index], stroage_id, path, &folder_list, &count); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
        //MS_DBG("GET_NULL_SCAN_FOLDER_LIST OK");
@@ -1311,45 +1059,33 @@ int ms_get_null_scan_folder_list(void **handle, const char *stroage_id, const ch
 
        MS_SAFE_FREE(folder_list);
 
-       return MS_MEDIA_ERR_NONE;
+       return ret;
 }
 
 int ms_change_validity_item_batch(void **handle, const char *storage_id, const char *path, int des_validity, int src_validity, uid_t uid)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((CHANGE_VALIDITY_ITEM_BATCH)func_array[lib_index][eCHANGE_VALIDITY_ITEM_BATCH])(handle[lib_index], storage_id, path, des_validity, src_validity, uid, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, storage_id);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((CHANGE_VALIDITY_ITEM_BATCH)func_array[lib_index][eCHANGE_VALIDITY_ITEM_BATCH])(handle[lib_index], storage_id, path, des_validity, src_validity, uid); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 int ms_get_media_type(void **handle, const char *path, int *media_type)
 {
        int lib_index;
-       int res = MS_MEDIA_ERR_NONE;
-       int ret;
-       char *err_msg = NULL;
+       int ret = MS_MEDIA_ERR_NONE;
 
        for (lib_index = 0; lib_index < lib_num; lib_index++) {
-               ret = ((GET_MEDIA_TYPE)func_array[lib_index][eGET_MEDIA_TYPE])(handle[lib_index], path, media_type, &err_msg); /*dlopen*/
-               if (ret != 0) {
-                       MS_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
-                       MS_SAFE_FREE(err_msg);
-                       res = MS_MEDIA_ERR_DB_INSERT_FAIL;
-               }
+               ret = ((GET_MEDIA_TYPE)func_array[lib_index][eGET_MEDIA_TYPE])(handle[lib_index], path, media_type); /*dlopen*/
+               MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "Error : %s", g_array_index(so_array, char*, lib_index));
        }
 
-       return res;
+       return ret;
 }
 
 bool ms_check_support_media_type(void **handle, const char *path)