myvtm/Framework/spbase/sp_mod.c

#include "precompile.h"

#include "sp_mod.h"
#include "sp_svc.h"

#include "sp_env.h"
#include "sp_def.h"

#include "SpBase.h"

#include "shm_mem.h"
#include "process_monitor.h"
#include "refcnt.h"
#include "spinlock.h"
#include "strutil.h"
#include "sp_logwithlinkforc.h"
#include "dbgutil.h"
#ifdef _WIN32
#include <WtsApi32.h>
#include <Userenv.h>
#include "sp_groupProcess.h"
#endif //_WIN32

#include "sp_gui.h"
#include "sp_env.h"

#include <winpr/exception.h>
#include <winpr/thread.h>
#include <winpr/wtsapi.h>
#include <winpr/synch.h>
#include <winpr/string.h>
#include <winpr/crt.h>
#include <winpr/sysinfo.h>
#include <winpr/wlog.h>
#define TAG SPBASE_TAG("sp_mod")

#include "toolkit.h"
#include "StartUpBase.h"

#define BUFSIZE 10240
#define MOD_CMD_INIT		0
#define MOD_CMD_TERM		1
#define MOD_CMD_START		2
#define MOD_CMD_STOP		3
#define MOD_CMD_PAUSE		4
#define MOD_CMD_CONTINUE	5
#define MOD_CMD_TEST		6
#define MOD_CMD_MOD_RESULT	7
#define MOD_CMD_ENT_RESULT	8

#define MOD_CMD_REPORT_CREATE_CONN			9
#define MOD_CMD_REPROT_CLOSE_CONN			10
#define MOD_CMD_REPORT_EXCEPTION			12
#define MOD_CMD_SUBSCRIBE_STATE_LISTENER	13
#define MOD_CMD_UNSUBSCRIBE_STATE_LISTENER	14
#define MOD_CMD_SUBSCRIBE_LIFE_LISTENER		15
#define MOD_CMD_UNSUBSCRIBE_LIFE_LISTENER	16
#define MOD_CMD_RECORD_STATE_EVENT	17
#define MOD_CMD_RECORD_CREATE_CONN	18
#define MOD_CMD_RECORD_CLOSE_CONN	19
#define MOD_CMD_RECORD_ENTITY_CLOSE	20
#define MOD_CMD_RECORD_ENTITY_CREATE	21
#define MOD_CMD_RECORD_ENTITY_EXCEPTION	22
#define MOD_CMD_SWITCH_RUNNING_MODE		23
#define MOD_CMD_USER_STATE_EVENT  24

#define MOD_CMD_ENT_RESULT_EX	                             25

#define MOD_CMD_NOTIFY_REDIRECT_SUBSCRIBE	     31 // shell -> entity
#define MOD_CMD_REPORT_REDIRECT_SUBSCRIBE	     32 // entity -> shell

//#define PROCESS_TIMEOUT		10000
#define PROCESS_TIMEOUT		120000
#define PROCESS_EXIT_TIMEOUT	4000
#define ENTITY_TEST_TIMEOUT 30000

#if defined(_MSC_VER)
#define PROCESS_TIMEOUT_FOR_TERMINAL	PROCESS_TIMEOUT
#else
#define PROCESS_TIMEOUT_FOR_TERMINAL	20000
#endif //_MSC_VER

#ifdef _WIN32
extern  void sp_mod_mgr_lockEx(int EntityId);
extern  void sp_mod_mgr_unlockEx(int EntityId);
extern  void sp_mod_mgr_lockArrClean();
#endif //_WIN32

struct sp_mod_stub_t
{
	sp_mod_stub_cb cb;
	sp_iom_t *iom;
};

struct sp_mod_entity_stub_t
{
	sp_mod_entity_stub_cb cb;
	strand_t *strand;
	sp_svc_t *svc;
};

#define SP_MOD_CMDTYPE_DEFINE(x)	\
	case x : return #x; break;

static const char* str_cmdtype(int cmdtype)
{
	switch (cmdtype) {
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_INIT)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_TERM)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_START)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_STOP)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_PAUSE)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_CONTINUE)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_TEST)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_MOD_RESULT)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_ENT_RESULT)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_REPORT_CREATE_CONN)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_REPROT_CLOSE_CONN)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_REPORT_EXCEPTION)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_SUBSCRIBE_STATE_LISTENER)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_UNSUBSCRIBE_STATE_LISTENER)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_SUBSCRIBE_LIFE_LISTENER)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_UNSUBSCRIBE_LIFE_LISTENER)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_RECORD_STATE_EVENT)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_RECORD_CREATE_CONN)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_RECORD_CLOSE_CONN)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_RECORD_ENTITY_CLOSE)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_RECORD_ENTITY_CREATE)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_RECORD_ENTITY_EXCEPTION)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_SWITCH_RUNNING_MODE)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_USER_STATE_EVENT)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_ENT_RESULT_EX)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_NOTIFY_REDIRECT_SUBSCRIBE)
        SP_MOD_CMDTYPE_DEFINE(MOD_CMD_REPORT_REDIRECT_SUBSCRIBE)
	default:
		return "unknown-cmdtype";
		break;
	}
}


static int mod_kill_process(sp_mod_t* mod)
{
	DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "to kill mod %s's process", mod->cfg->name);
#ifdef _WIN32
	if (0 != killModByPipe(findGroupProcessInfo(0, mod->cfg->name), mod->cfg->name)) {
		char szCmd[256];
		int nRet = 0;
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "terminate %s fail: 0x%X, retry with taskkill", mod->cfg->name, GetLastError());
		sprintf_s(szCmd, 256, "TASKKILL /PID %d /F", mod->process.pid);
		WinExec(szCmd, SW_HIDE);
	}
	return 0;
#else
	//to kill -15
	BOOL result = TerminateProcess(mod->process.handle, -1);
	if (!result && errno != 3) {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "to kill 15 cmd: %d", errno);
		if(kill(mod->process.pid, 9/*SIGKILL*/) && errno != 3) //No such process
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "kill 9 cmd for %s fail: %d", mod->cfg->name, errno);
		else 
			result = TRUE;
	}
	return (result ? 0 : -1);
#endif //_WIN32
}

static int mod_on_pkt(sp_iom_t *iom, int to_svc_id, int epid, int svc_id, int pkt_type, int pkt_id, iobuffer_t **p_pkt, void *user_data)
{
	sp_mod_stub_t *stub = (sp_mod_stub_t *)user_data;

	if (SP_GET_PKT_TYPE(pkt_type) == SP_PKT_MOD) {
		int cmd_type = SP_GET_TYPE(pkt_type);
		int result = Error_Bug;
		int processed = 0;
		if (cmd_type == MOD_CMD_INIT) {
			int service_flag = 0;
			int multithread_flag = 0;
			DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "receive module init cmd!");
			__try {
				result = stub->cb.on_module_init(stub, stub->cb.user_data);
			} __except(EXCEPTION_EXECUTE_HANDLER) {
				result = Error_Exception;
			}
			if (result != 0) {
				DbgWithLinkForC(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM, "module init end! %d, %s", result, sp_strerror(result));
			}
			sp_iom_post(iom, SP_INVALID_SVC_ID, epid, svc_id, SP_PKT_MOD|MOD_CMD_MOD_RESULT, result, NULL);
		} else if (cmd_type == MOD_CMD_TERM) {
			DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "receive module term cmd!");
			__try {
				result = stub->cb.on_module_term(stub, stub->cb.user_data);
			} __except(EXCEPTION_EXECUTE_HANDLER) {
				result = Error_Exception;
			}
			sp_iom_post(iom, SP_INVALID_SVC_ID, epid, svc_id, SP_PKT_MOD|MOD_CMD_MOD_RESULT, result, NULL);
			sp_iom_post_quit(iom);
		} else {
			return TRUE;
		}
		return FALSE;
	}

	return TRUE;
}

int sp_mod_stub_create(const sp_mod_stub_cb *cb, sp_iom_t *iom, sp_mod_stub_t **p_stub)
{
	sp_mod_stub_t *stub = MALLOC_T(sp_mod_stub_t);

	memcpy(&stub->cb, cb, sizeof(sp_mod_stub_cb));
	stub->iom = iom;
	sp_iom_add_pkt_handler(iom, (int)stub, &mod_on_pkt, stub);
	*p_stub = stub;

	return 0;
}

void sp_mod_stub_destroy(sp_mod_stub_t *stub)
{
	sp_iom_remove_pkt_handler(stub->iom, (int)stub);
	FREE(stub);
}

static void mod_entity_process_cmd(threadpool_t *threadpool, void *arg)
{
	iobuffer_t *pkt = arg;
	sp_mod_entity_stub_t *stub;
	int epid;
	int svc_id;
	int pkt_type;
	int pkt_id;
	int cmd_type;
	WLog_DBG(TAG, "==> %s", __FUNCTION__);
	iobuffer_read(pkt, IOBUF_T_PTR, &stub, NULL);
	iobuffer_read(pkt, IOBUF_T_I4, &epid, NULL);
	iobuffer_read(pkt, IOBUF_T_I4, &svc_id, NULL);
	iobuffer_read(pkt, IOBUF_T_I4, &pkt_type, NULL);
	iobuffer_read(pkt, IOBUF_T_I4, &pkt_id, NULL);
	cmd_type = SP_GET_TYPE(pkt_type);

	switch (cmd_type) {
		case MOD_CMD_TEST:
			{
				int trigger_entity_id;
				int test_type;
				iobuffer_read(pkt, IOBUF_T_I4, &trigger_entity_id, NULL);
				iobuffer_read(pkt, IOBUF_T_I4, &test_type, NULL);
				stub->cb.on_entity_test(stub, trigger_entity_id, test_type, stub->cb.user_data);
			}
			break;
		case MOD_CMD_CONTINUE:
			{
				int trigger_entity_id;
				iobuffer_read(pkt, IOBUF_T_I4, &trigger_entity_id, NULL);
				stub->cb.on_entity_precontinue(stub, trigger_entity_id, stub->cb.user_data);
			}
			break;
		case MOD_CMD_PAUSE:
			{
				int trigger_entity_id;
				iobuffer_read(pkt, IOBUF_T_I4, &trigger_entity_id, NULL);
				stub->cb.on_entity_prepause(stub, trigger_entity_id, stub->cb.user_data);
			}
			break;
		case MOD_CMD_STOP:
			{
				int trigger_entity_id;
				int cause_code;
				iobuffer_read(pkt, IOBUF_T_I4, &trigger_entity_id, NULL);
				iobuffer_read(pkt, IOBUF_T_I4, &cause_code, NULL);
				stub->cb.on_entity_stop(stub, trigger_entity_id, cause_code, stub->cb.user_data);
			}
			break;
		case MOD_CMD_START:
			{
				int slen = 0;
				char *cmdline = NULL;
				int numargs, numchars;
				char *p = NULL;
				int argc = 0;
				char **argv = NULL;
				int trigger_entity_id;
				iobuffer_read(pkt, IOBUF_T_STR, NULL, &slen);
				if (slen) {
					cmdline = malloc(slen+1);
					iobuffer_read(pkt, IOBUF_T_STR, cmdline, NULL);
					str_parse_cmdline(cmdline, NULL, NULL, &numargs, &numchars);
					p = malloc(numargs*sizeof(char*) + numchars);
					argc = numargs - 1; /*except program.exe name, and actually it doesn't exist*/
					argv = (char**)p;
					str_parse_cmdline(cmdline, (char **)p, p + numargs * sizeof(char *), &numargs, &numchars);
				}
				iobuffer_read(pkt, IOBUF_T_I4, &trigger_entity_id, NULL);
				WLog_DBG(TAG, "on_entity_prestart address: %p", (void*)stub->cb.on_entity_prestart);
				stub->cb.on_entity_prestart(stub, trigger_entity_id, argc, argv, stub->cb.user_data);
				WLog_DBG(TAG, "after invoke on_entity_prestart(trigger %d)", trigger_entity_id);
				free(p);
				free(cmdline);
			}
			break;
		case MOD_CMD_NOTIFY_REDIRECT_SUBSCRIBE:
			{
				int slen = 0;
				int from_entity_id = pkt_id;
				sp_uid_t uid;
				char *param = NULL;
				iobuffer_read(pkt, IOBUF_T_I8, &uid, 0);
				iobuffer_read(pkt, IOBUF_T_STR, NULL, &slen);
				if (slen) {
					param = malloc(slen + 1);
					iobuffer_read(pkt, IOBUF_T_STR, param, NULL);
				}
				stub->cb.on_entity_redirect_subscribe(stub, &uid, from_entity_id, param, stub->cb.user_data);
				free(param);
			}
			break;
		default:
			TOOLKIT_ASSERT(0);
			break;
	}

	iobuffer_dec_ref(pkt);

	WLog_DBG(TAG, "<== %s", __FUNCTION__);
}

