path: root/src/agent/dm-engine/dm_common_engine.c

/*
 * oma-dm-agent
 * Copyright (c) 2012 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.
 */

/*lib*/
#include <stdio.h>

/*sync-agent*/
#include <sync_agent.h>

/*dm-agent*/
#include "common/dm_common_def.h"
#include "common/dm_common.h"
#include "common/util/util.h"
#include "framework/task/oma_dm_task_request.h"
#include "framework/san-parser/pm_sanparser.h"
#include "dm-engine/dm_common_engine.h"
#include "dm-engine/fumo/fumo_engine.h"
#include "dm-engine/lawmo/lawmo_engine.h"
#include "mo-handler/dm_mo_common_internal.h"
#include "mo-handler/dm_mo_common.h"
#include "serviceadapter/dm-phase-handler/dm_phase_handler.h"
#include "serviceadapter/sa_define.h"
#include "serviceadapter/sa_session.h"
#include "serviceadapter/sa_session_internal.h"
#include "ipc_common.h"
#include "ipc_agent.h"

#ifndef OMADM_AGENT_LOG
#undef LOG_TAG
#define LOG_TAG	"COMMON_ENGINE"
#endif

static DM_ERROR _change_engine_status(char *server_id, char *full_path, char *correlator, int service_engine_status);

static DM_ERROR _change_engine_status(char *server_id, char *full_path, char *correlator, int service_engine_status)
{
	_INNER_FUNC_ENTER;
	DM_ERROR ret = DM_OK;

	retvm_if((server_id) == NULL, COMMON_ERR_IS_NULL, "full_path is NULL!!");
	retvm_if((full_path) == NULL, COMMON_ERR_IS_NULL, "full_path is NULL!!");

	int task_id;
	task_id = sync_agent_get_self_request_id();
	_DEBUG_TRACE("service engine db update");

	engine_status *status;

	int is_exist;
	is_exist = IsExist_Engine_id(service_engine_status);

	if (is_exist == 1) {
		ret = Get_Engine_Status(service_engine_status, &status);
		_DEBUG_TRACE("get engine status : %d", ret);
	} else {
		status = (engine_status *) calloc(1, sizeof(engine_status));
		_DEBUG_TRACE("get engine status error");
	}

	if (status == NULL) {
		_DEBUG_TRACE("calloc failed !!");
		ret = COMMON_ERR_ALLOC;
		goto error;
	}

	if (correlator != NULL) {
		status->correlator = strdup(correlator);
	} else {
		status->correlator = NULL;
	}

	status->engine_status = DM_SERVICE_ING;
	status->engine_id = service_engine_status;
	status->mo_path = strdup(full_path);
	status->server_url = NULL;
	status->result_status = DM_OK;
	status->server_id = strdup(server_id);
	status->task_id = task_id;
	status->ui_noti_type = 0;
	status->download_click = 0;
	//status->ui_mode = ;

	/* one engine */
	/*      if(IsExist_Engine_id(SERVICE_ENGINE)) {
	   ret = Delete_Engine_Status(SERVICE_ENGINE);
	   } */
	ret = Update_Engine_Status(status);
	_DEBUG_TRACE(" update engine status : %d \n", ret);

	if (status != NULL)
		Free_Memory_Engine_Status(&status, 1);

	if (ret != DM_OK) {
//              DB_End_Transaction(TRANSACTION_ROLLBACK_);
		goto error;
	}
	//sleep(10);
/*	ret = Update_Engine_Status_Column(IDLE_ENGINE, VALUE_ENGINE_STATUS, &service_engine_status);
	_DEBUG_TRACE(" update engine status : %d \n", ret);
	if (ret != DM_OK) {
		DB_End_Transaction(TRANSACTION_ROLLBACK_);
		goto error;
	}*/

	_INNER_FUNC_EXIT;
	return ret;
 error:

	_DEBUG_TRACE(" end error : %d \n", ret);
	_INNER_FUNC_EXIT;
	return ret;
}

void init_Dm_Engine()
{
	_EXTERN_FUNC_ENTER;

	/* always rebooting operation but excepted bootstrap */
	reset_devinfo();
	reset_devdetail();

	_EXTERN_FUNC_EXIT;
}

