X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=src%2Fstorage-inhouse.c;h=ef71f9834a2877142195fa05a04910187caf3eff;hb=ec9ff3c69455dbfc073e7f36a3a9147b4b7533dc;hp=37fa5a0b323f19e102e485897d5573d335db5a24;hpb=bf3d90469c74170299a68ff3deb473c8f000df97;p=platform%2Fcore%2Fsystem%2Flibstorage.git

diff --git a/src/storage-inhouse.c b/src/storage-inhouse.c
index 37fa5a0..ef71f98 100755
--- a/src/storage-inhouse.c
+++ b/src/storage-inhouse.c
@@ -15,18 +15,25 @@
  */
 
 
+#include <unistd.h>
+#include <sys/types.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <tzplatform_config.h>
+#include <blkid.h>
+#include <libsyscommon/libgdbus.h>
+#include <libsyscommon/common.h>
 
 #include "common.h"
-#include "list.h"
 #include "log.h"
 #include "storage-internal.h"
 #include "storage-external-dbus.h"
-#include "storage-experimental.h"
+
+#define FORMAT_TIMEOUT	(120*1000)
+#define USER_PARTITION "user"
+#define CONTAINER_USER_PARTITION "contain-user"
 
 /*
 	Get compat path from origin Multi-user path
@@ -47,6 +54,7 @@
 		else
 			// can convert. use dest path
  */