static int mod_entity_on_pkt(sp_svc_t *svc, int epid, int svc_id, int pkt_type, int pkt_id, iobuffer_t **p_pkt, void *user_data)
{
	sp_mod_entity_stub_t *stub = (sp_mod_entity_stub_t *)user_data;

	if (SP_GET_PKT_TYPE(pkt_type) == SP_PKT_MOD) {
		int cmd_type = SP_GET_TYPE(pkt_type);

		DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "rx entity cmd: %s !",  str_cmdtype(cmd_type));
		if (cmd_type == MOD_CMD_START || 
			cmd_type == MOD_CMD_STOP || 
			cmd_type == MOD_CMD_PAUSE ||
			cmd_type == MOD_CMD_CONTINUE ||
			cmd_type == MOD_CMD_TEST ||
			cmd_type == MOD_CMD_NOTIFY_REDIRECT_SUBSCRIBE) {
				iobuffer_t *pkt = *p_pkt;
				*p_pkt = NULL;
				iobuffer_write_head(pkt, IOBUF_T_I4, &pkt_id, 0);
				iobuffer_write_head(pkt, IOBUF_T_I4, &pkt_type, 0);
				iobuffer_write_head(pkt, IOBUF_T_I4, &svc_id, 0);
				iobuffer_write_head(pkt, IOBUF_T_I4, &epid, 0);
				iobuffer_write_head(pkt, IOBUF_T_PTR, &stub, 0);
				threadpool_queue_workitem(sp_svc_get_threadpool(stub->svc), stub->strand, &mod_entity_process_cmd, pkt);
				return FALSE;
		}
	}

	return TRUE;
}

int sp_mod_entity_stub_create(const sp_mod_entity_stub_cb *cb, sp_svc_t *svc, sp_mod_entity_stub_t **p_stub)
{
	sp_mod_entity_stub_t *stub = MALLOC_T(sp_mod_entity_stub_t);

	memcpy(&stub->cb, cb, sizeof(sp_mod_entity_stub_cb));
	stub->svc = svc;
	stub->strand = strand_create();
	sp_svc_add_pkt_handler(svc, (int)stub, SP_PKT_MOD, &mod_entity_on_pkt, stub);
	*p_stub = stub;

	return 0;
}

void sp_mod_entity_stub_destroy(sp_mod_entity_stub_t *stub)
{
	sp_svc_remove_pkt_handler(stub->svc, (int)stub, SP_PKT_MOD);
	strand_destroy(stub->strand);
	free(stub);
}

int sp_mod_entity_stub_report_create_connection(sp_mod_entity_stub_t *stub, int remote_entity)
{
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_REPORT_CREATE_CONN, remote_entity, NULL);
	return 0;
}

int sp_mod_entity_stub_report_close_connection(sp_mod_entity_stub_t *stub, int remote_entity)
{
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_REPROT_CLOSE_CONN, remote_entity, NULL);
	return 0;
}

int sp_mod_entity_stub_report_exception(sp_mod_entity_stub_t *stub, int win32_exception_code, int eip, int in_func)
{
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I4, &win32_exception_code, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &eip, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &in_func, 0);
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_REPORT_EXCEPTION, SP_SHELL_SVC_ID, &pkt);
	if (pkt)
		iobuffer_dec_ref(pkt);
	return 0;
}

int sp_mod_entity_stub_switch_running_state(sp_mod_entity_stub_t *stub, int state)
{
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_SWITCH_RUNNING_MODE, state, NULL);
	return 0;
}

int sp_mod_entity_stub_report_user_state_change(sp_mod_entity_stub_t *stub, int last_state, int curr_state)
{
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I4, &last_state, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &curr_state, 0);
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_USER_STATE_EVENT, 0, &pkt);
	if (pkt)
		iobuffer_dec_ref(pkt);
	return 0;
}

int sp_mod_entity_stub_finish_start(sp_mod_entity_stub_t *stub, int result)
{
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_ENT_RESULT, result, NULL);
	return 0;
}

int sp_mod_entity_stub_finish_stop(sp_mod_entity_stub_t *stub, int result)
{
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_ENT_RESULT, result, NULL);
	return 0;
}

int sp_mod_entity_stub_finish_pause(sp_mod_entity_stub_t *stub, int result)
{
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_ENT_RESULT, result, NULL);
	return 0;
}

int sp_mod_entity_stub_finish_continue(sp_mod_entity_stub_t *stub, int result)
{
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_ENT_RESULT, result, NULL);
	return 0;
}

int sp_mod_entity_stub_finish_test(sp_mod_entity_stub_t *stub, int result)
{
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_ENT_RESULT, result, NULL);
	return 0;
}

int sp_mod_entity_stub_finish_exam(sp_mod_entity_stub_t* stub, int result,  int statistic)
{
	iobuffer_t* pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I4, &statistic, 0);
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD | MOD_CMD_ENT_RESULT_EX, result, &pkt);
	if (pkt)
		iobuffer_dec_ref(pkt);
	return 0;
}

int sp_mod_entity_stub_finish_redirect_subscribe(sp_mod_entity_stub_t *stub, sp_uid_t *uid, int suggest_entity_id)
{
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I8, uid, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &suggest_entity_id, 0);
	sp_svc_post(stub->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_REPORT_REDIRECT_SUBSCRIBE, 0, &pkt);
	if (pkt)
		iobuffer_dec_ref(pkt);
	return 0;
}

//
// entity event listener
//

struct sp_mod_entity_state_listener_t
{
	sp_mod_entity_event_cb cb;
	sp_svc_t *svc;
	int target_entity_id;
	spinlock_t lock;
	strand_t *strand;
	int stop;
	void *user_data;
	DECLARE_REF_COUNT_MEMBER(ref_cnt);
};

DECLARE_REF_COUNT_STATIC(sp_mod_entity_state_listener, sp_mod_entity_state_listener_t)

static void mod_entity_state_listener_process_cmd(threadpool_t *threadpool, void *arg)
{
	sp_mod_entity_state_listener_t *listener;
	iobuffer_t *pkt = arg;

	iobuffer_read(pkt, IOBUF_T_PTR, &listener, NULL);

	spinlock_enter(&listener->lock, -1);
	if (!listener->stop) {
		int epid;
		int svc_id;
		int pkt_type;
		int pkt_id;
		int cmd_type;

		iobuffer_read(pkt, IOBUF_T_I4, &epid, NULL);
		iobuffer_read(pkt, IOBUF_T_I4, &svc_id, NULL);
		iobuffer_read(pkt, IOBUF_T_I4, &pkt_type, NULL);
		iobuffer_read(pkt, IOBUF_T_I4, &pkt_id, NULL);

		cmd_type = SP_GET_TYPE(pkt_type);

		if (cmd_type == MOD_CMD_RECORD_STATE_EVENT) {
			int entity_id;
			int trigger_entity_id;
			int last_state;
			int curr_state;
			iobuffer_read(pkt, IOBUF_T_I4, &entity_id, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &trigger_entity_id, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &last_state, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &curr_state, NULL);
			if (listener->target_entity_id == -1 || listener->target_entity_id == entity_id)
				listener->cb.on_entity_state(listener, entity_id, trigger_entity_id, last_state, curr_state, listener->cb.user_data);
		} 
		else if (cmd_type == MOD_CMD_USER_STATE_EVENT)
		{
			int entity_id;
			int last_state;
			int curr_state;
			iobuffer_read(pkt, IOBUF_T_I4, &entity_id, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &last_state, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &curr_state, NULL);
			if (listener->target_entity_id == -1 || listener->target_entity_id == entity_id)
				listener->cb.on_user_state(listener, entity_id, last_state, curr_state, listener->cb.user_data);
		}
		else if (cmd_type == MOD_CMD_RECORD_CREATE_CONN) {
			int src_entity_id;
			int dst_entity_id;
			iobuffer_read(pkt, IOBUF_T_I4, &src_entity_id, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &dst_entity_id, NULL);
			if (listener->target_entity_id == -1 || listener->target_entity_id == src_entity_id || listener->target_entity_id == dst_entity_id)
				listener->cb.on_create_connection(listener, src_entity_id, dst_entity_id, listener->cb.user_data);
		} else if (cmd_type == MOD_CMD_RECORD_CLOSE_CONN) {
			int src_entity_id;
			int dst_entity_id;
			iobuffer_read(pkt, IOBUF_T_I4, &src_entity_id, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &dst_entity_id, NULL);
			if (listener->target_entity_id == -1 || listener->target_entity_id == src_entity_id || listener->target_entity_id == dst_entity_id)
				listener->cb.on_close_connection(listener, src_entity_id, dst_entity_id, listener->cb.user_data);
		} else {
			TOOLKIT_ASSERT(0);
		}
	}
	spinlock_leave(&listener->lock);

	iobuffer_dec_ref(pkt);
	sp_mod_entity_state_listener_dec_ref(listener);
}

static int mod_entity_state_listener_on_pkt(sp_svc_t *svc, int epid, int svc_id, int pkt_type, int pkt_id, iobuffer_t **p_pkt, void *user_data)
{
	sp_mod_entity_state_listener_t *listener = (sp_mod_entity_state_listener_t *)user_data;

	if (SP_GET_PKT_TYPE(pkt_type) == SP_PKT_MOD && !listener->stop) {
		const int cmd_type = SP_GET_TYPE(pkt_type);
		if (cmd_type == MOD_CMD_RECORD_STATE_EVENT || 
			cmd_type == MOD_CMD_USER_STATE_EVENT ||
			cmd_type == MOD_CMD_RECORD_CREATE_CONN ||
			cmd_type == MOD_CMD_RECORD_CLOSE_CONN) {
			iobuffer_t *pkt = iobuffer_clone(*p_pkt);
			iobuffer_write_head(pkt, IOBUF_T_I4, &pkt_id, 0);
			iobuffer_write_head(pkt, IOBUF_T_I4, &pkt_type, 0);
			iobuffer_write_head(pkt, IOBUF_T_I4, &svc_id, 0);
			iobuffer_write_head(pkt, IOBUF_T_I4, &epid, 0);
			iobuffer_write_head(pkt, IOBUF_T_PTR, &listener, 0);
			sp_mod_entity_state_listener_inc_ref(listener);
			if (threadpool_queue_workitem(
				sp_svc_get_threadpool(listener->svc), listener->strand, mod_entity_state_listener_process_cmd, pkt) < 0) {
				sp_mod_entity_state_listener_dec_ref(listener);
				iobuffer_dec_ref(pkt);
			}
		}
	}
	return TRUE;
}

int sp_mod_entity_listener_create(int target_entity_id, const sp_mod_entity_event_cb *cb, sp_svc_t *svc, void *tag, sp_mod_entity_state_listener_t **p_listener)
{
	sp_mod_entity_state_listener_t *listener = MALLOC_T(sp_mod_entity_state_listener_t);

	memcpy(&listener->cb, cb, sizeof(sp_mod_entity_event_cb));
	listener->svc = svc;
	listener->stop = 0;
	listener->user_data = tag;
	listener->target_entity_id = target_entity_id;
	spinlock_init(&listener->lock);
	listener->strand = strand_create();
	REF_COUNT_INIT(&listener->ref_cnt);
	sp_svc_add_pkt_handler(svc, (int)listener, SP_PKT_MOD, &mod_entity_state_listener_on_pkt, listener);
	*p_listener = listener;

	sp_svc_post(svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_SUBSCRIBE_STATE_LISTENER, target_entity_id, NULL);

	return 0;
}

static void __sp_mod_entity_listener_destroy(sp_mod_entity_state_listener_t *listener)
{
	strand_destroy(listener->strand);
	free(listener);
}
IMPLEMENT_REF_COUNT_MT_STATIC(sp_mod_entity_state_listener,sp_mod_entity_state_listener_t,ref_cnt, __sp_mod_entity_listener_destroy)

void sp_mod_entity_listener_destroy(sp_mod_entity_state_listener_t *listener)
{
	sp_svc_post(listener->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_UNSUBSCRIBE_STATE_LISTENER, listener->target_entity_id, NULL);
	spinlock_enter(&listener->lock, -1);
	listener->stop = TRUE;
	spinlock_leave(&listener->lock);
	sp_svc_remove_pkt_handler(listener->svc, (int)listener, SP_PKT_MOD);
	sp_mod_entity_state_listener_dec_ref(listener);
}

void sp_mod_entity_listener_set_tag(sp_mod_entity_state_listener_t *listener, void *data)
{
	listener->user_data = data;
}

void *sp_mod_entity_listener_get_tag(sp_mod_entity_state_listener_t *listener)
{
	return listener->user_data;
}

// entity life listener

struct sp_mod_entity_life_listener_t
{
	sp_mod_entity_life_cb cb;
	sp_svc_t *svc;
	spinlock_t lock;
	strand_t *strand;
	int stop;
	void *user_data;
	DECLARE_REF_COUNT_MEMBER(ref_cnt);
};

DECLARE_REF_COUNT_STATIC(sp_mod_entity_life_listener, sp_mod_entity_life_listener_t)