DM_ERROR engine_start(char *server_id, char *full_path, char *correlator, ENGINE_ID * service_engine_id, int *resultCode)
{
	_EXTERN_FUNC_ENTER;

	DM_ERROR ret = DM_OK;

	if (server_id == NULL || full_path == NULL) {
		(*resultCode) = CLIENT_ERROR;
		ret = COMMON_ERR_IS_NULL;
		goto error;
	}

	sync_agent_dm_mo_error_e err_code = SYNC_AGENT_DM_MO_SUCCESS;
	sync_agent_dm_mo_type_e mo_type;

	err_code = sync_agent_get_mo_type(full_path, &mo_type);
	_DEBUG_INFO("get mo type result : %d", err_code);

	(*resultCode) = DM_ERR_ACCEPTED_FOR_PROCESSING;

	_DEBUG_INFO(" ------------------------------------------------------------------------------------------------------------------------------------- ");
	_DEBUG_INFO(" mo_type : %d , server id : %s , full_path : %s , correlator : %s  ", mo_type, server_id, full_path, correlator);
	_DEBUG_INFO(" ------------------------------------------------------------------------------------------------------------------------------------- ");

	switch (mo_type) {
	case SYNC_AGENT_DM_MO_TYPE_FUMO:

		_DEBUG_INFO("---------------------------------------------------------------- fumo engine ready --------------------------------------------------------------------- ");
		ret = _change_engine_status(server_id, full_path, correlator, FUMO_SERVICE_ENGINE);
		if (ret != DM_OK)
			goto error;

		if (correlator == NULL) {
			/*because of gcf server */
			/*ret = fumo_exec(full_path, correlator, (FUMO_Error *)resultCode);
			   if(ret !=DM_OK)
			   goto error; */
		}

		*service_engine_id = FUMO_SERVICE_ENGINE;

		break;
	case SYNC_AGENT_DM_MO_TYPE_LAWMO:
		_DEBUG_INFO("---------------------------------------------------------------- lawmo engine ready --------------------------------------------------------------------- ");
		ret = _change_engine_status(server_id, full_path, correlator, LAWMO_SERVICE_ENGINE);
		if (ret != DM_OK)
			goto error;

		//if( !correlator) {
		// 1 : this is just check , available operation
		ret = lawmo_exec(full_path, correlator, (LAWMO_Result_code *) resultCode, CHECK_OPERATION);
		if (ret != DM_OK)
			goto error;
		//}

		*service_engine_id = LAWMO_SERVICE_ENGINE;

		break;
	default:
		(*resultCode) = CLIENT_ERROR;
		_DEBUG_INFO(" not existed engine \n");
		break;
	}

	_DEBUG_INFO("====================result code : %d====================\n", *resultCode);
	_DEBUG_INFO(" end!!  resut code : %d\n", *resultCode);
	_EXTERN_FUNC_EXIT;
	return ret;
 error:

	_DEBUG_INFO("====================result code : %d====================\n", *resultCode);
	_DEBUG_INFO(" error end %d  result code : %d", ret, *resultCode);
	_EXTERN_FUNC_EXIT;
	return ret;
}