+//LCOV_EXCL_START Untested function
 API int storage_get_compat_internal_path(const char* origin, int len, char* compat)
 {
 	int r = -1;
@@ -58,13 +66,23 @@ API int storage_get_compat_internal_path(const char* origin, int len, char* comp
 		return -1;
 	}
 
+	if (getuid() <= USER_UID_START) {
+		//LCOV_EXCL_START System Error
+		_E("Only apps and user session daemons are allowed "
+				"to use storage_get_compat_internal_path()");
+		return -1;
+		//LCOV_EXCL_STOP
+	}
+
 	// this API works on place where compat path is bind-mounted
 	if (!is_compat_bind_mount()) {
+		//LCOV_EXCL_START System Error
 		_E("No compat bind mount");
 		return -1;
+		//LCOV_EXCL_STOP
 	}
 
-	str = tzplatform_getenv(TZ_USER_CONTENT);
+	str = tzplatform_uid_getenv(getuid(), TZ_USER_CONTENT);
 	str_len = strlen(str);
 	if (strncmp(origin, str, str_len) != 0) {
 		_E("Failed to match TZ_USER_CONTENT");
@@ -73,12 +91,15 @@ API int storage_get_compat_internal_path(const char* origin, int len, char* comp
 
 	r = snprintf(compat, len, "%s%s", COMPAT_DIR, origin + str_len);
 	if (r < 0) {
+		//LCOV_EXCL_START System Error
 		_E("Failed to create new path");
 		return -1;
+		//LCOV_EXCL_STOP
 	}
 
 	return 0;
 }
+//LCOV_EXCL_STOP
 
 /*
 	Get Multi-user path from compat path
@@ -109,10 +130,20 @@ API int storage_get_origin_internal_path(const char* compat, int len, char* orig
 		return -1;
 	}
 
+	if (getuid() <= USER_UID_START) {
+		//LCOV_EXCL_START System Error
+		_E("Only apps and user session daemons are allowed "
+				"to use storage_get_origin_internal_path()");
+		return -1;
+		//LCOV_EXCL_STOP
+	}
+
 	// this API works on place where compat path is bind-mounted
 	if (!is_compat_bind_mount()) {
+		//LCOV_EXCL_START System Error
 		_E("no compat bind mount");
 		return -1;
+		//LCOV_EXCL_STOP
 	}
 
 	compat_len = strlen(COMPAT_DIR);
@@ -121,10 +152,12 @@ API int storage_get_origin_internal_path(const char* compat, int len, char* orig
 		return -1;
 	}
 
-	r = snprintf(origin, len, "%s%s", tzplatform_getenv(TZ_USER_CONTENT), compat + compat_len);
+	r = snprintf(origin, len, "%s%s", tzplatform_uid_getenv(getuid(), TZ_USER_CONTENT), compat + compat_len);
 	if (r < 0) {
+		//LCOV_EXCL_START System Error
 		_E("failed to create new path");
 		return -1;
+		//LCOV_EXCL_STOP
 	}
 
 	return 0;
@@ -132,95 +165,373 @@ API int storage_get_origin_internal_path(const char* compat, int len, char* orig
 
 API int storage_get_primary_sdcard(int *storage_id, char **path)
 {
-	GVariant *result;
-	storage_ext_device info;
+	GVariant *reply;
+	int ret, ret_dbus;
+	char *reply_mount_point = NULL;
+	int reply_id;
 
 	if (!storage_id || !path)
 		return STORAGE_ERROR_INVALID_PARAMETER;
 
-	result = dbus_method_call_sync(STORAGE_EXT_BUS_NAME,
+	if (!storage_ext_is_supported())
+		return STORAGE_ERROR_NOT_SUPPORTED;
+
+	dbus_handle_h dbus_handle = gdbus_get_connection(G_BUS_TYPE_SYSTEM, true);
+	if (dbus_handle == NULL) {
+		_E("Failed to get dbus connection");
+		return STORAGE_ERROR_OPERATION_FAILED;
+	}
+
+	ret_dbus = gdbus_priv_call_sync_with_reply(dbus_handle,
+			STORAGE_EXT_BUS_NAME,
 			STORAGE_EXT_PATH_MANAGER,
 			STORAGE_EXT_IFACE_MANAGER,
 			"GetMmcPrimary",
-			NULL);
-	if (!result) {
+			NULL,
+			&reply);
+
+	gdbus_free_connection(dbus_handle);
+
+	if (ret_dbus < 0) {
+		//LCOV_EXCL_START System Error
 		_E("Failed to get primary sdcard partition"); //LCOV_EXCL_LINE
 		return STORAGE_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+		//LCOV_EXCL_STOP
 	}
 
-	g_variant_get(result, "(issssssisibii)",
-			&info.type, &info.devnode, &info.syspath,
-			&info.fs_usage, &info.fs_type,
-			&info.fs_version, &info.fs_uuid,
-			&info.readonly, &info.mount_point,
-			&info.state, &info.primary,
-			&info.flags, &info.storage_id);
+	if (!g_variant_get_safe(reply, "(issssssisibii)",
+			NULL, NULL, NULL,
+			NULL, NULL,
+			NULL, NULL,
+			NULL, &reply_mount_point,
+			NULL, NULL,
+			NULL, &reply_id)) {
+		g_variant_unref(reply);
+		return STORAGE_ERROR_OPERATION_FAILED;
+	}
 
-	g_variant_unref(result);
+	g_variant_unref(reply);
 
-	if (info.storage_id < 0)
-		return STORAGE_ERROR_NO_DEVICE;
+	if (reply_id < 0) {
+		ret = STORAGE_ERROR_NO_DEVICE;
+		goto out;
+	}
+
+	*path = strdup(reply_mount_point);
+	if (*path == NULL) {
+		ret = STORAGE_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE System Error
+		goto out;
+	}
 
-	*path = strdup(info.mount_point);
-	if (*path == NULL)
-		return STORAGE_ERROR_OUT_OF_MEMORY;
+	*storage_id = reply_id;
 
-	*storage_id = info.storage_id;
+	ret = STORAGE_ERROR_NONE;
+out:
+	g_free(reply_mount_point);
+
+	return ret;
+}
+
+API int storage_get_storage_level(const char *path, char **level)
+{
+	int ret_level;
+
+	if (!level || !path)
+		return STORAGE_ERROR_INVALID_PARAMETER;
+
+	ret_level = storage_ext_get_storage_level(path, level);
+	if (ret_level == -ENOMEM)
+		return STORAGE_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE System Error
+	else if (ret_level == -EINVAL)
+		return STORAGE_ERROR_INVALID_PARAMETER;
+	else if (ret_level < 0)
+		return STORAGE_ERROR_OPERATION_FAILED;
 
 	return STORAGE_ERROR_NONE;
 }
 
-API int storage_get_type_dev(int storage_id, storage_type_e *type, storage_dev_e *dev)
+//LCOV_EXCL_START Not called callback
+static void mount_mmc_cb(GVariant *var, void *user_data, GError *err)
 {
-	storage_ext_device *ext_dev;
-	int ret;
+	struct mmc_contents *mmc_data = (struct mmc_contents*)user_data;
+	int mmc_ret = -1;
 
-	if (storage_id < 0) {
-		_E("Invalid parameger");
-		return STORAGE_ERROR_NOT_SUPPORTED;
+	_D("mount_mmc_cb called");
+
+	if (!var) {
+		_E("no message [%s]", err->message);
+		mmc_ret = -EBADMSG;
+		goto exit;
 	}
 
-	if (!type) {
-		_E("Invalid parameger");
-		return STORAGE_ERROR_INVALID_PARAMETER;
+	g_variant_get(var, "(i)", &mmc_ret);
+
+	_I("Mount State : %d", mmc_ret);
+
+exit:
+	if (var)
+		g_variant_unref(var);
+	(mmc_data->mmc_cb)(mmc_ret, mmc_data->user_data);
+}
+//LCOV_EXCL_STOP
+
+API int storage_request_mount_mmc(struct mmc_contents *mmc_data)
+{
+	void (*mount_cb)(GVariant *, void *, GError *) = NULL;
+	void *data = NULL;
+	char *path;
+	int ret_val;
+	int id;
+
+	if (mmc_data && mmc_data->mmc_cb) {
+		_I("Mount callback exists");
+		mount_cb = mount_mmc_cb;
+		data = mmc_data;
+	}
+
+	ret_val = storage_get_primary_sdcard(&id, &path);
+	if (ret_val != STORAGE_ERROR_NONE)
+		return ret_val;
+//LCOV_EXCL_START System Error
+	if (path)
+		free(path);
+//LCOV_EXCL_STOP
+
+	ret_val = gdbus_call_async_with_reply(STORAGE_EXT_BUS_NAME,
+			STORAGE_EXT_PATH_MANAGER,
+			STORAGE_EXT_IFACE_MANAGER,
+			"Mount",
+			g_variant_new("(is)", id, ""),
+			mount_cb,
+			-1,
+			data);
+
+	_I("Mount Request %s", ret_val == 0 ? "Success" : "Failed");
+
+	if (ret_val == -ENOMEM)
+		return STORAGE_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE System Error
+	if (ret_val < 0)
+		return STORAGE_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+
+	return STORAGE_ERROR_NONE;
+}
+
+//LCOV_EXCL_START Not called callback
+static void unmount_mmc_cb(GVariant *var, void *user_data, GError *err)
+{
+	struct mmc_contents *mmc_data = (struct mmc_contents*)user_data;
+	int mmc_ret;
+
+	_D("unmount_mmc_cb called");
+
+	if (!var) {
+		_E("no message [%s]", err->message);
+		mmc_ret = -EBADMSG;
+		goto exit;
 	}
 
-	if (!dev) {
-		_E("Invalid parameger");
+	g_variant_get(var, "(i)", &mmc_ret);
+
+	_I("Unmount State : %d", mmc_ret);
+
+exit:
+	if (var)
+		g_variant_unref(var);
+	(mmc_data->mmc_cb)(mmc_ret, mmc_data->user_data);
+}
+//LCOV_EXCL_STOP
+
+API int storage_request_unmount_mmc(struct mmc_contents *mmc_data, int option)
+{
+	void (*unmount_cb)(GVariant *, void *, GError *) = NULL;
+	void *data = NULL;
+	char *path;
+	int ret_val;
+	int id;
+
+	if (option < 0 || option > 1)
 		return STORAGE_ERROR_INVALID_PARAMETER;
+
+	if (mmc_data && mmc_data->mmc_cb) {
+		_I("Unmount callback exists");
+		unmount_cb = unmount_mmc_cb;
+		data = mmc_data;
+	}
+
+	ret_val = storage_get_primary_sdcard(&id, &path);
+	if (ret_val != STORAGE_ERROR_NONE)
+		return ret_val;
+//LCOV_EXCL_START System Error
+	if (path)
+		free(path);
+//LCOV_EXCL_STOP
+
+	ret_val = gdbus_call_async_with_reply(STORAGE_EXT_BUS_NAME,
+			STORAGE_EXT_PATH_MANAGER,
+			STORAGE_EXT_IFACE_MANAGER,
+			"Unmount",
+			g_variant_new("(ii)", id, option),
+			unmount_cb,
+			-1,
+			data);
+
+	_I("Unmount Request %s", ret_val == 0 ? "Success" : "Failed");
+
+	if (ret_val == -ENOMEM)
+		return STORAGE_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE System Error
+	if (ret_val < 0)
+		return STORAGE_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+
+	return STORAGE_ERROR_NONE;
+}
+
+//LCOV_EXCL_START Not called callback
+static void format_mmc_cb(GVariant *var, void *user_data, GError *err)
+{
+	struct mmc_contents *mmc_data = (struct mmc_contents*)user_data;
+	int mmc_ret;
+
+	_D("format_mmc_cb called");
+
+	if (!var) {
+		_E("no message [%s]", err->message);
+		mmc_ret = -EBADMSG;
+		goto exit;
 	}
 
-	ret = storage_get_type(storage_id, type);
-	if (ret != STORAGE_ERROR_NONE) {
-		_E("Failed to get storage type: %d", ret);
-		return ret;
+	g_variant_get(var, "(i)", &mmc_ret);
+
+	_I("Format State : %d", mmc_ret);
+
+exit:
+	if (var)
+		g_variant_unref(var);
+	(mmc_data->mmc_cb)(mmc_ret, mmc_data->user_data);
+}
+//LCOV_EXCL_STOP
+
+API int storage_request_format_mmc(struct mmc_contents *mmc_data)
+{
+	return storage_format_mmc(mmc_data, 1);
+}
+
+API int storage_format_mmc(struct mmc_contents *mmc_data, int option)
+{
+	void (*format_cb)(GVariant *, void *, GError *) = NULL;
+	void *data = NULL;
+	char *path;
+	int ret_val;
+	int id;
+
+	if (option < 0 || option > 1)
+		return STORAGE_ERROR_INVALID_PARAMETER;
+
+	if (mmc_data && mmc_data->mmc_cb) {
+		_I("Format callback exists");
+		format_cb = format_mmc_cb;
+		data = mmc_data;
 	}
-	if (*type == STORAGE_TYPE_INTERNAL)
-		return STORAGE_ERROR_NONE;
 
-	ext_dev = calloc(1, sizeof(storage_ext_device));
-	if (!ext_dev) {
+	ret_val = storage_get_primary_sdcard(&id, &path);
+	if (ret_val != STORAGE_ERROR_NONE)
+		return ret_val;
 //LCOV_EXCL_START System Error
-		_E("calloc failed");
-		return STORAGE_ERROR_OUT_OF_MEMORY;
+	if (path)
+		free(path);
 //LCOV_EXCL_STOP
+
+	ret_val = gdbus_call_async_with_reply(STORAGE_EXT_BUS_NAME,
+			STORAGE_EXT_PATH_MANAGER,
+			STORAGE_EXT_IFACE_MANAGER,
+			"Format",
+			g_variant_new("(ii)", id, option),
+			format_cb,
+			FORMAT_TIMEOUT,
+			data);
+
+	_I("Format Request %s", ret_val == 0 ? "Success" : "Failed");
+
+	if (ret_val == -ENOMEM)
+		return STORAGE_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE System Error
+	if (ret_val < 0)
+		return STORAGE_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+
+	return STORAGE_ERROR_NONE;
+}
+
+API int storage_is_mounted_opt_usr(storage_part_mount_e *mounted)
+{
+	blkid_cache cache = NULL;
+	blkid_dev_iterate iter;
+	blkid_dev dev;
+	int ret_val;
+	bool found = false;
+	char *user_label = libsys_is_container()? CONTAINER_USER_PARTITION: USER_PARTITION;
+
+	if (!mounted)
+		return STORAGE_ERROR_INVALID_PARAMETER;
+
+	_D("Find user partition label: %s", user_label);
+	ret_val = blkid_get_cache(&cache, NULL);
+	if (ret_val < 0) {
+		_E("Failed to get cache"); //LCOV_EXCL_LINE
+		*mounted = STORAGE_PART_ERROR; //LCOV_EXCL_LINE
+		return STORAGE_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 	}
 
-	ret = storage_ext_get_device_info(storage_id, ext_dev);
-	if (ret < 0) {
-		_E("Cannot get the storage with id (%d, ret:%d)", storage_id, ret); //LCOV_EXCL_LINE
-		ret = STORAGE_ERROR_NOT_SUPPORTED;
-		goto out;
+	ret_val = blkid_probe_all(cache);
+	if (ret_val < 0) {
+		_E("Failed to probe all block devices"); //LCOV_EXCL_LINE
+		*mounted = STORAGE_PART_ERROR; //LCOV_EXCL_LINE
+		return STORAGE_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 	}
 
-	if (ext_dev->type == STORAGE_EXT_SCSI)
-		*dev = STORAGE_DEV_EXT_USB_MASS_STORAGE;
-	else if (ext_dev->type == STORAGE_EXT_MMC)
-		*dev = STORAGE_DEV_EXT_SDCARD;
-	ret = STORAGE_ERROR_NONE;
-	_I("type: %d(internal:0, external:1) dev: %d(sdcard: 1001, usb: 1002)", *type, *dev);
+	iter = blkid_dev_iterate_begin(cache);
+	if (!iter) {
+		_E("Failed to get iterate"); //LCOV_EXCL_LINE
+		*mounted = STORAGE_PART_ERROR; //LCOV_EXCL_LINE
+		return STORAGE_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
+	}
 
-out:
-	storage_ext_release_device(&ext_dev);
-	return ret;
+	ret_val = blkid_dev_set_search(iter, "LABEL", user_label);
+	if (blkid_dev_next(iter, &dev) == 0) {
+		dev = blkid_verify(cache, dev);
+		if (dev) {
+			found = true;
+			_D("Partition for user data is found(LABEL=%s)", user_label);
+		}
+	}
+	blkid_dev_iterate_end(iter);
+
+	if (!found) {
+		iter = blkid_dev_iterate_begin(cache);
+		if (!iter) {
+			_E("Failed to get iterate"); //LCOV_EXCL_LINE
+			*mounted = STORAGE_PART_ERROR; //LCOV_EXCL_LINE
+			return STORAGE_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
+		}
+
+		ret_val = blkid_dev_set_search(iter, "PARTLABEL", user_label);
+		if (blkid_dev_next(iter, &dev) == 0) {
+			dev = blkid_verify(cache, dev);
+			if (dev) {
+				found = true;
+				_D("Partition for user data is found(PARTLABEL=%s)", user_label);
+			}
+		}
+		blkid_dev_iterate_end(iter);
+	}
+
+	blkid_put_cache(cache);
+
+	if (found) {
+		ret_val = mount_check(tzplatform_getenv(TZ_SYS_USER));
+		if (ret_val)
+			*mounted = STORAGE_PART_MOUNTED;
+		else
+			*mounted = STORAGE_PART_NOT_MOUNTED;
+	} else
+		*mounted = STORAGE_PART_NOT_SUPPORTED;
+
+	return STORAGE_ERROR_NONE;
 }