static void mod_entity_life_listener_process_cmd(threadpool_t *threadpool, void *arg)
{
	sp_mod_entity_life_listener_t *listener;
	iobuffer_t *pkt = arg;

	iobuffer_read(pkt, IOBUF_T_PTR, &listener, NULL);

	spinlock_enter(&listener->lock, -1);
	if (!listener->stop) {
		int epid;
		int svc_id;
		int pkt_type;
		int pkt_id;
		int cmd_type;

		iobuffer_read(pkt, IOBUF_T_I4, &epid, NULL);
		iobuffer_read(pkt, IOBUF_T_I4, &svc_id, NULL);
		iobuffer_read(pkt, IOBUF_T_I4, &pkt_type, NULL);
		iobuffer_read(pkt, IOBUF_T_I4, &pkt_id, NULL);

		cmd_type = SP_GET_TYPE(pkt_type);

		if (cmd_type == MOD_CMD_RECORD_ENTITY_CREATE) {
			int entity_id;
			int trigger_entity_id;
			iobuffer_read(pkt, IOBUF_T_I4, &entity_id, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &trigger_entity_id, NULL);
			listener->cb.on_entity_create(listener, entity_id, trigger_entity_id, listener->cb.user_data);
		} else if (cmd_type == MOD_CMD_RECORD_ENTITY_CLOSE) {
			int entity_id;
			int trigger_entity_id;
			int close_cause;
			iobuffer_read(pkt, IOBUF_T_I4, &entity_id, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &trigger_entity_id, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &close_cause, NULL);
			listener->cb.on_entity_close(listener, entity_id, trigger_entity_id, close_cause, listener->cb.user_data);
		} else if (cmd_type == MOD_CMD_RECORD_ENTITY_EXCEPTION) {
			int entity_id;
			int error;
			int entity_state;
			iobuffer_read(pkt, IOBUF_T_I4, &entity_id, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &error, NULL);
			iobuffer_read(pkt, IOBUF_T_I4, &entity_state, NULL);
			listener->cb.on_entity_exception(listener, entity_id, error, entity_state, listener->cb.user_data);
		} else {
			TOOLKIT_ASSERT(0);
		}
	}
	spinlock_leave(&listener->lock);

	iobuffer_dec_ref(pkt);
	sp_mod_entity_life_listener_dec_ref(listener);
}

static int mod_entity_life_listener_on_pkt(sp_svc_t *svc, int epid, int svc_id, int pkt_type, int pkt_id, iobuffer_t **p_pkt, void *user_data)
{
	sp_mod_entity_life_listener_t *listener = (sp_mod_entity_life_listener_t *)user_data;

	if (SP_GET_PKT_TYPE(pkt_type) == SP_PKT_MOD && !listener->stop) {
		int cmd_type = SP_GET_TYPE(pkt_type);
		if (cmd_type == MOD_CMD_RECORD_ENTITY_CREATE || 
			cmd_type == MOD_CMD_RECORD_ENTITY_CLOSE ||
			cmd_type == MOD_CMD_RECORD_ENTITY_EXCEPTION) {
				iobuffer_t *pkt = iobuffer_clone(*p_pkt);
				iobuffer_write_head(pkt, IOBUF_T_I4, &pkt_id, 0);
				iobuffer_write_head(pkt, IOBUF_T_I4, &pkt_type, 0);
				iobuffer_write_head(pkt, IOBUF_T_I4, &svc_id, 0);
				iobuffer_write_head(pkt, IOBUF_T_I4, &epid, 0);
				iobuffer_write_head(pkt, IOBUF_T_PTR, &listener, 0);
				sp_mod_entity_life_listener_inc_ref(listener);
				if (threadpool_queue_workitem(
					sp_svc_get_threadpool(listener->svc), listener->strand, &mod_entity_life_listener_process_cmd, pkt) < 0) {
					sp_mod_entity_life_listener_dec_ref(listener);
					iobuffer_dec_ref(pkt);
				}
		}
	}
	return TRUE;
}

int sp_mod_entity_life_listener_create(const sp_mod_entity_life_cb *cb, sp_svc_t *svc, void *tag, sp_mod_entity_life_listener_t **p_listener)
{
	sp_mod_entity_life_listener_t *listener = MALLOC_T(sp_mod_entity_life_listener_t);

	memcpy(&listener->cb, cb, sizeof(sp_mod_entity_life_cb));
	listener->svc = svc;
	listener->stop = 0;
	listener->user_data = tag;
	spinlock_init(&listener->lock);
	listener->strand = strand_create();
	REF_COUNT_INIT(&listener->ref_cnt);
	sp_svc_add_pkt_handler(svc, (int)listener, SP_PKT_MOD, &mod_entity_life_listener_on_pkt, listener);
	*p_listener = listener;

	sp_svc_post(svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_SUBSCRIBE_LIFE_LISTENER, 0, NULL);

	return 0;
}

void __sp_mod_entity_life_listener_destroy(sp_mod_entity_life_listener_t *listener)
{
	strand_destroy(listener->strand);
	free(listener);
}
IMPLEMENT_REF_COUNT_MT_STATIC(sp_mod_entity_life_listener, sp_mod_entity_life_listener_t, ref_cnt, __sp_mod_entity_life_listener_destroy)
void sp_mod_entity_life_listener_destroy(sp_mod_entity_life_listener_t *listener)
{
	sp_svc_post(listener->svc, SP_SHELL_MOD_ID, SP_SHELL_SVC_ID, SP_PKT_MOD|MOD_CMD_UNSUBSCRIBE_LIFE_LISTENER, 0, NULL);
	spinlock_enter(&listener->lock, -1);
	listener->stop = TRUE;
	spinlock_leave(&listener->lock);
	sp_svc_remove_pkt_handler(listener->svc, (int)listener, SP_PKT_MOD);
	sp_mod_entity_life_listener_dec_ref(listener);
}

void sp_mod_entity_life_listener_set_tag(sp_mod_entity_life_listener_t *listener, void *data)
{
	listener->user_data = data;
}

void *sp_mod_entity_life_listener_get_tag(sp_mod_entity_life_listener_t *listener)
{
	return listener->user_data;
}

typedef struct entity_state_subscribe_entry {
	struct list_head entry;
	int mod_id;
	int svc_id;
	int instance;
	int target_entity_id;
}entity_state_subscribe_entry;

typedef struct entity_life_subscribe_entry {
	struct list_head entry;
	int mod_id;
	int svc_id;
	int instance;
}entity_life_subscribe_entry;

struct sp_mod_mgr_t
{
	sp_bcm_daemon_t *shell_daemon; // only for shell use
	sp_svc_t *shell_svc;
	CRITICAL_SECTION lock;
	process_monitor_t *process_monitor;
	
	spinlock_t entity_state_subscribe_lock;
	struct list_head entity_state_subscribe_list;
	
	spinlock_t entity_life_subscribe_lock;
	struct list_head entity_life_subscribe_list;

	struct list_head mod_list;		// list of sp_mod_t*
	array_header_t *arr_mod;		// array of  sp_mod_t*
	array_header_t *arr_ent;		// array of sp_entity_t*

	LONG instance_seq;
};

static __inline int mgr_new_instance_id(sp_mod_mgr_t *mgr)
{
	return (int)InterlockedIncrement((LONG*)&mgr->instance_seq);
}


#if defined(RVC_OS_WIN)
int assigntoJob(HANDLE process, int pid)
{
    //创建一个job内核对象  
    HANDLE hd = CreateJobObjectA(NULL, NULL);

    if (hd) {
        JOBOBJECT_EXTENDED_LIMIT_INFORMATION extLimitInfo;
        extLimitInfo.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK;

        if (!SetInformationJobObject(hd, JobObjectExtendedLimitInformation, &extLimitInfo, sizeof(extLimitInfo))) {
            CloseHandle(hd);
            return -1;
        }

		//insert the process into the job 
		if (AssignProcessToJobObject(hd, process))
			return 0;
		else
		{
			DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "AssignProcessToJobObject err! process: %d, %d", process, pid);
			return -1;
		}
	}
	else
	{
		DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "CreateJobObjectA err!");
		return -1;
	}
}
#endif //RVC_OS_WIN

static int create_module_process(const char *mod_name, int epid, int range, int debugFileExist, tk_process_t* new_process, int runType, int entity_id)
{
	char app[MAX_PATH] = {'\0'};
	int group = 0;

#ifdef _WIN32
	char writeParam[MAX_PATH] = "";
	char mutexName[MAX_PATH] = "";
	char eventName[MAX_PATH] = "";
	//BOOL bRet;
	STARTUPINFOA si = { sizeof(STARTUPINFOA) };
	PROCESS_INFORMATION pi;
	DWORD dwSessionId;
	HANDLE hUserTokenDup = NULL, hThisToken = NULL;
	HANDLE hProcess = NULL;
	HANDLE hMutex = NULL;
	int result = 0;
	sp_process_t* groupProcess = NULL;

	BOOL   fConnected = FALSE;
	DWORD  dwThreadId = 0;
	HANDLE hPipe = INVALID_HANDLE_VALUE, hThread = NULL;
	char lpszPipename[MAX_PATH] = "\\\\.\\pipe\\";
	static DWORD shellId = 0;
	if (0 == shellId)
		shellId = GetCurrentProcessId();

	if (0 != getNewGuid(mutexName)) {
		DbgWithLinkForC(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM, "get new gui failed!");
		return -1;
	}

	if (runType == 1)
		sprintf(app, ".\\bin\\sphost.exe {%s} %d", mutexName, shellId);
	else
		sprintf(app, ".\\bin\\sphost_re.exe {%s} %d", mutexName, shellId);

	sprintf_s(writeParam, sizeof(writeParam), "%s %d %d %s %d %d", mod_name, epid, range, mutexName, debugFileExist, entity_id);

	do {
		sp_process_t* curProcess = ZALLOC_T(sp_process_t);
		LUID luid;
		TOKEN_PRIVILEGES tp;
		LPVOID pEnv = NULL;

		if (0 == group)
			checkGroupProcesInfo(group, mod_name);
		groupProcess = findGroupProcessInfo(group, mod_name);//1，group为0时，基于每个group0_entityName的进程；2，gourp不为0,基于groupN的进程

		if (NULL != groupProcess)
			break;//already exist

		DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "open group process, %s", mod_name);
		dwSessionId = WTSGetActiveConsoleSessionId();

		if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &hThisToken)) {
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "open process token failed! Error : %d", GetLastError());
			break;
		}

		LookupPrivilegeValueA(NULL, SE_DEBUG_NAME, &luid);
		tp.PrivilegeCount = 1;
		tp.Privileges[0].Luid = luid;
		tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
		DuplicateTokenEx(hThisToken, MAXIMUM_ALLOWED, NULL, SecurityIdentification, TokenPrimary, &hUserTokenDup);
		SetTokenInformation(hUserTokenDup, TokenSessionId, (void*)&dwSessionId, sizeof(DWORD));
		AdjustTokenPrivileges(hUserTokenDup, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), (PTOKEN_PRIVILEGES)NULL, NULL);
		//提升权限

		sprintf(lpszPipename, "%s{%s}", lpszPipename, mutexName);
		sprintf(eventName, "{%s}", mutexName);

		hPipe = CreateNamedPipe(lpszPipename, PIPE_ACCESS_DUPLEX, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, PIPE_UNLIMITED_INSTANCES, BUFSIZE, BUFSIZE, 0, NULL);
		if (hPipe == INVALID_HANDLE_VALUE && !ConnectNamedPipe(hPipe, NULL) ? TRUE : (GetLastError() == ERROR_PIPE_CONNECTED))
			return -1;

		hMutex = CreateEvent(NULL, FALSE, FALSE, eventName);

		if (!CreateProcessAsUserA(hUserTokenDup, NULL, app, NULL, NULL, FALSE, 0, pEnv, NULL, &si, &pi)) {
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "CreateProcessAsUserA failed! Error : %d", GetLastError());
			break;
		}

		new_process->pid = pi.dwProcessId;
		new_process->handle = pi.hProcess;
		CloseHandle(pi.hThread);
		hProcess = pi.hProcess;
		curProcess->process_Handle = hProcess;
		curProcess->pid = pi.dwProcessId;
		curProcess->group = group;
		curProcess->write_pipe = hPipe;
		curProcess->read_pipe = hPipe;
		AddGroupProcessInfo(group, curProcess, mod_name);

		assigntoJob(hProcess, pi.dwProcessId);

		if (WAIT_TIMEOUT == WaitForSingleObject(hMutex, 10000))//确定实体进程已启动
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "open process timeout, %s", mod_name);
		CloseHandle(hMutex);

	} while (0);
	CloseHandle(hUserTokenDup);
	CloseHandle(hThisToken);

	addStartupStep(entity_id, "start_mod", "", 0, 0, 0);
	//通过管道通知进程创建实体线程
	if (NULL != (groupProcess = findGroupProcessInfo(group, mod_name)) && 0 == startModByPipe(groupProcess, writeParam)) {
		char dstParam[10][MAX_PATH];
		int paramNum = 0;
		ZeroMemory(dstParam, sizeof(dstParam));
		addStartupStep(entity_id, "query_mod", "", 0, 0, 0);
		if (-1 != (paramNum = queryModByPipe(groupProcess, mod_name, dstParam)))		//return paramNum
		{
			char processId[20];
			HANDLE processMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, dstParam[2]);
			new_process->pid = (int)groupProcess->pid;
			sprintf(processId, "%d", new_process->pid);
			addStartupStep(entity_id, "open_process_id", processId, 0, 0, 0);
			return 0;
		}
	}

#else

	tk_process_t* process = NULL;
	tk_process_option_t option;
	sprintf(app, "./bin/sphost %d %s %d %d %d", range, mod_name, epid, debugFileExist, entity_id);
	option.exit_cb = NULL;
	option.file = NULL;
	option.flags = 0;
	option.params = app;
	
	if (0 == process_spawn(&option, &process)) {
		new_process->pid = process->pid;
		new_process->handle = process->handle;
		FREE(process);
		return 0;
	}
#endif //_WIN32
	return -1;
}

static void mgr_bcast_entity_state_event(sp_mod_mgr_t *mgr, sp_entity_t *changed_entity, int pkt_type, iobuffer_t *pkt)
{
	entity_state_subscribe_entry *pos;
	spinlock_enter(&mgr->entity_state_subscribe_lock, -1);
	list_for_each_entry(pos, &mgr->entity_state_subscribe_list, entity_state_subscribe_entry, entry) {
		if (pos->target_entity_id == -1 || changed_entity->cfg->idx == pos->target_entity_id) {
			iobuffer_t *copy = iobuffer_clone(pkt);
			sp_svc_post(mgr->shell_svc, pos->mod_id, pos->svc_id, pkt_type, 0, &copy);
			if (copy)
				iobuffer_dec_ref(copy);
		}
	}
	spinlock_leave(&mgr->entity_state_subscribe_lock);
}