DM_ERROR service_engine_start(ENGINE_ID service_engine_id, DM_ERROR * service_ret)
{
	_EXTERN_FUNC_ENTER;

	_DEBUG_INFO(" start : service_engine_id : %d", service_engine_id);
	DM_ERROR ret = DM_OK;
	engine_status *service_status = NULL;
	engine_status *after_service_status = NULL;
	char *full_path = NULL;
	char *correlator = NULL;
	char *server_id = NULL;
	int service_engine_status;
	bool cancel_flag = 0;

	cancel_flag = sync_agent_check_cancel_flag();
	if (cancel_flag != 0) {
		ret = DM_ERR_OPERATION_CANCELLED;
		goto error;
	}

	if (IsExist_Engine_id(service_engine_id) == 1) {

		_DEBUG_INFO("service engine id = %d\n", service_engine_id);
		_DEBUG_INFO(" engine must re-start");

		ret = Get_Engine_Status(service_engine_id, &service_status);
		_DEBUG_INFO(" get engine status : %d \n", ret);
		if (ret != DM_OK)
			goto error;

		if (service_status == NULL) {
			_DEBUG_INFO("service status is null");
			ret = COMMON_ERR_IS_NULL;
			goto error;
		}

		if (service_status->engine_status == DM_SERVICE_UNKNOWN) {
			_DEBUG_INFO("engine status unknown");
			goto error;
		}

		if (service_status->engine_status == DM_SERVICE_ING) {
			_DEBUG_INFO("-------------------------------------------- service type ------------------------------------------------ : %d", service_engine_id);

			int engine_return = OPERATION_SUCCEEDED;

			if (service_status->mo_path != NULL) {
				full_path = strdup(service_status->mo_path);
				_DEBUG_INFO("full path : %s ", full_path);
			} else {
				ret = COMMON_ERR_INTERNAL_NOT_DEFINED;
				goto error;
			}

			if (service_status->server_id != NULL) {
				server_id = strdup(service_status->server_id);
				_DEBUG_INFO("server_id : %s", server_id);
			} else {
				ret = COMMON_ERR_INTERNAL_NOT_DEFINED;
				goto error;
			}

			if (service_status->correlator != NULL) {
				correlator = strdup(service_status->correlator);
				_DEBUG_INFO("correlator : %s", correlator);
			}

			_DEBUG_INFO("service status : %d", service_status->engine_status);

			switch (service_engine_id) {
			case FUMO_SERVICE_ENGINE:
				_DEBUG_INFO(" fumo exec");
				ret = fumo_exec(full_path, correlator, (FUMO_Error *) (&engine_return));
				_DEBUG_INFO("fumo ret : %d", ret);
				*service_ret = ret;
				if (ret != DM_OK && ret != DM_ERR_USER_CANDELLED && ret != DM_ERR_REMINDER_INTERVAL /*|| ret != DM_ERR_DEVICE_ABORTED */ )
					goto error;
				break;
			case LAWMO_SERVICE_ENGINE:
				_DEBUG_INFO(" lawmo exec");
				ret = lawmo_exec(full_path, correlator, (LAWMO_Result_code *) (&engine_return), NON_CHECK_OPERATION);
				_DEBUG_INFO("lawmo ret : %d", ret);
				*service_ret = ret;
				if (ret != DM_OK)
					goto error;
				break;
			default:
				break;
			}
			_DEBUG_INFO("exe resutlt : %d , server id : %s", engine_return, server_id);
			_DEBUG_INFO("correlator : %s", correlator);

			ret = Get_Engine_Status(service_engine_id, &after_service_status);
			_DEBUG_INFO(" get engine status : %d \n", ret);
			if (ret != DM_OK)
				goto error;

			if (after_service_status == NULL) {
				_DEBUG_INFO("service status is null");
				ret = COMMON_ERR_IS_NULL;
				goto error;
			}

			if (after_service_status->download_click != RESUME_STATUS_INSTALL_BEFORE) {
				/*engine status generic alert status */
				service_engine_status = DM_GENERICALERT_ING;
				ret = Update_Engine_Status_Column(service_engine_id, VALUE_ENGINE_STATUS, &service_engine_status);
				_DEBUG_INFO("service engine status generic alert");

				ret = Update_Engine_Status_Column(service_engine_id, VALUE_RESULT_STATUS, &engine_return);
				_DEBUG_INFO("service engine status generic alert status : %d", engine_return);
			}

			str_free(&full_path);
			str_free(&correlator);
			str_free(&server_id);

			if (service_status != NULL) {
				Free_Memory_Engine_Status(&service_status, 1);
			}
			if (after_service_status != NULL) {
				Free_Memory_Engine_Status(&after_service_status, 1);
			}

		} else {
			if (service_status != NULL) {
				Free_Memory_Engine_Status(&service_status, 1);
			}
			_DEBUG_INFO(" non service engine ing");
		}

	} else {
		_DEBUG_INFO(" non service engine ");
	}

	_EXTERN_FUNC_EXIT;
	return ret;

 error:
	if (service_status != NULL) {
		Free_Memory_Engine_Status(&service_status, 1);
	}

	if (after_service_status != NULL) {
		Free_Memory_Engine_Status(&after_service_status, 1);
	}

	str_free(&full_path);
	str_free(&correlator);
	str_free(&server_id);
	_DEBUG_INFO(" error end %d ", ret);
	_EXTERN_FUNC_EXIT;
	return ret;
}

