path: root/pkgmgr_account/src/account.cpp

//
// Copyright (c) 2013 Samsung Electronics Co., Ltd.
//
// Licensed under the Apache License, Version 2.0 (the License);
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#include <errno.h>
#include <new>
#include <unique_ptr.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <account.h>
#include <account-types.h>
#include <FApp.h>
#include <FAppPkgPackageInfo.h>
#include <FAppPkgPackageManager.h>
#include <FAppPkg_PackageManagerImpl.h>
#include <FBaseColIEnumerator.h>
#include <FBaseColIList.h>
#include <FBaseDataType.h>
#include <FBaseString.h>
#include <FBaseSysLog.h>
#include <FBase_StringConverter.h>
#include <FBaseUtilStringTokenizer.h>
#include <FBaseUtilStringUtil.h>

#define _SysTryReturn(NID, condition, returnValue, ...)	\
	if (!(condition)) { \
		SysLog(NID, __VA_ARGS__); \
		return returnValue;	\
	} \
	else {;}

#define _SysTryCatch(NID, condition, expr, ...) \
	if (!(condition)) { \
		SysLog(NID, __VA_ARGS__); \
		expr; \
		goto CATCH;	\
	} \
	else {;}

using namespace Tizen::App;
using namespace Tizen::App::Package;
using namespace Tizen::Base;
using namespace Tizen::Base::Collection;
using namespace Tizen::Base::Utility;

static const xmlChar _NODE_ACCOUNT_PROVIDER[]				= "account-provider";
static const xmlChar _NODE_ICON[]							= "icon";
static const xmlChar _NODE_LABEL[]							= "label";
static const xmlChar _NODE_CAPABILITY[]						= "capability";

static const xmlChar _ATTRIBUTE_APP_ID[]					= "appid";
static const xmlChar _ATTRIBUTE_MULTIPLE_ACCOUNTS_SUPPORT[]	= "multiple-accounts-support";
static const xmlChar _ATTRIBUTE_SECTION[]					= "section";
static const xmlChar _ATTRIBUTE_TYPE[]						= "type";
static const xmlChar _ATTRIBUTE_XML_LANG[]					= "xml:lang";

static const xmlChar _VALUE_TRUE[]							= "true";
static const xmlChar _VALUE_ACCOUNT[]						= "account";
static const xmlChar _VALUE_ACCOUNT_SMALL[]					= "account-small";
static const xmlChar _VALUE_XHIGH[]							= "Xhigh";

static const char _DEFAULT_LOCALE[]							= "default";

static String __oldAccountProviderAppId;

bool
OnAccountReceived(account_h accountHandle, void* pUserData)
{
	SysTryReturn(NID_SCL, accountHandle != null && pUserData != null, false, E_SYSTEM, "[%s] A system error has occurred.", GetErrorMessage(E_SYSTEM));

	String* pAccountProviderAppId = static_cast<String*> (pUserData);
	SysTryReturn(NID_SCL, pAccountProviderAppId != null, false, E_SYSTEM, "[%s] A system error has occurred.", GetErrorMessage(E_SYSTEM));

	// Get the account ID
	int accountDbId = 0;
	int ret = account_get_account_id(accountHandle, &accountDbId);
	SysTryReturn(NID_SCL, ret == ACCOUNT_ERROR_NONE, null, E_SYSTEM, "[%s] The method cannot proceed due to a severe system error.", GetErrorMessage(E_SYSTEM));

	// Set the new app ID
	std::unique_ptr<char[]> pCharArrayAppId(_StringConverter::CopyToCharArrayN(*pAccountProviderAppId));
	SysTryReturn(NID_SCL, pCharArrayAppId != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));

	ret = account_set_package_name(accountHandle, pCharArrayAppId.get());
	SysTryReturn(NID_SCL, ret == ACCOUNT_ERROR_NONE, false, E_SYSTEM, "[%s] A system error has occurred.", GetErrorMessage(E_SYSTEM));

	// Update the account
	ret = account_update_to_db_by_id_ex(accountHandle, accountDbId);
	SysTryReturn(NID_SCL, ret != ACCOUNT_ERROR_NOT_REGISTERED_PROVIDER, false, E_INVALID_OPERATION, "[%s] The application does not register the account provider.", GetErrorMessage(E_INVALID_OPERATION));
	SysTryReturn(NID_SCL, ret != ACCOUNT_ERROR_PERMISSION_DENIED, false, E_INVALID_OPERATION, "[%s] The application has no permission to update this account.", GetErrorMessage(E_INVALID_OPERATION));
	SysTryReturn(NID_SCL, ret != ACCOUNT_ERROR_RECORD_NOT_FOUND, false, E_OBJ_NOT_FOUND, "[%s] The account does not exist.", GetErrorMessage(E_OBJ_NOT_FOUND));
	SysTryReturn(NID_SCL, ret == ACCOUNT_ERROR_NONE, false, E_SYSTEM, "[%s] A system error has occurred.", GetErrorMessage(E_SYSTEM));

	return true;
}