static void mgr_bcast_entity_on_connection(sp_mod_mgr_t *mgr, sp_entity_t *entity_src, sp_entity_t *entity_dst, int pkt_type, iobuffer_t *pkt)
{
	entity_state_subscribe_entry *pos;
	spinlock_enter(&mgr->entity_state_subscribe_lock, -1);
	list_for_each_entry(pos, &mgr->entity_state_subscribe_list, entity_state_subscribe_entry, entry) {
		if (pos->target_entity_id == -1 || entity_src->cfg->idx == pos->target_entity_id || entity_dst->cfg->idx == pos->target_entity_id) {
			iobuffer_t *copy = iobuffer_clone(pkt);
			sp_svc_post(mgr->shell_svc, pos->mod_id, pos->svc_id, pkt_type, 0, &copy);
			if (copy)
				iobuffer_dec_ref(copy);
		}
	}
	spinlock_leave(&mgr->entity_state_subscribe_lock);
	DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "bcast entity on connection! src: %s, dst: %s", entity_src->cfg->name, entity_dst->cfg->name);
}

static void mgr_on_entity_state(sp_mod_mgr_t *mgr, sp_entity_t *entity, int trigger_entity_id, int last_state, int curr_state)
{
	sp_env_t *env = NULL;
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I4, &entity->cfg->idx, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &trigger_entity_id, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &last_state, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &curr_state, 0);
	mgr_bcast_entity_state_event(mgr, entity, SP_PKT_MOD|MOD_CMD_RECORD_STATE_EVENT, pkt);
	iobuffer_dec_ref(pkt);

	addStartupStep(entity->cfg->idx, "state_change", "", last_state, curr_state, 0);

	// gui显示实体状态变化
	env = sp_get_env();
#if defined(_MSC_VER)
	sp_gui_show_entity_info(env->gui, entity->cfg->name, curr_state);
#else
	if (env->gui != NULL) {
		env->gui->show_entity_info(env->gui->gui_inst, entity->cfg->name, curr_state);
	}
#endif //_MSC_VER
}

static void mgr_on_user_state(sp_mod_mgr_t *mgr, sp_entity_t *entity, int last_state, int curr_state)
{
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I4, &entity->cfg->idx, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &last_state, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &curr_state, 0);
	mgr_bcast_entity_state_event(mgr, entity, SP_PKT_MOD|MOD_CMD_USER_STATE_EVENT, pkt);
	iobuffer_dec_ref(pkt);
}

static void mgr_on_create_connection(sp_mod_mgr_t *mgr, sp_entity_t *entity_src, sp_entity_t *entity_dst)
{
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I4, &entity_src->cfg->idx, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &entity_dst->cfg->idx, 0);
	mgr_bcast_entity_on_connection(mgr, entity_src, entity_dst, SP_PKT_MOD|MOD_CMD_RECORD_CREATE_CONN, pkt);
	iobuffer_dec_ref(pkt);
}

static void mgr_on_close_connection(sp_mod_mgr_t *mgr, sp_entity_t *entity_src, sp_entity_t *entity_dst)
{
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I4, &entity_src->cfg->idx, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &entity_dst->cfg->idx, 0);
	mgr_bcast_entity_on_connection(mgr, entity_src, entity_dst, SP_PKT_MOD|MOD_CMD_RECORD_CLOSE_CONN, pkt);
	iobuffer_dec_ref(pkt);
}

static void mgr_bcast_entity_life_event(sp_mod_mgr_t *mgr, int pkt_type, iobuffer_t *pkt)
{
	entity_life_subscribe_entry *pos;
	spinlock_enter(&mgr->entity_life_subscribe_lock, -1);
	list_for_each_entry(pos, &mgr->entity_life_subscribe_list, entity_life_subscribe_entry, entry) {
		iobuffer_t *copy = iobuffer_clone(pkt);
		sp_svc_post(mgr->shell_svc, pos->mod_id, pos->svc_id, pkt_type, 0, &copy);
		if (copy)
			iobuffer_dec_ref(copy);
	}
	spinlock_leave(&mgr->entity_life_subscribe_lock);
}

static void mgr_on_entity_create(sp_mod_mgr_t *mgr, sp_entity_t *entity, int trigger_entity_id)
{
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I4, &entity->cfg->idx, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &trigger_entity_id, 0);
	mgr_bcast_entity_life_event(mgr, SP_PKT_MOD|MOD_CMD_RECORD_ENTITY_CREATE, pkt);
	iobuffer_dec_ref(pkt);
}

static void mgr_on_entity_close(sp_mod_mgr_t *mgr, sp_entity_t *entity, int trigger_entity_id, int cause_code)
{
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I4, &entity->cfg->idx, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &trigger_entity_id, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &cause_code, 0);
	mgr_bcast_entity_life_event(mgr, SP_PKT_MOD|MOD_CMD_RECORD_ENTITY_CLOSE, pkt);
	iobuffer_dec_ref(pkt);
}

static void mgr_on_entity_exception(sp_mod_mgr_t *mgr, sp_entity_t *entity, int trigger_entity_id, int error)
{
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I4, &entity->cfg->idx, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &error, 0);
	iobuffer_write(pkt, IOBUF_T_I4, &entity->state, 0);
	mgr_bcast_entity_life_event(mgr, SP_PKT_MOD|MOD_CMD_RECORD_ENTITY_EXCEPTION, pkt);
	iobuffer_dec_ref(pkt);
}

static int on_detect_process_end(process_monitor_t *monitor, HANDLE hproc, void *user_data)
{
	sp_mod_mgr_t *mgr = (sp_mod_mgr_t*)user_data;
	sp_mod_t *mod;
	list_for_each_entry(mod, &mgr->mod_list, sp_mod_t, entry) {
		if (mod->loaded && mod->process.handle == hproc) {
			sp_entity_t *ent;

#ifdef _WIN32
			sp_mod_mgr_lockEx(mod->cfg->idx);
#else
			sp_mod_mgr_lock(mgr);
#endif //_WIN32

			DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "detect process [mod=%s] exit", mod->cfg->name);	//no exit code
			process_close(&mod->process);
			mod->loaded = SP_MODULE_STATE_UNLOAD;
			list_for_each_entry(ent, &mod->entity_list, sp_entity_t, entry) {
				if (ent->state != EntityState_Killed && ent->state != EntityState_Close) { // 
					int last_state = ent->state;
					ent->state = EntityState_Lost;
					mgr_on_entity_state(mgr, ent, ent->cfg->idx, last_state, ent->state);
					mgr_on_entity_close(mgr, ent, ent->cfg->idx, CloseCause_Lost);
				}
			}
			SetEvent(mod->evt_app_exit);

#ifdef _WIN32
			sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
			sp_mod_mgr_unlock(mgr);
#endif //_WIN32

			break;
		}
	}

	return TRUE; // delete process handle
}

static void subscribe_entity_state(sp_mod_mgr_t *mgr, int mod_id, int svc_id, int target_entity_id)
{
	int found = 0;
	entity_state_subscribe_entry *pos;
	spinlock_enter(&mgr->entity_state_subscribe_lock, -1);
	list_for_each_entry(pos, &mgr->entity_state_subscribe_list, entity_state_subscribe_entry, entry) {
		if (pos->mod_id == mod_id && pos->svc_id == svc_id && pos->target_entity_id == target_entity_id) {
			found = TRUE;
			break;
		}
	}
	if (found) {
		pos->instance ++;
	} else {
		pos = MALLOC_T(entity_state_subscribe_entry);
		pos->instance = 1;
		pos->mod_id = mod_id;
		pos->svc_id = svc_id;
		pos->target_entity_id = target_entity_id;
		list_add_tail(&pos->entry, &mgr->entity_state_subscribe_list);
	}
	spinlock_leave(&mgr->entity_state_subscribe_lock);
}

static void unsubscribe_entity_state(sp_mod_mgr_t *mgr, int mod_id, int svc_id, int target_entity_id)
{
	int found = 0;
	entity_state_subscribe_entry *pos;
	spinlock_enter(&mgr->entity_state_subscribe_lock, -1);
	list_for_each_entry(pos, &mgr->entity_state_subscribe_list, entity_state_subscribe_entry, entry) {
		if (pos->mod_id == mod_id && pos->svc_id == svc_id && pos->target_entity_id == target_entity_id) {
			found = TRUE;
			break;
		}
	}
	if (found) {
		pos->instance--;
		if (pos->instance == 0) {
			list_del(&pos->entry);
			FREE(pos);
		}
	}
	spinlock_leave(&mgr->entity_state_subscribe_lock);
}

static void subscribe_entity_life(sp_mod_mgr_t *mgr, int mod_id, int svc_id)
{
	int found = 0;
	entity_life_subscribe_entry *pos;
	spinlock_enter(&mgr->entity_life_subscribe_lock, -1);
	list_for_each_entry(pos, &mgr->entity_life_subscribe_list, entity_life_subscribe_entry, entry) {
		if (pos->mod_id == mod_id && pos->svc_id == svc_id) {
			found = TRUE;
			break;
		}
	}
	if (found) {
		pos->instance ++;
	} else {
		pos = MALLOC_T(entity_life_subscribe_entry);
		pos->instance = 1;
		pos->mod_id = mod_id;
		pos->svc_id = svc_id;
		list_add_tail(&pos->entry, &mgr->entity_life_subscribe_list);
	}
	spinlock_leave(&mgr->entity_life_subscribe_lock);
}

static void unsubscribe_entity_life(sp_mod_mgr_t *mgr, int mod_id, int svc_id)
{
	int found = 0;
	entity_life_subscribe_entry *pos;
	spinlock_enter(&mgr->entity_life_subscribe_lock, -1);
	list_for_each_entry(pos, &mgr->entity_life_subscribe_list, entity_life_subscribe_entry, entry) {
		if (pos->mod_id == mod_id && pos->svc_id == svc_id ) {
			found = TRUE;
			break;
		}
	}
	if (found) {
		pos->instance--;
		if (pos->instance == 0) {
			list_del(&pos->entry);
			FREE(pos);
		}
	}
	spinlock_leave(&mgr->entity_life_subscribe_lock);
}

static void clear_entity_state(sp_mod_mgr_t *mgr, int mod_id)
{
	entity_state_subscribe_entry *pos, *n;
	spinlock_enter(&mgr->entity_state_subscribe_lock, -1);
	list_for_each_entry_safe(pos, n, &mgr->entity_state_subscribe_list, entity_state_subscribe_entry, entry) {
		if (pos->mod_id == mod_id) {
			list_del(&pos->entry);
			FREE(pos);
		}
	}
	spinlock_leave(&mgr->entity_state_subscribe_lock);
}
static void clear_entity_state_list_all(sp_mod_mgr_t *mgr)
{
	entity_state_subscribe_entry *pos, *n;
	spinlock_enter(&mgr->entity_state_subscribe_lock, -1);
	list_for_each_entry_safe(pos, n, &mgr->entity_state_subscribe_list, entity_state_subscribe_entry, entry) {
		list_del(&pos->entry);
		FREE(pos);
	}
	spinlock_leave(&mgr->entity_state_subscribe_lock);
}
static void clear_entity_life(sp_mod_mgr_t *mgr, int mod_id)
{
	entity_life_subscribe_entry *pos, *n;
	spinlock_enter(&mgr->entity_life_subscribe_lock, -1);
	list_for_each_entry_safe(pos, n, &mgr->entity_life_subscribe_list, entity_life_subscribe_entry, entry) {
		if (pos->mod_id == mod_id) {
			list_del(&pos->entry);
			FREE(pos);
		}		
	}
	spinlock_leave(&mgr->entity_life_subscribe_lock);
}
static void clear_entity_life_list_all(sp_mod_mgr_t *mgr)
{
	entity_life_subscribe_entry *pos, *n;
	spinlock_enter(&mgr->entity_life_subscribe_lock, -1);
	list_for_each_entry_safe(pos, n, &mgr->entity_life_subscribe_list, entity_life_subscribe_entry, entry) {
		list_del(&pos->entry);
		FREE(pos);
	}
	spinlock_leave(&mgr->entity_life_subscribe_lock);
}