DM_ERROR set_engine_status_idle(ENGINE_ID service_engine_id)
{
	_EXTERN_FUNC_ENTER;

	DM_ERROR ret = DM_OK;

	if (IsExist_Engine_id(service_engine_id) == 1) {
		_DEBUG_INFO("service engine id = %d\n", service_engine_id);
	}

	ret = set_end_engine_status_idle();
	if (ret != DM_OK)
		goto error;

	_EXTERN_FUNC_EXIT;
	return ret;
 error:
	_DEBUG_INFO(" error end %d ", ret);
	_EXTERN_FUNC_EXIT;
	return ret;
}

DM_ERROR set_end_engine_status_idle()
{
	_EXTERN_FUNC_ENTER;

	DM_ERROR ret = DM_OK;

	int common_engine_status = DM_IDLE;
	_DEBUG_INFO(" engine idle");
	ret = Update_Engine_Status_Column(IDLE_ENGINE, VALUE_ENGINE_STATUS, &common_engine_status);
	if (ret != DM_OK)
		goto error;

	_EXTERN_FUNC_EXIT;
	return ret;

 error:
	_DEBUG_INFO(" error end %d ", ret);
	_EXTERN_FUNC_EXIT;
	return ret;
}

DM_ERROR dm_common_start(Event_Contents * pEvent_data)
{
	_EXTERN_FUNC_ENTER;

	DM_ERROR ret = DM_OK;

	retvm_if((pEvent_data) == NULL, COMMON_ERR_IS_NULL, "pEvent_data is NULL!!");

	ret = dm_common_operation(pEvent_data);
	if (ret != DM_OK) {
		goto error;
	}

	_EXTERN_FUNC_EXIT;
	return ret;
 error:

	_DEBUG_INFO(" end!! error : %d\n", ret);
	_EXTERN_FUNC_EXIT;
	return ret;

}

DM_ERROR dm_common_operation(Event_Contents * pEvent_data)
{
	_EXTERN_FUNC_ENTER;

	DM_ERROR ret = DM_OK;

	retvm_if((pEvent_data) == NULL, COMMON_ERR_IS_NULL, "pEvent_data is NULL!!");

	int return_ret = 0;
	return_ret = remove(OMA_DM_MSG_PATH);
	_DEBUG_INFO(" result file remove /tmp/dm.txt =[%d]\n", return_ret);

	DM_ERROR service_ret = DM_OK;
	ENGINE_ID service_engine_id = NO_SERVICE_ENGINE;
	char *session_id = NULL;
	char *server_id = NULL;
	int session_type;

	ret = get_server_info(pEvent_data, &server_id, &session_id, &session_type);
	if (ret != DM_OK) {
		goto error;
	}

	get_service_engine_id(&service_engine_id, pEvent_data->ui_mode);

	/*pkg 1 ~ pkg2 */
	int isFinish = 0;
	int isgeneticAlert = 0;
	void *session = NULL;
	_DEBUG_INFO("----------------------------------------------------------------------------------------------------------\n");
	_DEBUG_INFO(" setupphase Msg \n");
	_DEBUG_INFO("----------------------------------------------------------------------------------------------------------\n");
	ret = setup_phase(1, (Session **) & session, server_id, session_id, session_type, &service_engine_id, &isFinish, isgeneticAlert);
	if (ret != DM_OK) {
		_DEBUG_INFO("connect to server fail in dm common operation (authentication fail or network fail)");
		_DEBUG_INFO(" result =[%d]\n", ret);
		service_ret = ret;
		goto error;
	}

	while (!isFinish) {

		/* pkg 3 ~ pkg 4 */
		/*isFinish = 0; */
		_DEBUG_INFO("----------------------------------------------------------------------------------------------------------\n");
		_DEBUG_INFO(" management Msg \n");
		_DEBUG_INFO("----------------------------------------------------------------------------------------------------------\n");
		ret = management_phase(1, (Session **) (&session), NULL, &service_engine_id, &isFinish);
		if (ret != DM_OK) {
			service_ret = ret;
			goto error;
		}

		_DEBUG_INFO("isFinish : %d\n", isFinish);
		_DEBUG_INFO("----------------------------------------------------------------------------------------------------------\n");

		ret = service_engine_start(service_engine_id, &service_ret);
		if (ret != DM_OK)
			goto error;

		ret = genericalert_operation(&session, &isFinish, service_engine_id);
		if (ret != DM_OK)
			goto error;

		set_engine_status_idle(service_engine_id);
	}

	terminate_oma_dm_ui(service_ret, service_engine_id);

	_EXTERN_FUNC_EXIT;
	return ret;

 error:

	terminate_oma_dm_ui(service_ret, service_engine_id);

	if (ret == DM_ERR_OPERATION_CANCELLED && service_ret == DM_ERR_OPERATION_CANCELLED) {
		Delete_Engine_Status(service_engine_id);
		_DEBUG_INFO("Delete fumo service engine");
	}

	set_engine_status_idle(service_engine_id);

	if (service_engine_id != NO_SERVICE_ENGINE) {

		if (service_engine_id != FUMO_SERVICE_ENGINE && check_existed_fumo_reminder_interval() == 0) {
			Delete_Engine_Status(service_engine_id);
			_DEBUG_INFO("Delete fumo service engine");
		}
	}

	_DEBUG_INFO(" end error ret : %d\n", ret);
	_EXTERN_FUNC_EXIT;
	return ret;
}