result
RegisterAccountProvider(xmlDocPtr docPtr, String& accountProviderAppId)
{
	SysLog(NID_SCL, "Registering the Account Provider.");

	int ret = account_connect();
	SysTryReturnResult(NID_SCL, ret == ACCOUNT_ERROR_NONE, E_SYSTEM, "A system error has occurred.");

	account_type_h accountTypeHandle = null;
	ret = account_type_create(&accountTypeHandle);
	if (ret != ACCOUNT_ERROR_NONE || accountTypeHandle == null)
	{
		SysLog(NID_SCL, "Memory allocation failed.");
		return E_OUT_OF_MEMORY;
	}

	result r = E_SUCCESS;

	// Node: <account>
	xmlNodePtr curPtr = xmlFirstElementChild(xmlDocGetRootElement(docPtr));
	SysTryCatch(NID_SCL, curPtr != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Failed to get the element.", GetErrorMessage(E_INVALID_ARG));

	SysSecureLog(NID_SCL, "Node: %s", curPtr->name);

	// Get the children nodes
	curPtr = curPtr->xmlChildrenNode;
	SysTryCatch(NID_SCL, curPtr != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Failed to get the child element.", GetErrorMessage(E_INVALID_ARG));

	while(curPtr != null)
	{
		SysSecureLog(NID_SCL, "Node: %s", curPtr->name);

		// Node: <account-provider>
		if ((!xmlStrcmp(curPtr->name, _NODE_ACCOUNT_PROVIDER)))
		{
			// Attribute: appid
			xmlChar* pAppIdId = xmlGetProp(curPtr, _ATTRIBUTE_APP_ID);
			SysTryCatch(NID_SCL, pAppIdId != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Failed to get the attribute.", GetErrorMessage(E_INVALID_ARG));

			SysSecureLog(NID_SCL, "Attribute: appid - %s", pAppIdId);
			ret = account_type_set_app_id(accountTypeHandle, reinterpret_cast<char*> (pAppIdId));
			SysTryCatch(NID_SCL, ret == ACCOUNT_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to set the app ID.", GetErrorMessage(E_SYSTEM));

			accountProviderAppId.Clear();
			accountProviderAppId.Append(String(reinterpret_cast<char*> (pAppIdId)));

			// Attribute: multiple-accounts-support
			xmlChar* pMultipleAccountsSupport = xmlGetProp(curPtr, _ATTRIBUTE_MULTIPLE_ACCOUNTS_SUPPORT);
			SysTryCatch(NID_SCL, pMultipleAccountsSupport != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Failed to get the attribute.", GetErrorMessage(E_INVALID_ARG));

			SysSecureLog(NID_SCL, "Attribute: multiple-accounts-support - %s", pMultipleAccountsSupport);
			if ((!xmlStrcmp(pMultipleAccountsSupport, _VALUE_TRUE)))
			{
				ret = account_type_set_multiple_account_support(accountTypeHandle, true);
				SysTryCatch(NID_SCL, ret == ACCOUNT_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to set the multiple accounts support.", GetErrorMessage(E_SYSTEM));
			}
			else
			{
				ret = account_type_set_multiple_account_support(accountTypeHandle, false);
				SysTryCatch(NID_SCL, ret == ACCOUNT_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to set the multiple accounts support.", GetErrorMessage(E_SYSTEM));
			}

			// Get the children nodes
			curPtr = curPtr->xmlChildrenNode;
			SysTryCatch(NID_SCL, curPtr != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Failed to get the child element.", GetErrorMessage(E_INVALID_ARG));

			while (curPtr != NULL)
			{
				SysSecureLog(NID_SCL, "Node: %s", curPtr->name);

				// Node: <icon>
				if ((!xmlStrcmp(curPtr->name, _NODE_ICON)))
				{
					// Attribute: section
					xmlChar* pSection = xmlGetProp(curPtr, _ATTRIBUTE_SECTION);
					SysTryCatch(NID_SCL, pSection != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Failed to get the attribute.", GetErrorMessage(E_INVALID_ARG));

					SysSecureLog(NID_SCL, "Attribute: section - %s", pSection);

					if ((!xmlStrcmp(pSection, _VALUE_ACCOUNT)))
					{
						xmlChar* pAccountIcon = xmlNodeListGetString(docPtr, curPtr->xmlChildrenNode, 1);
						SysTryCatch(NID_SCL, pAccountIcon != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Failed to get the value.", GetErrorMessage(E_INVALID_ARG));

						SysSecureLog(NID_SCL, "Node: icon - %s", pAccountIcon);
						ret = account_type_set_icon_path(accountTypeHandle, reinterpret_cast<char*> (pAccountIcon));
						SysTryCatch(NID_SCL, ret == ACCOUNT_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to set the icon path.", GetErrorMessage(E_SYSTEM));
					}
					else if ((!xmlStrcmp(pSection, _VALUE_ACCOUNT_SMALL)))
					{
						xmlChar* pAccountSmallIcon = xmlNodeListGetString(docPtr, curPtr->xmlChildrenNode, 1);
						SysTryCatch(NID_SCL, pAccountSmallIcon != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Failed to get the value.", GetErrorMessage(E_INVALID_ARG));

						SysSecureLog(NID_SCL, "Node: icon (small) - %s",  pAccountSmallIcon);
						ret = account_type_set_small_icon_path(accountTypeHandle, reinterpret_cast<char*> (pAccountSmallIcon));
						SysTryCatch(NID_SCL, ret == ACCOUNT_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to set the small icon path.", GetErrorMessage(E_SYSTEM));
					}
				}
				// Node: <label>
				else if ((!xmlStrcmp(curPtr->name, _NODE_LABEL)))
				{
					SysSecureLog(NID_SCL, "Node: %s", curPtr->name);

		    		// Attribute: xml:lang
					xmlChar* pLang = xmlNodeGetLang(curPtr);
					if (pLang != null)
					{
						SysSecureLog(NID_SCL, "Attribute: xml:lang - %s", pLang);

						String lang(reinterpret_cast<char*> (pLang));

						StringTokenizer strTok(lang, L"-");
						String token;
						String convertedLang;

						strTok.GetNextToken(convertedLang);
						convertedLang.Append(L"_");

						strTok.GetNextToken(token);
						token.ToUpper();
						convertedLang.Append(token);

						std::unique_ptr<ByteBuffer> pConvertedLangBuf(StringUtil::StringToUtf8N(convertedLang));
						SysTryCatch(NID_SCL, pConvertedLangBuf != null, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to convert String to Utf8N.", GetErrorMessage(E_SYSTEM));

						SysSecureLog(NID_SCL, "Attribute: converted lang - %s", pConvertedLangBuf->GetPointer());

						xmlChar* pLabel = xmlNodeListGetString(docPtr, curPtr->xmlChildrenNode, 1);
						SysTryCatch(NID_SCL, pLabel != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Failed to get the value.", GetErrorMessage(E_INVALID_ARG));

						SysSecureLog(NID_SCL, "Node: label - %s", pLabel);
						ret = account_type_set_label(accountTypeHandle, reinterpret_cast<char*> (pLabel), reinterpret_cast<char*> (pConvertedLangBuf->GetPointer()));
						SysTryCatch(NID_SCL, ret == ACCOUNT_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to set the display name.", GetErrorMessage(E_SYSTEM));
					}
					else
					{
						xmlChar* pLabel = xmlNodeListGetString(docPtr, curPtr->xmlChildrenNode, 1);
						SysTryCatch(NID_SCL, pLabel != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Failed to get the value.", GetErrorMessage(E_INVALID_ARG));

						SysSecureLog(NID_SCL, "Node: label - %s",  pLabel);
						ret = account_type_set_label(accountTypeHandle, reinterpret_cast<char*> (pLabel), _DEFAULT_LOCALE);
						SysTryCatch(NID_SCL, ret == ACCOUNT_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to set the display name.", GetErrorMessage(E_SYSTEM));
					}
				}
				// Node: <capability>
				else if ((!xmlStrcmp(curPtr->name, _NODE_CAPABILITY)))
				{
					SysSecureLog(NID_SCL, "Node: %s", curPtr->name);

					xmlChar* pCapability = xmlNodeListGetString(docPtr, curPtr->xmlChildrenNode, 1);
					SysTryCatch(NID_SCL, pCapability != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Failed to get the value.", GetErrorMessage(E_INVALID_ARG));

					SysSecureLog(NID_SCL, "Node: capability - %s",  pCapability);
					ret = account_type_set_provider_feature(accountTypeHandle, reinterpret_cast<char*> (pCapability));
					SysTryCatch(NID_SCL, ret == ACCOUNT_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to set the capability.", GetErrorMessage(E_SYSTEM));
				}

				curPtr = curPtr->next;
			}

			break;
		}

		curPtr = curPtr->next;
	}

	// Insert the account type to the account DB
	{
		int accountTypeDbId = 0;
		ret = account_type_insert_to_db(accountTypeHandle, &accountTypeDbId);
		SysTryCatch(NID_SCL, ret == ACCOUNT_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] A system error has occurred.", GetErrorMessage(E_SYSTEM));
	}

	account_type_destroy(accountTypeHandle);
	SysTryReturnResult(NID_SCL, account_disconnect() == ACCOUNT_ERROR_NONE, E_SYSTEM, "A system error has occurred.");

	return E_SUCCESS;

CATCH:
	account_type_destroy(accountTypeHandle);
	SysTryReturnResult(NID_SCL, account_disconnect() == ACCOUNT_ERROR_NONE, E_SYSTEM, "A system error has occurred.");

	return r;
}

extern "C"
__attribute__ ((visibility("default")))
int PKGMGR_PARSER_PLUGIN_INSTALL(xmlDocPtr docPtr, const char* packageId)
{
	SysLog(NID_SCL, "PKGMGR_PARSER_PLUGIN_INSTALL");

	String accountProviderAppId;
	result r = RegisterAccountProvider(docPtr, accountProviderAppId);
	_SysTryReturn(NID_SCL, r == E_SUCCESS, -1, "Failed to register the account provider.");

	return 0;
}

extern "C"
__attribute__ ((visibility("default")))
int PKGMGR_PARSER_PLUGIN_UNINSTALL(xmlDocPtr docPtr, const char* packageId)
{
	SysLog(NID_SCL, "PKGMGR_PARSER_PLUGIN_UNINSTALL");

	int ret = account_connect();
	_SysTryReturn(NID_SCL, ret == ACCOUNT_ERROR_NONE, -1, "A system error has occurred.");

	// Node: <account>
	xmlNodePtr curPtr = xmlFirstElementChild(xmlDocGetRootElement(docPtr));
	_SysTryCatch(NID_SCL, curPtr != null, ret = -EINVAL, "Failed to get the element.");

	SysSecureLog(NID_SCL, "Node: %s", curPtr->name);

	// Get the children nodes
	curPtr = curPtr->xmlChildrenNode;
	_SysTryCatch(NID_SCL, curPtr != null, ret = -EINVAL, "Failed to get the child element.");

	while(curPtr != null)
	{
		SysSecureLog(NID_SCL, "Node: %s", curPtr->name);

		// Node: <account-provider>
		if ((!xmlStrcmp(curPtr->name, _NODE_ACCOUNT_PROVIDER)))
		{
			// Attribute: appid
			xmlChar* pAppIdId = xmlGetProp(curPtr, _ATTRIBUTE_APP_ID);
			_SysTryCatch(NID_SCL, pAppIdId != null, ret = -EINVAL, "Failed to get the attribute.");

			SysSecureLog(NID_SCL, "Attribute: appid - %s", pAppIdId);

			ret = account_delete_from_db_by_package_name(reinterpret_cast<char*> (pAppIdId));
			_SysTryCatch(NID_SCL, ret == ACCOUNT_ERROR_NONE, ret = -1, "A system error has occurred.");

			ret = account_type_delete_by_app_id(reinterpret_cast<char*> (pAppIdId));
			_SysTryCatch(NID_SCL, ret == ACCOUNT_ERROR_NONE, ret = -1, "A system error has occurred.");

			break;
		}

		curPtr = curPtr->next;
	}

	SysTryReturn(NID_SCL, account_disconnect() == ACCOUNT_ERROR_NONE, -1, E_SYSTEM, "[%s] A system error has occurred.", GetErrorMessage(E_SYSTEM));

	return 0;

CATCH:
	SysTryReturn(NID_SCL, account_disconnect() == ACCOUNT_ERROR_NONE, -1, E_SYSTEM, "[%s] A system error has occurred.", GetErrorMessage(E_SYSTEM));

	return ret;
}

extern "C"
__attribute__ ((visibility("default")))
int PKGMGR_PARSER_PLUGIN_PRE_UPGRADE(const char* packageId)
{
	SysLog(NID_SCL, "PKGMGR_PARSER_PLUGIN_PRE_UPGRADE");

	result r = E_SUCCESS;

	__oldAccountProviderAppId.Clear();

	_PackageManagerImpl* pPackageManagerImpl = _PackageManagerImpl::GetInstance();
	_SysTryReturn(NID_SCL, pPackageManagerImpl != null, -1, "Failed to get the PackageManagerImpl instance.");

	String pkgId(packageId);
	std::unique_ptr<PackageInfo> pPackageInfo(pPackageManagerImpl->GetPackageInfoN(pkgId));
	r = GetLastResult();
	_SysTryReturn(NID_SCL, r != E_PKG_NOT_INSTALLED, -1, "The package is not installed.");
	_SysTryReturn(NID_SCL, pPackageInfo != null && r == E_SUCCESS, -1, "Failed to get the package information.");

	std::unique_ptr<IList, AllElementsDeleter> pPackageAppInfoList(pPackageInfo->GetPackageAppInfoListN());
	_SysTryReturn(NID_SCL, pPackageAppInfoList != null, -1, "Failed to get the application information list.");

	std::unique_ptr<IEnumerator> pEnum(pPackageAppInfoList->GetEnumeratorN());
	_SysTryReturn(NID_SCL, pEnum != null, -1, "A system error has occurred.");

	int ret = account_connect();
	_SysTryReturn(NID_SCL, ret == ACCOUNT_ERROR_NONE, -1, "A system error has occurred.");

	while (pEnum->MoveNext() == E_SUCCESS)
	{
		PackageAppInfo* pPackageAppInfo = dynamic_cast<PackageAppInfo*> (pEnum->GetCurrent());
		_SysTryCatch(NID_SCL, pPackageAppInfo != null, ret = -1, "A system error has occurred.");

		std::unique_ptr<char[]> pCharArrayAppId(_StringConverter::CopyToCharArrayN(pPackageAppInfo->GetAppId()));
		_SysTryCatch(NID_SCL, pCharArrayAppId != null, ret = -1, "Memory allocation failed.");

		ret = account_type_delete_by_app_id(pCharArrayAppId.get());
		if (ret == ACCOUNT_ERROR_NONE)
		{
			SysLog(NID_SCL, "PKGMGR_PARSER_PLUGIN_PRE_UPGRADE: app ID - %ls", (pPackageAppInfo->GetAppId()).GetPointer());

			__oldAccountProviderAppId = pPackageAppInfo->GetAppId();
			break;
		}
	}

	SysTryReturn(NID_SCL, account_disconnect() == ACCOUNT_ERROR_NONE, -1, E_SYSTEM, "[%s] A system error has occurred.", GetErrorMessage(E_SYSTEM));

	return 0;

CATCH:
	SysTryReturn(NID_SCL, account_disconnect() == ACCOUNT_ERROR_NONE, -1, E_SYSTEM, "[%s] A system error has occurred.", GetErrorMessage(E_SYSTEM));

	return ret;
}

extern "C"
__attribute__ ((visibility("default")))
int PKGMGR_PARSER_PLUGIN_UPGRADE(xmlDocPtr docPtr, const char* packageId)
{
	SysLog(NID_SCL, "PKGMGR_PARSER_PLUGIN_UPGRADE");

	String accountProviderAppId;
	result r = RegisterAccountProvider(docPtr, accountProviderAppId);
	_SysTryReturn(NID_SCL, r == E_SUCCESS, -1, "Failed to register the account provider.");

	int ret = account_connect();
	_SysTryReturn(NID_SCL, ret == ACCOUNT_ERROR_NONE, -1, "A system error has occurred.");

	std::unique_ptr<char[]> pCharArrayAppId(_StringConverter::CopyToCharArrayN(__oldAccountProviderAppId));
	_SysTryCatch(NID_SCL, pCharArrayAppId != null, ret = -1, "Memory allocation failed.");

	ret = account_query_account_by_package_name(OnAccountReceived, pCharArrayAppId.get(), (void*) &accountProviderAppId);
	_SysTryCatch(NID_SCL, (ret == ACCOUNT_ERROR_NONE) || (ret == ACCOUNT_ERROR_RECORD_NOT_FOUND), ret = -1, "A system error has occurred.");

	r = GetLastResult();
	_SysTryCatch(NID_SCL, r == E_SUCCESS, ret = -1, "Failed to update accounts.");

	ret = account_disconnect();
	_SysTryReturn(NID_SCL, ret == ACCOUNT_ERROR_NONE, -1, "A system error has occurred.");

	return 0;

CATCH:
	_SysTryReturn(NID_SCL, account_disconnect() == ACCOUNT_ERROR_NONE, -1, "A system error has occurred.");

	return ret;
}