X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmedia_util_private.c;h=f6e1e688181041f7745925734b94033f85a11dd2;hb=74bdc88b1bb73967a71589a4c809a9b669046ac9;hp=37cea491ccac6b139cbcfc5dcfb0c4e8a1091759;hpb=59caaf5a163a9395669592130cfaa1af5c4f0116;p=platform%2Fcore%2Fapi%2Fmedia-content.git

diff --git a/src/media_util_private.c b/src/media_util_private.c
index 37cea49..f6e1e68 100755
--- a/src/media_util_private.c
+++ b/src/media_util_private.c
@@ -14,14 +14,45 @@
 * limitations under the License.
 */
 
+
 #include <dirent.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
 #include <fcntl.h>
-#include <media_util_private.h>
 #include <media_info_private.h>
-#include <media_content_type.h>
+#include <storage.h>
+#include <system_info.h>
+#include <sys/stat.h>
+
+static int MEDIA_CONTENT_OTHER_SUPPORT = -1;
+
+bool _media_util_check_support_media_type(const char *path)
+{
+	int ret = SYSTEM_INFO_ERROR_NONE;
+	int media_type = -1;
+	bool is_supported = false;
+
+	content_retvm_if(!STRING_VALID(path), false, "path is empty");
+
+	if (MEDIA_CONTENT_OTHER_SUPPORT == -1) {
+		ret = system_info_get_platform_bool("http://tizen.org/feature/content.scanning.others", &is_supported);
+		if (ret != SYSTEM_INFO_ERROR_NONE) {
+			content_debug("SYSTEM_INFO_ERROR: content.scanning.others [%d]", ret);
+			return false;
+		}
+
+		MEDIA_CONTENT_OTHER_SUPPORT = is_supported;
+	}
+
+	/* If not, check media type */
+	if (!MEDIA_CONTENT_OTHER_SUPPORT) {
+		ret = media_svc_get_media_type(path, &media_type);
+		content_retvm_if(ret != MS_MEDIA_ERR_NONE, false, "Failed to get media type");
+
+		if (media_type == MEDIA_CONTENT_TYPE_OTHERS)
+			return false;
+	}
+
+	return true;
+}
 
 int _media_util_check_file_exist(const char *path)
 {
@@ -29,12 +60,14 @@ int _media_util_check_file_exist(const char *path)
 
 	/* check the file exits actually */
 	exist = open(path, O_RDONLY);
-	if(exist < 0) {
-		media_content_sec_debug("path [%s]", path);
-		media_content_stderror("open file fail");
+	if (exist < 0) {
 		if (errno == EACCES || errno == EPERM) {
+			content_stderror("open file fail");
+			content_sec_debug("path [%s]", path);
 			return MEDIA_CONTENT_ERROR_PERMISSION_DENIED;
 		} else {
+			content_stderror("open file fail");
+			content_sec_debug("path [%s]", path);
 			return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 		}
 	}
@@ -44,132 +77,257 @@ int _media_util_check_file_exist(const char *path)
 	return MEDIA_CONTENT_ERROR_NONE;
 }
 
-int _media_util_check_ignore_file(const char *path, bool *ignore)
+int _media_util_get_file_time(const char *path)
+{
+	struct stat statbuf;
+	int ret = 0;
+
+	memset(&statbuf, 0, sizeof(struct stat));
+	ret = stat(path, &statbuf);
+	if (ret == -1) {
+		content_stderror("stat failed");
+		return ret;
+	}
+
+	return statbuf.st_mtime;
+}
+
+bool _media_util_is_ignorable_file(const char *path)
 {
-	media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
+	char *tmp_path = NULL;
+	char *org_path = NULL;
+
+#ifndef _USE_TVPD_MODE
+	char replace[MAX_PATH_LEN] = {0, };
+#endif
 
-	*ignore = FALSE;
+	content_retip_if_fail(STRING_VALID(path));
 
-	if(strstr(path, "/.") != NULL)
-	{
-		*ignore = TRUE;
-		media_content_error("hidden path");
-		media_content_sec_debug("path : %s", path);
+	/* Check is exist (It may be the path to the deleted file) */
+	if (!g_file_test(path, G_FILE_TEST_EXISTS)) {
+		content_sec_debug("removed path[%s]", path);
+		return false;
 	}
 
-	return MEDIA_CONTENT_ERROR_NONE;
+	/* Check symbolic link file */
+	if (g_file_test(path, G_FILE_TEST_IS_SYMLINK)) {
+		content_error("symbolic link(file)");
+		content_sec_debug("path : %s", path);
+		return true;
+	}
+
+	/* Check hidden path */
+	if (strstr(path, "/.") != NULL) {
+		content_error("hidden path");
+		content_sec_debug("path : %s", path);
+		return true;
+	}
+
+	/* Check symbolic directory */
+	tmp_path = realpath(path, NULL);
+	/* Get trimmed path */
+	org_path = g_canonicalize_filename(path, NULL);
+
+#ifdef _USE_TVPD_MODE
+	if (g_strcmp0(tmp_path, org_path) != 0) {
+		content_error("symbolic link(directory)");
+		content_sec_debug("path[%s] real[%s]", org_path, tmp_path);
+		SAFE_FREE(tmp_path);
+		g_free(org_path);
+		return true;
+	}
+#else
+	if (g_str_has_prefix(tmp_path, MEDIA_SHARE_PATH)) {
+		/* If shared dirctory, it should be change path to TZ_USER_SHARE from realpath */
+		snprintf(replace, MAX_PATH_LEN, "%s%s", tzplatform_getenv(TZ_USER_MEDIASHARED), tmp_path + strlen(MEDIA_SHARE_PATH));
+		if (g_strcmp0(replace, org_path) != 0) {
+			content_error("symbolic link(directory)");
+			content_sec_debug("path[%s] real[%s]", org_path, tmp_path);
+			SAFE_FREE(tmp_path);
+			g_free(org_path);
+			return true;
+		}
+	} else {
+		if (g_strcmp0(tmp_path, org_path) != 0) {
+			content_error("symbolic link(directory)");
+			content_sec_debug("path[%s] real[%s]", org_path, tmp_path);
+			SAFE_FREE(tmp_path);
+			g_free(org_path);
+			return true;
+		}
+	}
+#endif
+	SAFE_FREE(tmp_path);
+	g_free(org_path);
+
+	return false;
 }
 
-int _media_util_check_ignore_dir(const char *dir_path, bool *ignore)
+static bool __is_scan_ignore_exist(const char *path)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
-	media_svc_storage_type_e storage_type = 0;
 	const char *scan_ignore = ".scan_ignore";
-	bool find = false;
+	char *ignore_path = NULL;
+	gboolean result = FALSE;
+
+	if (!STRING_VALID(path))
+		return false;
+
+	ignore_path = g_build_path(G_DIR_SEPARATOR_S, path, scan_ignore, NULL);
+	result = g_file_test(ignore_path, G_FILE_TEST_EXISTS);
+
+	if (result)
+		content_error("scan ignore file exist [%s]", ignore_path);
+
+	g_free(ignore_path);
+
+	return (bool)result;
+}
+
+bool _media_util_is_ignorable_dir(const char *dir_path)
+{
+	int ret = MEDIA_CONTENT_ERROR_NONE;
+	ms_user_storage_type_e storage_type = MS_USER_STORAGE_INTERNAL;
 
-	media_content_sec_debug("dir_path : %s", dir_path);
+	content_retip_if_fail(STRING_VALID(dir_path));
 
-	media_content_retvm_if(!STRING_VALID(dir_path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid dir_path");
+	content_sec_debug("dir_path : %s", dir_path);
 
-	*ignore = FALSE;
 	/*1. Check Hidden Directory*/
-	if(strstr(dir_path, "/.") != NULL)
-	{
-		*ignore = TRUE;
-		media_content_error("hidden path");
-		return MEDIA_CONTENT_ERROR_NONE;
+	if (strstr(dir_path, "/.") != NULL) {
+		content_error("hidden path");
+		return true;
 	}
 
 	/*2. Check Scan Ignore Directory*/
-	ret = media_svc_get_storage_type(dir_path, &storage_type, tzplatform_getuid(TZ_USER_NAME));
-	if(ret != MS_MEDIA_ERR_NONE)
-	{
-		media_content_error("media_svc_get_storage_type failed : %d", ret);
-		return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+	ret = ms_user_get_storage_type(_content_get_uid(), dir_path, &storage_type);
+	if (ret != MS_MEDIA_ERR_NONE) {
+		content_error("ms_user_get_storage_type failed : %d", ret);
+		return false;
 	}
 
-	DIR *dp = NULL;
-	struct dirent entry;
-	struct dirent *result = NULL;
-
 	char *leaf_path = NULL;
-	char search_path[4096] = {0, };
-
-	strncpy(search_path, dir_path, strlen(dir_path));
-	while(STRING_VALID(search_path))
-	{
-		dp = opendir(search_path);
-		if (dp == NULL) {
-			*ignore = TRUE;
-			media_content_error("Open Directory fail");
-			media_content_sec_debug("Open fail path[%s]", search_path);
+	char search_path[MAX_PATH_LEN] = {0, };
+
+	SAFE_STRLCPY(search_path, dir_path, sizeof(search_path));
+
+	while (STRING_VALID(search_path)) {
+		if (__is_scan_ignore_exist(search_path))
+			return true;
+
+		leaf_path = strrchr(search_path, '/');
+		if (!leaf_path)
+			break;
+
+		search_path[leaf_path - search_path] = '\0';
+	}
+
+	return false;
+}
+
+int _media_content_check_dir(const char *path)
+{
+	DIR *dp = NULL;
+	char *real = NULL;
+	char *origin = NULL;
+#ifndef _USE_TVPD_MODE
+	char result_path[MAX_PATH_LEN] = {0, };
+#endif
+	dp = opendir(path);
+	if (dp == NULL) {
+		if (errno == EACCES || errno == EPERM) {
+			content_stderror("open dir fail");
+			content_sec_error("path [%s]", path);
+			return MEDIA_CONTENT_ERROR_PERMISSION_DENIED;
+		} else {
+			content_stderror("open dir fail");
+			content_sec_error("path [%s]", path);
 			return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 		}
+	}
 
-		media_content_retvm_if(dp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "Open Directory fail");
-
-		while (!readdir_r(dp, &entry, &result))
-		{
-			if (result == NULL)
-				break;
-
-			if(STRING_VALID(entry.d_name) && (strcmp(entry.d_name, scan_ignore) == 0))
-			{
-				media_content_error("Find Ignore path");
-				media_content_sec_debug("Ignore path[%s]", search_path);
-				find = TRUE;
-				break;
-			}
-			else
-			{
-				//media_content_sec_debug("entry.d_name[%s]", entry.d_name);
-				continue;
-			}
-		}
+	closedir(dp);
 
-		if (dp)	closedir(dp);
-		dp = NULL;
+	/* Check symbolic link directory */
+	real = realpath(path, NULL);
+	/* Get trimmed path */
+	origin = g_canonicalize_filename(path, NULL);
 
-		if(find)
-		{
-			*ignore = TRUE;
-			break;
+#ifdef _USE_TVPD_MODE
+	if (g_strcmp0(real, origin) != 0) {
+		content_error("symbolic link(directory)");
+		content_sec_debug("path[%s] real[%s]", origin, real);
+		SAFE_FREE(real);
+		g_free(origin);
+		return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+	}
+#else
+	if (g_str_has_prefix(real, MEDIA_SHARE_PATH)) {
+		/* If shared dirctory, it should be change path to TZ_USER_SHARE from realpath */
+		snprintf(result_path, MAX_PATH_LEN, "%s%s", tzplatform_getenv(TZ_USER_MEDIASHARED), real + strlen(MEDIA_SHARE_PATH));
+		if (g_strcmp0(result_path, origin) != 0) {
+			content_error("symbolic link(directory)");
+			content_sec_debug("path[%s] real[%s]", origin, real);
+			SAFE_FREE(real);
+			g_free(origin);
+			return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 		}
-		else
-		{
-			/*If root path, Stop Scanning*/
-			if((storage_type == MEDIA_SVC_STORAGE_INTERNAL) && (STRING_VALID(MEDIA_ROOT_PATH_INTERNAL) && strcmp(search_path, MEDIA_ROOT_PATH_INTERNAL) == 0)) {
-				break;
-			} else if((storage_type == MEDIA_SVC_STORAGE_EXTERNAL) && (STRING_VALID(MEDIA_ROOT_PATH_SDCARD)) && (strcmp(search_path, MEDIA_ROOT_PATH_SDCARD) == 0)) {
-				break;
-			} else if(storage_type == MEDIA_SVC_STORAGE_EXTERNAL_USB) {
-				char *parent_folder_path = NULL;
-				bool is_root = FALSE;
-
-				parent_folder_path = g_path_get_dirname(search_path);
-				if (STRING_VALID(MEDIA_ROOT_PATH_USB) && (strcmp(parent_folder_path, MEDIA_ROOT_PATH_USB) == 0))
-					is_root = TRUE;
-
-				SAFE_FREE(parent_folder_path);
-
-				if (is_root == TRUE)
-					break;
-			}
-
-			leaf_path = strrchr(search_path, '/');
-			if(leaf_path != NULL)
-			{
-				int seek_len = leaf_path -search_path;
-				search_path[seek_len] = '\0';
-				//media_content_sec_debug("go to other dir [%s]", search_path);
-			}
-			else
-			{
-				media_content_debug("Fail to find leaf path");
-				break;
-			}
+	} else {
+		if (g_strcmp0(real, origin) != 0) {
+			content_error("symbolic link(directory)");
+			content_sec_debug("path[%s] real[%s]", origin, real);
+			SAFE_FREE(real);
+			g_free(origin);
+			return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 		}
 	}
+#endif
+
+	SAFE_FREE(real);
+	g_free(origin);
 
 	return MEDIA_CONTENT_ERROR_NONE;
 }
+
+
+/* FIXME : If there are no issue reports related to this, it will be deleted in tizen 6.5 or after. */
+char * _media_content_replace_path_in_condition(const char *condition)
+{
+	return g_strdup(condition);
+#if 0
+	char **split_list = NULL;
+	char *result = NULL;
+
+	if (!STRING_VALID(MEDIA_ROOT_PATH_INTERNAL_OLD) || !STRING_VALID(MEDIA_ROOT_PATH_INTERNAL))
+		return NULL;
+
+	content_sec_debug("Old condition[%s]", condition);
+
+	split_list = g_strsplit(condition, MEDIA_ROOT_PATH_INTERNAL_OLD, -1);
+	if (!split_list)
+		return NULL;
+
+	result = g_strjoinv(MEDIA_ROOT_PATH_INTERNAL, split_list);
+	g_strfreev(split_list);
+
+	return result;
+#endif
+}
+
+/* FIXME : If there are no issue reports related to this, it will be deleted in Tizen 6.5 or after. */
+int _media_content_replace_path(const char *path, char *replace_path)
+{
+	content_retip_if_fail(STRING_VALID(path));
+
+	snprintf(replace_path, MAX_PATH_LEN, "%s", path);
+#if 0
+	if (strncmp(path, MEDIA_ROOT_PATH_INTERNAL_OLD, strlen(MEDIA_ROOT_PATH_INTERNAL_OLD)) == 0) {
+		content_sec_debug("Old path[%s]", path);
+		snprintf(replace_path, MAX_PATH_LEN, "%s%s", MEDIA_ROOT_PATH_INTERNAL, path + strlen(MEDIA_ROOT_PATH_INTERNAL_OLD));
+	} else {
+		snprintf(replace_path, MAX_PATH_LEN, "%s", path);
+	}
+#endif
+
+	return MEDIA_CONTENT_ERROR_NONE;
+}
+