DM_ERROR genericalert_operation(void **session, int *isFinish, ENGINE_ID service_engine_id)
{

	_EXTERN_FUNC_ENTER;

	DM_ERROR ret = DM_OK;
	char *pServer_id = NULL;
	engine_status *status = NULL;

	if (IsExist_Engine_id(service_engine_id) == 1) {
		ret = Get_Engine_Status(service_engine_id, &status);
		if (ret != DM_OK)
			goto error;
		_DEBUG_INFO(" result =[%d]\n", ret);

		_DEBUG_INFO("server id : %s", status->server_id);
		_DEBUG_INFO("engine_id : %d", status->engine_id);
		_DEBUG_INFO("correlator : %s", status->correlator);
		_DEBUG_INFO("engine_status : %d", status->engine_status);
		_DEBUG_INFO("result status : %d", status->result_status);
		_DEBUG_INFO("mo path : %s", status->mo_path);
		_DEBUG_INFO("server url : %s", status->server_url);

		if (status->engine_status == DM_GENERICALERT_ING) {
			_DEBUG_INFO(" ----------------------------------------------------------------------generic alert-------------------------------------------------------------------------------");
			_DEBUG_INFO("service engine id = %d\n", service_engine_id);

			isFinish = 0;
			int isgeneticAlert = 1;

			if (status->server_id != NULL) {
				pServer_id = strdup(status->server_id);
				_DEBUG_INFO(" server id is %s", status->server_id);
			} else {
				_DEBUG_INFO(" server id is NULL");
				ret = COMMON_ERR_IS_NULL;
				goto error;
			}
			//void * session = NULL;

			ret = generic_alert(1, (Session **) session, pServer_id, NULL, isFinish, isgeneticAlert, service_engine_id, status->result_status);
			if (ret != DM_OK)
				goto error;
			_DEBUG_INFO(" result =[%d]\n", ret);

			/*update engine_status */
			status->engine_status = DM_SERVICE_UNKNOWN;
			ret = Update_Engine_Status(status);
			_DEBUG_INFO(" update engine status : %d \n", ret);

			str_free(&pServer_id);
		}
	} else {
		_DEBUG_INFO("non generic alert");
	}

	if (status != NULL) {
		Free_Memory_Engine_Status(&status, 1);
	}

	_EXTERN_FUNC_EXIT;
	return ret;

 error:

	str_free(&pServer_id);
	if (status != NULL)
		Free_Memory_Engine_Status(&status, 1);

	_DEBUG_INFO(" error end  ret : %d\n", ret);
	_EXTERN_FUNC_EXIT;
	return ret;

}