static int mgr_on_pkt(sp_svc_t *svc,int epid, int svc_id, int pkt_type, int pkt_id, iobuffer_t **p_pkt, void *user_data)
{
	sp_mod_mgr_t *mgr = (sp_mod_mgr_t *)user_data;

	if (SP_GET_PKT_TYPE(pkt_type) == SP_PKT_MOD) {
		int result = pkt_id;
		int cmd_type = SP_GET_TYPE(pkt_type);
		sp_mod_t *mod;

		if (cmd_type == MOD_CMD_INIT || cmd_type == MOD_CMD_TERM) {		// not necessary {bug}
			list_for_each_entry(mod, &mgr->mod_list, sp_mod_t, entry) {
				if (mod->cfg->idx == epid) {
					if (mod->doing) {
						mod->wait_result = result;
						SetEvent(mod->evt_wait_handle);
					}
					break;
				}
			}
		} 
		else if (cmd_type == MOD_CMD_USER_STATE_EVENT)
		{
			int last_state, curr_state;
			sp_entity_t *entity = sp_mod_mgr_find_entity_by_idx(mgr, svc_id);
			iobuffer_read(*p_pkt, IOBUF_T_I4, &last_state, NULL);
			iobuffer_read(*p_pkt, IOBUF_T_I4, &curr_state, NULL);
			mgr_on_user_state(mgr, entity, last_state, curr_state);
		}
		else if (cmd_type == MOD_CMD_REPORT_CREATE_CONN) {
			sp_entity_t *entity_src = sp_mod_mgr_find_entity_by_idx(mgr, svc_id);
			sp_entity_t *entity_dst = sp_mod_mgr_find_entity_by_idx(mgr, pkt_id);
			if (entity_src && entity_dst)
				mgr_on_create_connection(mgr, entity_src, entity_dst);
		} else if (cmd_type == MOD_CMD_REPROT_CLOSE_CONN) {
			sp_entity_t *entity_src = sp_mod_mgr_find_entity_by_idx(mgr, svc_id);
			sp_entity_t *entity_dst = sp_mod_mgr_find_entity_by_idx(mgr, pkt_id);
			mgr_on_close_connection(mgr, entity_src, entity_dst);
		} else if (cmd_type == MOD_CMD_REPORT_EXCEPTION) {
			sp_entity_t *ent = sp_mod_mgr_find_entity_by_idx(mgr, svc_id);
			mgr_on_entity_exception(mgr, ent, ent->cfg->idx, Error_Exception);
		} else if (cmd_type == MOD_CMD_SWITCH_RUNNING_MODE) {
			// BugFix [4/3/2020 9:09 Gifur]
			sp_entity_t *ent = sp_mod_mgr_find_entity_by_idx(mgr, svc_id);
			int state = pkt_id;
			mod = sp_mod_mgr_find_module_by_idx(mgr, epid);
			if ((ent->state == EntityState_Idle || ent->state == EntityState_Busy) && state != ent->state) {
#ifdef _WIN32
				sp_mod_mgr_lockEx(mod->cfg->idx);
#else
				sp_mod_mgr_lock(mgr);
#endif //_WIN32
				if (ent->state == EntityState_Idle || ent->state == EntityState_Busy) {
					if (ent->state != state) {
						int old_state = ent->state;
						ent->state = state;
						mgr_on_entity_state(mgr, ent, ent->cfg->idx, old_state, state);
					}
				}
#ifdef _WIN32
				sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
				sp_mod_mgr_unlock(mgr);
#endif //_WIN32
			}
		} else if (cmd_type == MOD_CMD_SUBSCRIBE_STATE_LISTENER) {
			subscribe_entity_state(mgr, epid, svc_id, pkt_id);
		} else if (cmd_type == MOD_CMD_UNSUBSCRIBE_STATE_LISTENER) {
			unsubscribe_entity_state(mgr, epid, svc_id, pkt_id);
		} else if (cmd_type == MOD_CMD_SUBSCRIBE_LIFE_LISTENER) {
			subscribe_entity_life(mgr, epid, svc_id);
		} else if (cmd_type == MOD_CMD_UNSUBSCRIBE_LIFE_LISTENER) {
			unsubscribe_entity_life(mgr, epid, svc_id);
		} else if (cmd_type == MOD_CMD_ENT_RESULT) {
			sp_entity_t *ent = sp_mod_mgr_find_entity_by_idx(mgr, svc_id);
			if (ent->mod->doing) {
				ent->wait_result = result;
				SetEvent(ent->evt_wait_handle);
			}
		/** this for new for entity unit test, we need to know the exam result*/
		} else if (cmd_type == MOD_CMD_ENT_RESULT_EX) {
			sp_entity_t* ent = sp_mod_mgr_find_entity_by_idx(mgr, svc_id);
			if (ent->mod->doing) {
				unsigned int statistic = 0;
				iobuffer_read(*p_pkt, IOBUF_T_I4, &statistic, NULL);
				ent->wait_result = result;
				ent->result_param1 = statistic;
				SetEvent(ent->evt_wait_handle);
			}
		}
		else if (cmd_type == MOD_CMD_MOD_RESULT) {
			mod = sp_mod_mgr_find_module_by_idx(mgr, epid);
			if (mod->doing) {
				mod->wait_result = result;
				SetEvent(mod->evt_wait_handle);
			}
		} else if (cmd_type == MOD_CMD_REPORT_REDIRECT_SUBSCRIBE) {
			sp_uid_t uid;
			int suggest_entity_id;
			iobuffer_read(*p_pkt, IOBUF_T_I8, &uid, NULL);
			iobuffer_read(*p_pkt, IOBUF_T_I4, &suggest_entity_id, NULL);
			sp_bcm_daemon_process_redirect_subscribe(mgr->shell_daemon, svc_id, &uid, suggest_entity_id);
		} else {
			TOOLKIT_ASSERT(0);
		}

		return FALSE;
	}

	return TRUE;
}

static void mgr_on_sys(sp_svc_t *svc,int epid, int state, void *user_data)
{
	sp_mod_mgr_t *mgr = (sp_mod_mgr_t *)user_data;

	if (state == BUS_STATE_OFF) {
		clear_entity_state(mgr, epid);
		clear_entity_life(mgr, epid);
	}
}

int sp_mod_mgr_create(sp_mod_mgr_t **p_mgr)
{
	sp_mod_mgr_t *mgr = shm_malloc(sizeof(sp_mod_mgr_t));

	memset(mgr, 0, sizeof(sp_mod_mgr_t));
	InitializeCriticalSection(&mgr->lock);
	INIT_LIST_HEAD(&mgr->mod_list);
	process_monitor_create(&mgr->process_monitor);
	process_monitor_set_cb(mgr->process_monitor, &on_detect_process_end, mgr);
	spinlock_init(&mgr->entity_life_subscribe_lock);
	INIT_LIST_HEAD(&mgr->entity_life_subscribe_list);
	spinlock_init(&mgr->entity_state_subscribe_lock);
	INIT_LIST_HEAD(&mgr->entity_state_subscribe_list);
	mgr->arr_ent = shm_array_make(SP_MAX_ENTITY, sizeof(sp_entity_t*));
	mgr->arr_mod = shm_array_make(SP_MAX_MODULE, sizeof(sp_mod_t*));
	mgr->instance_seq = 0;
	mgr->shell_svc = NULL;
	mgr->shell_daemon = NULL;

	*p_mgr = mgr;

	return 0;
}

void sp_mod_mgr_destroy(sp_mod_mgr_t *mgr)
{
	TOOLKIT_ASSERT(list_empty(&mgr->mod_list));
	clear_entity_life_list_all(mgr);
	clear_entity_state_list_all(mgr);
	process_monitor_destroy(mgr->process_monitor);
#ifdef _WIN32
	ClearGroupProcessInfo();
#endif //_WIN32
	DeleteCriticalSection(&mgr->lock);
	shm_free(mgr);
}

void sp_mod_mgr_bind_shell_svc(sp_mod_mgr_t *mgr, sp_svc_t *svc)
{
	mgr->shell_svc = svc;
}

int sp_mod_mgr_add_module(sp_mod_mgr_t *mgr, sp_cfg_shell_module_t *cfg_mod)
{
	sp_mod_t *mod;

	TOOLKIT_ASSERT(mgr);

	mod = sp_mod_mgr_find_module_by_name(mgr, cfg_mod->name);
	if (!mod) {
		mod = shm_malloc(sizeof(sp_mod_t));
		mod->loaded = SP_MODULE_STATE_UNLOAD;
		mod->mgr = mgr;
		mod->cfg = cfg_mod;
		mod->doing = mod->closing = 0;
		mod->wait_result = 0;
		mod->start_time = 0;
		mod->evt_app_exit = CreateEventA(NULL, TRUE, TRUE, NULL);
		mod->evt_wait_handle = CreateEventA(NULL, TRUE, FALSE, NULL);
		process_init(&mod->process);
		INIT_LIST_HEAD(&mod->entity_list);
		list_add_tail(&mod->entry, &mgr->mod_list);
		ARRAY_IDX(mgr->arr_mod, cfg_mod->idx, sp_mod_t*) = mod;
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "module %s already exist!", cfg_mod->name);
		//return Error_Duplication;
	}

	return 0;
}

int sp_mod_mgr_add_entity(sp_mod_mgr_t *mgr, sp_cfg_shell_entity_t *cfg_ent)
{
	sp_mod_t *mod;
	sp_entity_t *ent;

	TOOLKIT_ASSERT(mgr);

	mod = sp_mod_mgr_find_module_by_name(mgr, cfg_ent->mod->name);
	if (mod) {
		ent = sp_mod_find_entity_by_name(mod, cfg_ent->name);
		if (!ent) {
			ent = shm_malloc(sizeof(sp_entity_t));
			ent->state = EntityState_NoStart;
			ent->mod = mod;
			ent->wait_result = 0;
			ent->result_param1 = ent->result_param2 = 0;
			ent->first_start_time = 0;
			ent->last_start_time = 0;
			ent->state_start_time = 0;
			ent->cfg = cfg_ent;
			ent->service_flag = 0;
			ent->evt_wait_handle = CreateEventA(NULL, TRUE, FALSE, NULL);
			ent->instance_id = 0;
			ent->user_state = 0;
			ent->last_err.sys_code = ent->last_err.usr_code = 0;
			memset(ent->last_err.msg, '\0', sizeof(ent->last_err.msg));
			list_add_tail(&ent->entry, &mod->entity_list);
			ARRAY_IDX(mgr->arr_ent, cfg_ent->idx, sp_entity_t*) = ent;
		} else {
			//return Error_Duplication;
		}
	} else {
		return Error_NotExist;
	}

	return 0;
}

int sp_mod_mgr_remove_module(sp_mod_mgr_t *mgr, const char *mod_name)
{
	sp_mod_t *mod;

	TOOLKIT_ASSERT(mgr);
	TOOLKIT_ASSERT(mod_name);

	mod = sp_mod_mgr_find_module_by_name(mgr, mod_name);
	if (mod) {
		TOOLKIT_ASSERT(mod->loaded == SP_MODULE_STATE_UNLOAD);
		TOOLKIT_ASSERT(list_empty(&mod->entity_list));
		list_del(&mod->entry);
		CloseHandle(mod->evt_app_exit);
		CloseHandle(mod->evt_wait_handle);
		shm_free(mod);
	} else {
		return Error_NotExist;
	}

	return 0;
}

int sp_mod_mgr_remove_entity(sp_mod_mgr_t *mgr, const char *entity_name)
{
	sp_entity_t *ent;

	TOOLKIT_ASSERT(mgr);
	TOOLKIT_ASSERT(entity_name);

	ent = sp_mod_mgr_find_entity_by_name(mgr, entity_name);
	if (ent) {
		list_del(&ent->entry);
		CloseHandle(ent->evt_wait_handle);
		shm_free(ent);
	} else {
		return Error_NotExist;
	}

	return 0;
}

int sp_mod_mgr_init(sp_mod_mgr_t *mgr)
{
	int rc;
	sp_mod_t *mod_pos;
	int existMod = mgr->arr_mod->nelts;
	mgr->arr_mod->nelts = mgr->arr_ent->nelts = 0;
	list_for_each_entry(mod_pos, &mgr->mod_list, sp_mod_t, entry) {	//遍历
		sp_entity_t *ent_pos;
		mgr->arr_mod->nelts++;
		list_for_each_entry(ent_pos, &mod_pos->entity_list, sp_entity_t, entry) {
			mgr->arr_ent->nelts++;
		}
	}
	if (existMod == 0)
		rc = sp_svc_add_pkt_handler(mgr->shell_svc, (int)mgr, SP_PKT_MOD, &mgr_on_pkt, mgr);
	else
		rc = 0;

	return rc;
}

void sp_mod_mgr_term(sp_mod_mgr_t *mgr)
{
	sp_svc_remove_pkt_handler(mgr->shell_svc, (int)mgr, SP_PKT_MOD);
	process_monitor_stop(mgr->process_monitor);
	mgr->arr_ent->nelts = 0;
	mgr->arr_mod->nelts = 0;
}

void sp_mod_mgr_bind_bcm_daemon(sp_mod_mgr_t *mgr, sp_bcm_daemon_t *daemon)
{
	mgr->shell_daemon = daemon;
}

void sp_mod_mgr_lock(sp_mod_mgr_t *mgr)
{
	EnterCriticalSection(&mgr->lock);
}

void sp_mod_mgr_unlock(sp_mod_mgr_t *mgr)
{
	LeaveCriticalSection(&mgr->lock);
}

sp_mod_t *sp_mod_mgr_find_module_by_name(sp_mod_mgr_t *mgr, const char *mod_name)
{
	sp_mod_t *mod;

	if (!mod_name)
		return NULL;

	list_for_each_entry(mod, &mgr->mod_list, sp_mod_t, entry) {
		if (_stricmp(mod_name, mod->cfg->name) == 0)
			return mod;
	}

	return NULL;
}

sp_mod_t *sp_mod_mgr_find_module_by_idx(sp_mod_mgr_t *mgr, int mod_idx)
{
	if (mod_idx == -1 || mod_idx >= mgr->arr_mod->nelts)
		return NULL;
	
	return ARRAY_IDX(mgr->arr_mod, mod_idx, sp_mod_t*);
}

sp_entity_t *sp_mod_find_entity_by_name(sp_mod_t *mod, const char *entity_name)
{
	sp_entity_t *ent;

	if (!entity_name)
		return NULL;

	list_for_each_entry(ent, &mod->entity_list, sp_entity_t, entry) {
		if (_stricmp(ent->cfg->name, entity_name) == 0)
			return ent;
	}

	return NULL;
}

sp_entity_t *sp_mod_find_entity_by_idx(sp_mod_t *mod, int entity_idx)
{
	if (entity_idx == -1 || entity_idx >= mod->mgr->arr_ent->nelts)
		return NULL;

	return ARRAY_IDX(mod->mgr->arr_ent, entity_idx, sp_entity_t*);
}

sp_entity_t *sp_mod_find_entity_by_devel_id(sp_mod_t *mod, int devel_id)
{
	sp_entity_t *ent;

	list_for_each_entry(ent, &mod->entity_list, sp_entity_t, entry) {
		if (ent->cfg->devel_id == devel_id)
			return ent;
	}

	return NULL;
}

sp_entity_t *sp_mod_find_entity_by_inst_id(sp_mod_t *mod, int inst_id)
{
	sp_entity_t *ent;

	list_for_each_entry(ent, &mod->entity_list, sp_entity_t, entry) {
		if (ent->instance_id == inst_id)
			return ent;
	}

	return NULL;
}

void sp_mod_supress_last_err_for_all_entity(sp_mod_t* mod, const char* err_msg)
{
    sp_entity_t* ent;
	if (err_msg != NULL && strlen(err_msg) > 0) {
        list_for_each_entry(ent, &mod->entity_list, sp_entity_t, entry)
        {
            ent->last_err.sys_code = (uint32_t)0x300; /*Error_InvalidState*/
            ent->last_err.usr_code = 0;
			strcpy_s(ent->last_err.msg, SP_ENTITY_ERRMSG_MAX_LEN, err_msg);
        }
	}
}

sp_entity_t *sp_mod_mgr_find_entity_by_name(sp_mod_mgr_t *mgr, const char *entity_name)
{
	sp_mod_t *mod;

	if (!entity_name)
		return NULL;

	list_for_each_entry(mod, &mgr->mod_list, sp_mod_t, entry) {
		sp_entity_t *ent = sp_mod_find_entity_by_name(mod, entity_name);
		if (ent)
			return ent;
	}

	return NULL;
}

sp_entity_t *sp_mod_mgr_find_entity_by_idx(sp_mod_mgr_t *mgr, int entity_id)
{
	if (entity_id == -1 || entity_id >= mgr->arr_ent->nelts)
		return NULL;

	return ARRAY_IDX(mgr->arr_ent, entity_id, sp_entity_t*);
}

sp_entity_t *sp_mod_mgr_find_entity_by_devel_id(sp_mod_mgr_t *mgr, int devel_id)
{
	int i;

	for (i = 1; i < mgr->arr_ent->nelts; ++i) {
		sp_entity_t *ent = ARRAY_IDX(mgr->arr_ent, i, sp_entity_t*);
		if (ent->cfg->devel_id == devel_id)
			return ent;
	}

	return NULL;
}

sp_entity_t *sp_mod_mgr_find_entity_by_inst_id(sp_mod_mgr_t *mgr, int inst_id)
{
	int i;

	for (i = 1; i < mgr->arr_ent->nelts; ++i) {
		sp_entity_t *ent = ARRAY_IDX(mgr->arr_ent, i, sp_entity_t*);
		if (ent->instance_id == inst_id)
			return ent;
	}

	return NULL;
}

struct list_head* sp_mod_mgr_get_module_list_head(sp_mod_mgr_t *mgr)
{
	return &mgr->mod_list;
}

int sp_mod_mgr_get_entity_array_nelts(sp_mod_mgr_t *mgr)
{
	return mgr->arr_ent->nelts;
}

static int try_lock_doing(sp_mod_mgr_t *mgr, sp_mod_t *mod)
{
	int ok = FALSE;
#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32
	if (!mod->doing) {
		mod->doing = 1;
		ok = TRUE;
	}
#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32
	return ok;
}

static void unlock_doing(sp_mod_mgr_t *mgr, sp_mod_t *mod)
{
#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32
	mod->doing = 0;
#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32
}

static int load_module(sp_mod_mgr_t *mgr, sp_mod_t *mod, int trigger_entity_id, int entity_id)
{
	int rc = 0;
	sp_env_t *env = sp_get_env();
	addStartupStep(mod->cfg->idx, "begin_load", "", 0, 0, 0);

#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32
	if (!mod->loaded) {
		ResetEvent(mod->evt_app_exit);
		if (0 != create_module_process(mod->cfg->name, mod->cfg->idx, env->shm_range, mod->cfg->debugFileExist, &mod->process, mod->cfg->runType, entity_id)) {
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "sp_mod_mgr_load_module %s failed! create module process failed", mod->cfg->name);
			rc = Error_Unexpect;
		} else {
			DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "create module process succ, pid: %d", mod->process.pid);
		}
	} else {
		rc = Error_Duplication;
	}
#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32

	if (rc == 0) {
		const int interval = 50; //consider sleep operation below, here would consume 4 min at terriable situation.
		const int tries = PROCESS_TIMEOUT / interval;
		int i;

		ResetEvent(mod->evt_wait_handle);
		DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "get remote entitiy state...");
		for (i = 0; i < tries; ++i) {
			int state = BUS_STATE_OFF;
			rc = sp_svc_get_state(mgr->shell_svc, mod->cfg->idx, &state);
			WLog_DBG(TAG, "cfg::idx: %d, state: %d", mod->cfg->idx, state);
			if (rc == 0) 
			{
				if (state != BUS_STATE_ON) {
					DWORD dwRet;
					dwRet = WaitForSingleObject(mod->process.handle, (DWORD)interval);	//wait for entity thread end
					if (dwRet == WAIT_OBJECT_0) {
						addStartupStep(mod->cfg->idx, "mod_online", "process exit exception!", 0, 0, Error_Exception);
						rc = Error_Exception;
						break;
					}
				} else {
					addStartupStep(mod->cfg->idx, "mod_online", "", 0, 0, 0);
					break;
				}
			} 
			else 
			{
				addStartupStep(mod->cfg->idx, "mod_online", "get epid state failed!", 0, 0, Error_Exception);
				break;
			}
		}

		if (rc == 0)
			rc = sp_svc_send(mgr->shell_svc, mod->cfg->idx, SP_INVALID_SVC_ID, SP_PKT_MOD|MOD_CMD_INIT, 0, NULL);
		if (rc) {
			addStartupStep(mod->cfg->idx, "send_init", "failed", 0, 0, rc);
		} else {
			addStartupStep(mod->cfg->idx, "send_init", "", 0, 0, 0);
			for (i = 0; i < tries; ++i) {
#ifdef _WIN32
				HANDLE hs[] = { mod->evt_wait_handle, mod->process.handle };	//wait for entity thread end
				DWORD dwRet = WaitForMultipleObjects(array_size(hs), &hs[0], FALSE, (DWORD)interval);
#else
				DWORD dwRet = WaitForSingleObject(mod->evt_wait_handle, (DWORD)interval);
				if (dwRet == WAIT_TIMEOUT) {
					dwRet = WaitForSingleObject(mod->process.handle, 0);
					if (dwRet == WAIT_OBJECT_0) {
						dwRet = WAIT_OBJECT_0 + 1;
					}
				}
#endif //_WIN32
				if (dwRet == WAIT_OBJECT_0) {
					addStartupStep(mod->cfg->idx, "entity_reply", "", 0, 0, 0);
					rc = mod->wait_result;
					if (rc != 0) {
						addStartupStep(mod->cfg->idx, "entity_reply", "failed", 0, 0, rc);
					}
					break;
				} else if (dwRet == WAIT_OBJECT_0+1) {
					addStartupStep(mod->cfg->idx, "entity_reply", "process end", 0, 0, Error_Exception);
					rc = Error_Exception;
					break;
				} else if(dwRet == WAIT_TIMEOUT) {
					addStartupStep(mod->cfg->idx, "entity_reply", "timeout", 0, 0, Error_TimeOut);
					rc = Error_TimeOut;
				}
				else {
					addStartupStep(mod->cfg->idx, "entity_reply", "multi obj", 0, 0, Error_Unexpect);
					rc = Error_Unexpect;
					break;
				}
			}
		}
	}

#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32
	if (rc == 0) {
		mod->loaded = SP_MODULE_STATE_LOAD;
		mod->start_time = y2k_time_now();
		process_monitor_add(mgr->process_monitor, &mod->process);
		DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "load module ok! start time = %d, state = LOADED", mod->start_time);
	} else {
		DWORD result = 0;
		mod_kill_process(mod);
		result = WaitForSingleObject(mod->process.handle, PROCESS_EXIT_TIMEOUT);
		process_close(&mod->process);
        DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "load module %s failed! 0x%x, 0x%x", mod->cfg->name, rc, result);
	}
#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32

	return rc;
}

static int unload_module(sp_mod_mgr_t *mgr, sp_mod_t *mod, int trigger_entity_id)
{
	int rc = 0;
	sp_entity_t *pos;

#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32

	if (mod->loaded) {
		list_for_each_entry(pos, &mod->entity_list, sp_entity_t, entry) {
			if (pos->state != EntityState_Killed && 
				pos->state != EntityState_Close && pos->state != EntityState_NoStart) {
					DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "unload %s module, has entity in normal state!", mod->cfg->name);
					rc = Error_Bug;
					break;
			}
		}
		if (rc == 0) {
			ResetEvent(mod->evt_wait_handle);
			rc = sp_svc_send(mod->mgr->shell_svc, mod->cfg->idx, SP_INVALID_SVC_ID, SP_PKT_MOD|MOD_CMD_TERM, 0, NULL);
			if (rc == 0) {
				DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "unload %s module, send pkt cmd ok!", mod->cfg->name);
			} else  {
				DbgWithLinkForC(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM, "unload %s module, send pkt cmd failed: %d!", mod->cfg->name, rc);
			}
		}
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "module %s already unloaded!", mod->cfg->name);
		rc = Error_InvalidState;
	}

#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32

	if (rc == 0) {
		int removed = 0;
		/*TODO: the clear job depend on different result seems no different.*/
		for (;;) {
			HANDLE hs[] = {mod->evt_app_exit, mod->evt_wait_handle};
			DWORD dwRet = WaitForMultipleObjects(array_size(hs), &hs[0], FALSE, PROCESS_TIMEOUT_FOR_TERMINAL);
			if (dwRet == WAIT_OBJECT_0) { // app exit
				DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "module %s app exit", mod->cfg->name);
				break;
			} else if (dwRet == WAIT_OBJECT_0+1) {
				ResetEvent(mod->evt_wait_handle);
                DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "module %s wait handle received, wait result: %d", mod->cfg->name, mod->wait_result);
				if (mod->wait_result != 0) {
					HANDLE hprocess = mod->process.handle;
					if (hprocess && process_monitor_remove(mgr->process_monitor, &mod->process) == 0) {
						DWORD result;
						removed = 1;
						mod_kill_process(mod);
						result = WaitForSingleObject(mod->process.handle, PROCESS_EXIT_TIMEOUT);
						process_close(&mod->process);
						break;
					} //TODO: 
				} else {
					HANDLE hprocess = mod->process.handle;
					if (hprocess && process_monitor_remove(mgr->process_monitor, &mod->process) == 0) {
						DWORD tmp;
						removed = 1;
						tmp = WaitForSingleObject(hprocess, PROCESS_EXIT_TIMEOUT);
						if (tmp == WAIT_TIMEOUT) {
							DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "wait process %s(%d) normal exit timeout!", mod->cfg->name, mod->process.pid);
							mod_kill_process(mod);
							WaitForSingleObject(mod->process.handle, PROCESS_EXIT_TIMEOUT);
						}
						process_close(&mod->process);
						break;
					}
				}
			} else {
				HANDLE hprocess;
				DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "wait unexpect: %u", dwRet);
				hprocess = mod->process.handle;
				if (hprocess && process_monitor_remove(mgr->process_monitor, &mod->process) == 0) {
					removed = 1;
					mod_kill_process(mod);
					WaitForSingleObject(mod->process.handle, PROCESS_EXIT_TIMEOUT);
					process_close(&mod->process);
					break;
				}
			}
		}

#ifdef _WIN32
		sp_mod_mgr_lockEx(mod->cfg->idx);
#else
		sp_mod_mgr_lock(mgr);
#endif //_WIN32
		if (removed) {
			DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "set mod %s unload state  line: %d", mod->cfg->name, __LINE__);
			mod->loaded = SP_MODULE_STATE_UNLOAD;
			SetEvent(mod->evt_app_exit);
		}
#ifdef _WIN32
		sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
		sp_mod_mgr_unlock(mgr);
#endif //_WIN32

	}
	return rc;
}


/*remove from monitor and kill it directory!!*/
static int terminate_module(sp_mod_mgr_t *mgr, sp_mod_t *mod, int trigger_entity_id)
{
	int rc = 0;
	sp_entity_t *pos;

#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32

	if (mod->loaded) {
        DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "%s: %s by entity %d", __FUNCTION__, mod->cfg->name, trigger_entity_id);
		if (mod->process.handle) {
			if (process_monitor_remove(mgr->process_monitor, &mod->process) == 0) {
				DWORD result;
				mod_kill_process(mod);
				result = WaitForSingleObject(mod->process.handle, PROCESS_EXIT_TIMEOUT);
				DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "mod %s 's process removed now! %u", mod->cfg->name, result);
				process_close(&mod->process);
				mod->loaded = SP_MODULE_STATE_UNLOAD;
				list_for_each_entry(pos, &mod->entity_list, sp_entity_t, entry) {
					int old_state = pos->state;
					if (old_state != EntityState_Close && old_state != EntityState_Killed) {
						pos->state = EntityState_Killed;
						mgr_on_entity_state(mgr, pos, trigger_entity_id, old_state, pos->state);
						mgr_on_entity_close(mgr, pos, trigger_entity_id, CloseCause_Lost);
					}
				}
				SetEvent(mod->evt_app_exit);
			} else {
				DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "mod %s is remove monitor failed!", mod->cfg->name);
				rc = -1;
			}
		} else {
			list_for_each_entry(pos, &mod->entity_list, sp_entity_t, entry) {
				if (pos->state != EntityState_Killed && pos->state != EntityState_Close) {
					int old_state = pos->state;
					pos->state = EntityState_Killed;
					mgr_on_entity_state(mgr, pos, trigger_entity_id, old_state, pos->state);
					mgr_on_entity_close(mgr, pos, trigger_entity_id, CloseCause_Lost);
				}
			}
			DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "set mod %s unload state  line: %d", mod->cfg->name, __LINE__);
			mod->loaded = SP_MODULE_STATE_UNLOAD;
		}
	} else {
		list_for_each_entry(pos, &mod->entity_list, sp_entity_t, entry) {
			if (pos->state != EntityState_Killed && pos->state != EntityState_Close && pos->state != EntityState_NoStart) {
				int old_state = pos->state;
				pos->state = EntityState_Killed;
				mgr_on_entity_state(mgr, pos, trigger_entity_id, old_state, pos->state);
				mgr_on_entity_close(mgr, pos, trigger_entity_id, CloseCause_Lost);
			}
		}
	}
#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32
	WLog_DBG(TAG, "terminal module %s turned out: %d", mod->cfg->name, rc);
	return rc;
}

static int start_entity(sp_mod_mgr_t *mgr, sp_entity_t *ent, const char *cmdline, int trigger_entity_id)
{
	int rc = 0;
	sp_mod_t *mod = ent->mod;

	addStartupLog(mod->cfg->name, mod->cfg->idx);
	
#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32
	if (mod->loaded) {
		if (ent->state == EntityState_NoStart || ent->state == EntityState_Killed || ent->state == EntityState_Close) {
			iobuffer_t *pkt = iobuffer_create(-1, -1);
			iobuffer_write(pkt, IOBUF_T_STR, cmdline, -1);
			iobuffer_write(pkt, IOBUF_T_I4, &trigger_entity_id, 0);
			ResetEvent(ent->evt_wait_handle);
			ent->instance_id = mgr_new_instance_id(mgr);
			rc = sp_svc_send(mgr->shell_svc, mod->cfg->idx, ent->cfg->idx, SP_PKT_MOD|MOD_CMD_START, ent->cfg->idx, &pkt);
			if (rc == 0) {
				int last_state = ent->state;
				addStartupStep(mod->cfg->idx, "send_start", "", 0, 0, 0);
				ent->state_start_time = y2k_time_now();
				if (ent->first_start_time == 0)
					ent->first_start_time = ent->state_start_time;
				ent->last_start_time = ent->state_start_time;
				ent->state = EntityState_Starting;
				mgr_on_entity_state(mgr, ent, trigger_entity_id, last_state, ent->state);
			} else {
				addStartupStep(mod->cfg->idx, "send_start", "failed", 0, 0, Error_Unexpect);
			}
			if (pkt)
				iobuffer_dec_ref(pkt);
		} else {
			rc = Error_InvalidState;
			addStartupStep(mod->cfg->idx, "send_start", "state is not correct", 0, 0, Error_InvalidState);
		}
	} else {
		addStartupStep(mod->cfg->idx, "send_start", "module is not load", 0, 0, Error_InvalidState);
		rc = Error_InvalidState;
	}
#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32

	if (rc == 0) {
		int last_state = ent->state;
		HANDLE hs[] = {mod->evt_app_exit, ent->evt_wait_handle};
		DWORD dwRet = WaitForMultipleObjects(array_size(hs), &hs[0], FALSE, PROCESS_TIMEOUT);
		if (dwRet == WAIT_OBJECT_0) {
			addStartupStep(mod->cfg->idx, "wait_result", "app exit", 0, 0, Error_Unexpect);
			rc = Error_Unexpect;
		} else if (dwRet == WAIT_OBJECT_0+1) {
			addStartupStep(mod->cfg->idx, "wait_result", "", 0, 0, 0);
			rc = ent->wait_result;
			if (rc != 0) {
				addStartupStep(mod->cfg->idx, "wait_result", "turned out result", 0, 0, ent->wait_result);
			}
		} else {
			addStartupStep(mod->cfg->idx, "wait_result", "timeout", 0, 0, Error_TimeOut);
			rc = Error_TimeOut;
		}

#ifdef _WIN32
		sp_mod_mgr_lockEx(mod->cfg->idx);
#else
		sp_mod_mgr_lock(mgr);
#endif //_WIN32

		if (rc == 0) {
			ent->state = EntityState_Idle;
			ent->state_start_time = y2k_time_now();
			mgr_on_entity_create(mgr, ent, trigger_entity_id);
		} else {
			ent->state = EntityState_Lost;
			ent->state_start_time = y2k_time_now();
			mgr_on_entity_exception(mgr, ent, trigger_entity_id, Error_Exception);
		}
		mgr_on_entity_state(mgr, ent, trigger_entity_id, last_state, ent->state);
#ifdef _WIN32
		sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
		sp_mod_mgr_unlock(mgr);
#endif //_WIN32
	}

	return rc;
}

static int stop_entity(sp_mod_mgr_t *mgr, sp_entity_t *ent, int trigger_entity_id, int cause_code)
{
	int rc = 0;
	sp_mod_t *mod = ent->mod;

#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32
	if (mod->loaded) {//judge module state
		if (ent->state == EntityState_Busy || ent->state == EntityState_Idle || ent->state == EntityState_Pause) {
			iobuffer_t *body = iobuffer_create(-1, -1);
			ResetEvent(ent->evt_wait_handle);
			iobuffer_write(body, IOBUF_T_I4, &trigger_entity_id, 0);
			iobuffer_write(body, IOBUF_T_I4, &cause_code, 0);
			rc = sp_svc_send(mgr->shell_svc, mod->cfg->idx, ent->cfg->idx, SP_PKT_MOD|MOD_CMD_STOP, ent->cfg->idx, &body);
			if (rc == 0) {
				int last_state = ent->state;
				DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "stop entity %s, send cmd stop ok!", ent->cfg->name);
				ent->state = EntityState_UnLoading;
				ent->state_start_time = y2k_time_now();
				mgr_on_entity_state(mgr, ent, trigger_entity_id, last_state, ent->state);
			} else {
				DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "stop entity %s, send cmd stop failed!", ent->cfg->name);
			}
			if (body)
				iobuffer_dec_ref(body);
		} else {
			rc = Error_InvalidState;
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "entity %s state is not correct for stop! state: %d", ent->cfg->name, ent->state);
		}
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "%s's mod %s has been unloaded!", ent->cfg->name, mod->cfg->name);
		rc = Error_InvalidState;
	}
#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32

	if (rc == 0) {
		int last_state = ent->state;
		HANDLE hs[] = {mod->evt_app_exit, ent->evt_wait_handle};
		DWORD dwRet = WaitForMultipleObjects(array_size(hs), &hs[0], FALSE, PROCESS_TIMEOUT_FOR_TERMINAL); //20secs at uos
		if (dwRet == WAIT_OBJECT_0) {
			DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "wait for stop entity %s result, app exit!", ent->cfg->name);
			rc = Error_Unexpect;
		} else if (dwRet == WAIT_OBJECT_0+1) {
			DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "wait for stop entity %s result ok, result = %d!", ent->cfg->name, ent->wait_result);
			rc = ent->wait_result;
		} else if(dwRet == WAIT_TIMEOUT){
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "wait for stop entity %s timeout!", ent->cfg->name);
			rc = Error_TimeOut;
		} else {
            DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "wait for stop entity %s failed: %u!", ent->cfg->name, dwRet);
            rc = Error_Unexpect;
		}

#ifdef _WIN32
		sp_mod_mgr_lockEx(mod->cfg->idx);
#else
		sp_mod_mgr_lock(mgr);
#endif //_WIN32
		if (rc == 0) {
			ent->state = EntityState_Close;
			ent->state_start_time = y2k_time_now();
			mgr_on_entity_close(mgr, ent, trigger_entity_id, trigger_entity_id != ent->cfg->idx ? CloseCause_Other : CloseCause_Self);
		} else {
			ent->state = EntityState_Lost;
			ent->state_start_time = y2k_time_now();
			mgr_on_entity_exception(mgr, ent, trigger_entity_id, Error_Exception);
		}
		mgr_on_entity_state(mgr, ent, trigger_entity_id, last_state, ent->state);
#ifdef _WIN32
		sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
		sp_mod_mgr_unlock(mgr);
#endif //_WIN32
	}

	return rc;
}

static int pause_entity(sp_mod_mgr_t *mgr, sp_entity_t *ent, int trigger_entity_id)
{
	int rc = 0;
	sp_mod_t *mod;

	mod = ent->mod;
#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32
	if (mod->loaded) {
		if (ent->state == EntityState_Busy || ent->state == EntityState_Idle) {
			iobuffer_t *body = iobuffer_create(-1, -1);
			ResetEvent(ent->evt_wait_handle);
			iobuffer_write(body, IOBUF_T_I4, &trigger_entity_id, 0);
			rc = sp_svc_send(mgr->shell_svc, mod->cfg->idx, ent->cfg->idx, SP_PKT_MOD|MOD_CMD_PAUSE, ent->cfg->idx, &body);
			if (rc == 0) {
				DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "pause entity %s, send cmd pause ok!", ent->cfg->name);
			} else {
				DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "pause entity %s, send cmd pause failed!", ent->cfg->name);
			}
			if (body) 
				iobuffer_dec_ref(body);
		} else {
			rc = Error_InvalidState;
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "%s: entity %s state is not correct! current state: %d", __FUNCTION__, ent->cfg->name, (int)ent->state);
		}
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "%s: entity's %s mod %s is not load!", __FUNCTION__, ent->cfg->name, mod->cfg->name);
		rc = Error_InvalidState;
	}
#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32

	if (rc == 0) {
		HANDLE hs[] = {mod->evt_app_exit, ent->evt_wait_handle};
		DWORD dwRet = WaitForMultipleObjects(array_size(hs), &hs[0], FALSE, PROCESS_TIMEOUT);
		if (dwRet == WAIT_OBJECT_0) {
			DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "wait for pause entity %s result, app exit!", ent->cfg->name);
			rc = Error_Unexpect;
		} else if (dwRet == WAIT_OBJECT_0+1) {
			DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "wait for pause entity %s result ok, result = %d!", ent->cfg->name, ent->wait_result);
			rc = ent->wait_result;
		} else {
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "wait for pause entity %s timeout!", ent->cfg->name);
			rc = Error_TimeOut;
		}
#ifdef _WIN32
		sp_mod_mgr_lockEx(mod->cfg->idx);
#else
		sp_mod_mgr_lock(mgr);
#endif //_WIN32
		if (rc == 0) {
			int last_state = ent->state;
			ent->state = EntityState_Pause;
			ent->state_start_time = y2k_time_now();
			mgr_on_entity_state(mgr, ent, trigger_entity_id, last_state, ent->state);
		}
#ifdef _WIN32
		sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
		sp_mod_mgr_unlock(mgr);
#endif //_WIN32
	}

	return rc;
}

static int continue_entity(sp_mod_mgr_t *mgr, sp_entity_t *ent, int trigger_entity_id)
{
	int rc = 0;
	sp_mod_t*mod;

	mod = ent->mod;
#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32
	if (mod->loaded) {
		if (ent->state == EntityState_Pause) {
			iobuffer_t *body = iobuffer_create(-1, -1);
			ResetEvent(ent->evt_wait_handle);
			iobuffer_write(body, IOBUF_T_I4, &trigger_entity_id, 0);
			rc = sp_svc_send(mgr->shell_svc, mod->cfg->idx, ent->cfg->idx, SP_PKT_MOD|MOD_CMD_CONTINUE, ent->cfg->idx, &body);
			if (rc == 0) {
				DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "continue entity %s, send cmd continue ok!", ent->cfg->name);
			} else {
				DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "continue entity %s, send cmd continue failed!", ent->cfg->name);
			}
			if (body) 
				iobuffer_dec_ref(body);
		} else {
			rc = Error_InvalidState;
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "%s: entity %s state is not correct! current state: %d", __FUNCTION__, ent->cfg->name, (int)ent->state);
		}
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "%s: entity's %s mod %s is not load!", __FUNCTION__, ent->cfg->name, mod->cfg->name);
		rc = Error_InvalidState;
	}
#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32
	if (rc == 0) {
		HANDLE hs[] = {mod->evt_app_exit, ent->evt_wait_handle};
		DWORD dwRet = WaitForMultipleObjects(array_size(hs), &hs[0], FALSE, PROCESS_TIMEOUT);
		if (dwRet == WAIT_OBJECT_0) {
			DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "wait for continue entity %s result, app exit!", ent->cfg->name);
			rc = Error_Unexpect;
		} else if (dwRet == WAIT_OBJECT_0+1) {
			DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "wait for continue entity %s result ok, result = %d!", ent->cfg->name, ent->wait_result);
			rc = ent->wait_result;
		} else {
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "wait for continue entity %s timeout!", ent->cfg->name);
			rc = Error_TimeOut;
		}

#ifdef _WIN32
		sp_mod_mgr_lockEx(mod->cfg->idx);
#else
		sp_mod_mgr_lock(mgr);
#endif //_WIN32
		if (rc == 0) {
			ent->state = EntityState_Idle;
			ent->state_start_time = y2k_time_now();
			mgr_on_entity_state(mgr, ent, trigger_entity_id, EntityState_Pause, ent->state);
		}
#ifdef _WIN32
		sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
		sp_mod_mgr_unlock(mgr);
#endif //_WIN32
	}

	return rc;
}

static int test_entity(sp_mod_mgr_t *mgr, sp_entity_t *ent, int test_type, int trigger_entity_id, int* result)
{
	int rc = 0;
	sp_mod_t *mod;

	mod = ent->mod;
#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32
	if (mod->loaded) {
		if (ent->state == EntityState_Idle || ent->state == EntityState_Busy || ent->state == EntityState_Pause) {
			iobuffer_t *body = iobuffer_create(-1, -1);
			ResetEvent(ent->evt_wait_handle);
			iobuffer_write(body, IOBUF_T_I4, &trigger_entity_id, 0);
			iobuffer_write(body, IOBUF_T_I4, &test_type, 0);
			rc = sp_svc_send(mgr->shell_svc, mod->cfg->idx, ent->cfg->idx, SP_PKT_MOD|MOD_CMD_TEST, ent->cfg->idx, &body);
			if (rc == 0) {
				//DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "test entity %s, send cmd test ok!", ent->cfg->name);
			} else {
				DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "test entity %s, send cmd test failed!", ent->cfg->name);
			}
			if (body) 
				iobuffer_dec_ref(body);
		} else {
			rc = Error_InvalidState;
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "%s: entity %s state is not correct! current state: %d", __FUNCTION__, ent->cfg->name, ent->state);
		}
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "%s: entity's %s mod %s is not load!", __FUNCTION__, ent->cfg->name, mod->cfg->name);
		rc = Error_InvalidState;
	}
#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32

	if (rc == 0) {
		HANDLE hs[] = {mod->evt_app_exit, ent->evt_wait_handle};
		DWORD dwRet = WaitForMultipleObjects(array_size(hs), &hs[0], FALSE, ENTITY_TEST_TIMEOUT);
		if (dwRet == WAIT_OBJECT_0) {
			DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "wait for test entity %s result, app exit!", ent->cfg->name);
			rc = Error_Unexpect;
		} else if (dwRet == WAIT_OBJECT_0+1) {
            rc = ent->wait_result;
			if (rc != 0) {
				DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "wait for test entity %s result = %s!", ent->cfg->name, sp_strerror(rc));
			}
			if (result) *result = ent->result_param1;
		} else {
			DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "wait for test entity %s timeout!", ent->cfg->name);
			rc = Error_TimeOut;
		}
	}

	return rc;
}

int sp_mod_mgr_start_entity(sp_mod_mgr_t *mgr, int entity_id, const char *cmdline, int trigger_entity_id)
{
	sp_entity_t *ent;
	ent = sp_mod_mgr_find_entity_by_idx(mgr, entity_id);
	if (!ent)
		return Error_NotExist;
	return sp_mod_mgr_start_entity2(mgr, ent, cmdline, trigger_entity_id, entity_id);
}

int sp_mod_mgr_stop_entity(sp_mod_mgr_t *mgr, int entity_id, int trigger_entity_id, int cause_code)
{
	sp_entity_t *ent;
	ent = sp_mod_mgr_find_entity_by_idx(mgr, entity_id);
	if (!ent)
		return Error_NotExist;
	return sp_mod_mgr_stop_entity2(mgr, ent, trigger_entity_id, cause_code);
}

int sp_mod_mgr_terminate_entity(sp_mod_mgr_t *mgr, int entity_id, int trigger_entity_id)
{
	sp_entity_t *ent;
	ent = sp_mod_mgr_find_entity_by_idx(mgr, entity_id);
	if (!ent) 
		return Error_NotExist;
	return sp_mod_mgr_terminate_entity2(mgr, ent, trigger_entity_id);
}

int sp_mod_mgr_pause_entity(sp_mod_mgr_t *mgr, int entity_id, int trigger_entity_id)
{
	sp_entity_t *ent;
	ent = sp_mod_mgr_find_entity_by_idx(mgr, entity_id);
	if (!ent) 
		return Error_NotExist;
	return sp_mod_mgr_pause_entity2(mgr, ent, trigger_entity_id);
}

int sp_mod_mgr_continue_entity(sp_mod_mgr_t *mgr, int entity_id, int trigger_entity_id)
{
	sp_entity_t *ent;
	ent = sp_mod_mgr_find_entity_by_idx(mgr, entity_id);
	if (!ent) 
		return Error_NotExist;
	return sp_mod_mgr_continue_entity2(mgr, ent, trigger_entity_id);
}

int sp_mod_mgr_test_entity(sp_mod_mgr_t *mgr, int entity_id, int trigger_entity_id, int test_type, int* cause)
{
	sp_entity_t *ent;
	ent = sp_mod_mgr_find_entity_by_idx(mgr, entity_id);
	if (!ent) 
		return Error_NotExist;
	return sp_mod_mgr_test_entity2(mgr, ent, trigger_entity_id, test_type, cause);
}

int sp_mod_mgr_lost_entity(sp_mod_mgr_t *mgr, int entity_id, int trigger_entity_id)
{
	sp_entity_t *ent;
	sp_mod_t *mod;
	ent = sp_mod_mgr_find_entity_by_idx(mgr, entity_id);
	if (!ent)
		return Error_NotExist;

	mod = ent->mod;
#ifdef _WIN32
	sp_mod_mgr_lockEx(mod->cfg->idx);
#else
	sp_mod_mgr_lock(mgr);
#endif //_WIN32
	if (mod->loaded) {
		const int last_state = ent->state;
		DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "set entity %s lost ok!", ent->cfg->name);
		
		ent->state = EntityState_Lost;
		mgr_on_entity_state(mgr, ent, ent->cfg->idx, last_state, ent->state);
	}

#ifdef _WIN32
	sp_mod_mgr_unlockEx(mod->cfg->idx);
#else
	sp_mod_mgr_unlock(mgr);
#endif //_WIN32
	return Error_Succeed;
}

int sp_mod_mgr_terminate_all_entity(sp_mod_mgr_t* mgr, int trigger_entity_id)
{
	int i;
	int rc = 0;
	TOOLKIT_ASSERT(mgr);
	for (i = 1; i < mgr->arr_ent->nelts; ++i) {
		int res;
		sp_entity_t* ent = ARRAY_IDX(mgr->arr_ent, i, sp_entity_t*);
		res = sp_mod_mgr_terminate_entity2(mgr, ent, trigger_entity_id);
		if (res != 0)
			rc = res;
	}
	return rc;
}

int sp_mod_mgr_start_entity2(sp_mod_mgr_t *mgr, sp_entity_t *ent, const char *cmdline, int trigger_entity_id, int entity_id)
{
	int rc = 0;
	ULONGLONG curTickCount;
	
	if (!ent) {
		return Error_Param;
	}

	if (try_lock_doing(mgr, ent->mod)) {
        int isFirstStart = 0;
        ent->cfg->m_startTimes++;
        if (1 == ent->cfg->m_startTimes)
            isFirstStart = 1;
        if (isFirstStart)
#if defined(_MSC_VER)
			ent->cfg->m_EntityStartTime.longPart = sp_cfg_getShellFirstStartTime().longPart + clock() * 10000;
#else
			GetLocalTime(&ent->cfg->m_EntityStartTime);
#endif //_MSC_VER
        if (!ent->mod->loaded)
            rc = load_module(mgr, ent->mod, trigger_entity_id, entity_id);	//start Entity process return init ok
        if (isFirstStart)
#if defined(_MSC_VER)
			ent->cfg->m_EntityInitEndTime.longPart = sp_cfg_getShellFirstStartTime().longPart + clock() * 10000;
		GetLocalTime(&ent->cfg->m_EntityInitEndTime);
#else
		//GetLocalTime(&ent->cfg->m_EntityInitEndTime);
        ZeroMemory(&ent->cfg->m_EntityInitEndTime, sizeof(SYSTEMTIME));
        curTickCount = GetTickCount64();
        memcpy(&ent->cfg->m_EntityInitEndTime, &curTickCount, sizeof(ULONGLONG));
#endif //_MSC_VER
        if (rc == 0)
            rc = start_entity(mgr, ent, cmdline, trigger_entity_id);//wait Entity start end, set Idle/lost
        if (isFirstStart)
#if defined(_MSC_VER)
			ent->cfg->m_EntityStartEndTime.longPart = sp_cfg_getShellFirstStartTime().longPart + clock() * 10000;
#else
			GetLocalTime(&ent->cfg->m_EntityStartEndTime);
#endif //_MSC_VER

		unlock_doing(mgr, ent->mod);
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "mod %s is busy doing now! line: %s", ent->mod->cfg->name, __FUNCTION__);
		rc = Error_Busy;
	}

	return rc;
}

/*send {MOD_CMD_STOP} cmd and then {MOD_CMD_TERM} cmd*/
int sp_mod_mgr_stop_entity2(sp_mod_mgr_t *mgr, sp_entity_t *ent, int trigger_entity_id, int cause_code)
{
	int rc;

	if (!ent)
		return Error_NotExist;

	if (try_lock_doing(mgr, ent->mod)) {
		rc = stop_entity(mgr, ent, trigger_entity_id, cause_code);
		if (rc == 0) {
			sp_mod_t *mod = ent->mod;
			sp_entity_t *pos;
			int unload = TRUE;
			list_for_each_entry(pos, &mod->entity_list, sp_entity_t, entry) {
				if ((pos->state != EntityState_Close && pos->state != EntityState_Killed && pos->state != EntityState_NoStart) ){
					unload = FALSE;
					break;
				}
			}
			if (unload) {
				DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "to unload module...");
				rc = unload_module(mgr, mod, trigger_entity_id);
                DbgWithLinkForC(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM, "unload module returned: %d", rc);
			}
		}
		unlock_doing(mgr, ent->mod);
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "mod %s is busy doing now! line: %s", ent->mod->cfg->name, __FUNCTION__);
		rc = Error_Busy;
	}

	return rc;
}

int sp_mod_mgr_terminate_entity2(sp_mod_mgr_t *mgr, sp_entity_t *ent, int trigger_entity_id)
{
	int rc;

	if (!ent)
		return Error_NotExist;
	
	if (try_lock_doing(mgr, ent->mod)) {
		rc = terminate_module(mgr, ent->mod, trigger_entity_id);
		unlock_doing(mgr, ent->mod);
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "mod %s is busy doing now! line: %s", ent->mod->cfg->name, __FUNCTION__);
		rc = Error_Busy;
	}

	return rc;
}

int sp_mod_mgr_pause_entity2(sp_mod_mgr_t *mgr, sp_entity_t *ent, int trigger_entity_id)
{
	int rc;

	if (!ent)
		return Error_NotExist;

	if (try_lock_doing(mgr, ent->mod)) {
		rc = pause_entity(mgr, ent, trigger_entity_id);
		unlock_doing(mgr, ent->mod);
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "mod %s is busy doing now! line: %s", ent->mod->cfg->name, __FUNCTION__);
		rc = Error_Busy;
	}

	return rc;
}

int sp_mod_mgr_continue_entity2(sp_mod_mgr_t *mgr, sp_entity_t *ent, int trigger_entity_id)
{
	int rc;

	if (!ent)
		return Error_NotExist;

	if (try_lock_doing(mgr, ent->mod)) {
		rc = continue_entity(mgr, ent, trigger_entity_id);
		unlock_doing(mgr, ent->mod);
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "mod %s is busy doing now! line: %s", ent->mod->cfg->name, __FUNCTION__);
		rc = Error_Busy;
	}

	return rc;
}

int sp_mod_mgr_test_entity2(sp_mod_mgr_t *mgr, sp_entity_t *ent, int trigger_entity_id, int test_type, int* result)
{
	int rc;

	if (!ent)
		return Error_NotExist;

	if (try_lock_doing(mgr, ent->mod)) {
		rc = test_entity(mgr, ent, test_type, trigger_entity_id, result);
		unlock_doing(mgr, ent->mod);
	} else {
		DbgWithLinkForC(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM, "mod %s is busy doing now! line: %s", ent->mod->cfg->name, __FUNCTION__);
		rc = Error_Busy;
	}

	return rc;
}

// from shell-> entity
int sp_mod_mgr_notify_redirect_subscribe(sp_mod_mgr_t *mgr, sp_entity_t *entity, sp_uid_t *uid, int from_entity_id, const char *param)
{
	int rc;
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_I8, uid, 0);
	iobuffer_write(pkt, IOBUF_T_STR, param, -1);
	rc = sp_svc_post(mgr->shell_svc, entity->mod->cfg->idx, entity->cfg->idx, SP_PKT_MOD|MOD_CMD_NOTIFY_REDIRECT_SUBSCRIBE, from_entity_id, &pkt);
	if (pkt)
		iobuffer_dec_ref(pkt);
	return rc;
}