/*************************************************
 * MagicPassJs
 * 매직패스의 기능 정의
 * Copyright 2010, DreamSecurity. http://www.dreamsecurity.com
 * 
 * @author Naruware 한영수/박종훈
 * @since 12 May 2010.
 * @version 2.0.5
 *************************************************/
MagicPass = {};
MagicPass.siteTitle					= "한국산업기술진흥원";
MagicPass.siteName					= "KIAT";
MagicPass.applCode					= "APPLDEFAULT";
MagicPass.pkiType					= "NPKI";
MagicPass.path						= window.location.protocol + "//" + window.location.host + "/magicsso";		//매직패스 설치경로
MagicPass.baseUrl					= "/index.jsp";		//매직패스 처리 후, 이동할 URL(사이트 메인페이지)
MagicPass.logoutUrl					= MagicPass.path + "/logout.jsp";		//매직패스 처리 후, 이동할 URL(사이트 메인페이지)
MagicPass.secureUrl					= MagicPass.path + "/secure.jsp";		//암호화 처리 URL

/* MagicPass Option Definitions */
MagicPass.option = {};
MagicPass.option.debugScript		= true;		//자바스크립트 디버그모드
MagicPass.option.debugApplet		= true;		//자바애플릿 디버그모드
MagicPass.option.isAutoLogin		= true;		//자동로그인(매직패스가 로그인되어 있는 상태에 접근 시, 자동으로 사이트로그인)
MagicPass.option.useCertificate		= true;		//인증서 로그인 사용여부
MagicPass.option.useApplet			= false;		//애플릿 사용여부(IE이외에서는 자동으로 애플릿사용)
MagicPass.option.useMagicPassS		= false;		//MagicPassS(RMI Server) 사용여부(Windows이외(Linux, Mac and etc.)에선 자동으로 MagicPassS사용)
MagicPass.option.JS_monitor			= {use : true, interval : 5000, object : null};		//자바스크립트 로그아웃감지(자바스크립트가 해당 interval 로 매직패스 로그아웃상태 감지)
MagicPass.option.MP_monitor			= {use : false, interval : 7000};		//매직패스의 자동세션아웃 기능(페이지가 매직패스를 해당 interval 이내에 IsLogon 호출이 없으면 로그아웃)

/* MagicPass Client-Modules Version Definitions */
MagicPass.version = {
		"MagicLoaderX"		: "1,0,1,10",
		"MagicPassX"		: "1,0,4,3",
		"MPCertX"			: "1,0,1,6",
		"applet"			: "1.0.0.4",
		"appletResource"	: "1.0.0.3"
};

/*--------------------------------------------------------------
	In the below will be Optimazing
--------------------------------------------------------------*/
MagicPass.settings = {};
MagicPass.loginSettings = {};
ClientEnvironments = {};

/* MagicPass runtime variable Definitions */ 
MagicPass.pageLoaded				= false;		//플러그인 사용 가능여부
MagicPass.pluginUsable				= false;		//플러그인 사용 가능여부
MagicPass.isReading					= false;		//플러그인을 읽어오는 중인지 여부
MagicPass.isSetting					= false;		//매직패스 다운로드/설치 중인지 여부
MagicPass.serverCertificate			= null;		//멀티도메인연계될때 현재 어플리케이션 코드 저장
MagicPass.loginType					= null;		//로그인타입
MagicPass.cookieName				= "_MPSC_=";		//서버인증서를 담을 쿠키명

/* Setting Definitions */
MagicPass.settings.alias			= "MagicPassPlugin";		//플러그인 별칭
MagicPass.settings.object			= document.getElementById(MagicPass.settings.alias);		//ActiveX의 MagicPassX 객체
MagicPass.settings.objectLoaderX	= document.getElementById("MagicLoaderX");		//ActiveX의 MagicLoadeX 객체
MagicPass.settings.objectCertX		= document.getElementById("MPCertX");		//ActiveX의 (N)MPCertX 객체
MagicPass.settings.configFile		= MagicPass.path + "/plugins/setup.txt";
MagicPass.settings.onlineFile		= MagicPass.path + "/plugins/setupOnLine.exe";
MagicPass.settings.updateFile		= MagicPass.path + "/plugins/setupOnLine_update.exe";
MagicPass.settings.settingFile		= MagicPass.path + "/plugins/setupOnLine_update_setting_file.exe";
MagicPass.settings.executeFile		= "DreamSecurity\\MagicPass\\MagicPass.exe";
MagicPass.settings.onlineUrl		= MagicPass.secureUrl + "?actionName=CIPHER&source=" + MagicPass.settings.onlineFile;
MagicPass.settings.updateUrl		= MagicPass.secureUrl + "?actionName=CIPHER&source=" + MagicPass.settings.updateFile;
MagicPass.settings.settingUrl		= MagicPass.secureUrl + "?actionName=CIPHER&source=" + MagicPass.settings.settingFile;
MagicPass.settings.executeUrl		= MagicPass.secureUrl + "?actionName=CIPHER&source=" + MagicPass.settings.executeFile;
MagicPass.settings.offlineUrl		= MagicPass.path + "/installer.html";

/* Login Settings Definitions */
MagicPass.loginSettings.ID			= 0;		//아이디 로그인
MagicPass.loginSettings.SSN			= 1;		//주민번호 로그인
MagicPass.loginSettings.EMPNO		= 2;		//사원번호 로그인
MagicPass.loginSettings.CERT		= 3;		//인증서 로그인
MagicPass.loginSettings.cryptoAlgo	= "48";		//로그인 암호화 알고리즘

/* Client Environment Definitions */
ClientEnvironments.os				= null;		//사용자 OS 종류
ClientEnvironments.browser			= null;		//사용자 브라우저 종류
ClientEnvironments.autoSetup		= true;		//자동설치 셋팅(오프라인설치 페이지에서 자동설치확인을 활성화 하지 않을 경우 false가 됨)
(function() {
	var userAgent=navigator.userAgent.toUpperCase();
	var browserList=["MSIE","FIREFOX","CHROME","SAFARI","OPERA"];
	
	ClientEnvironments.browser = "OTHERS";
	for(var i in browserList)
	{
		if(userAgent.indexOf(browserList[i])>-1)
		{
			ClientEnvironments.browser=browserList[i];
			break;
		}
	}
	
	var platform = navigator.platform.toUpperCase();
	var osList = ["WIN", "MAC", "LINUX"];

	ClientEnvironments.os = "OTHERS";
	for(var i in osList)
	{
		if(platform.indexOf(osList[i])>-1)
		{
			ClientEnvironments.os=(osList[i]=="WIN")?"WINDOWS":osList[i];
			break;
		}
	}
	
	if(document.cookie.indexOf("MagicPassAutoSetup")>-1)
	{
		ClientEnvironments.autoSetup=false;
	}

	if(ClientEnvironments.os != "WINDOWS")
	{
		MagicPass.option.useMagicPassS=true;
	}

	if(ClientEnvironments.browser != "MSIE")
	{
		MagicPass.option.useApplet = true;
	}
})();

/*--------------------------------------------------------------
	Function Definitions
--------------------------------------------------------------*/
/**
 * 매직패스 플러그인이 로딩된 이후 실행하도록, 작업될 내용을 Queue에 적재합니다.
 * 이미 로딩 되어있는 경우, 바로 실행시킨다.
 * 
 * @param
 * 		title : 작업명(작업인식용 텍스트)
 * 		job : 작업 객체(스크립트 함수)
 * 		functionClass : 작업 객체가 클래스형식일 경우, 클레스 입력
 */
MagicPass.job = function(title, job, functionClass)
{
	if(!MagicPass.pluginUsable)
	{
		if(MagicPass.job.queue == null) MagicPass.job.queue = [];
		MagicPass.job.queue.push([title, job, functionClass]);
	}
	else
	{
		MagicPass.log("[job]" + title + " Start");
		(job).call(funtionClass);
		MagicPass.log("[job]" + title + " End");
	}
};

/**
 * MagicPass.job에서 적재한 작업을 수행합니다.
 */
MagicPass.jobExecute = function()
{ 
	if(MagicPass.pluginUsable)
	{
		if(MagicPass.job.queue != null)
		{
			for(var i = 0; i < MagicPass.job.queue.length; i++)
			{
				MagicPass.log("[job]" + MagicPass.job.queue[i][0] + " Start");
				(MagicPass.job.queue[i][1]).call(MagicPass.job.queue[i][2]);
				MagicPass.log("[job]" + MagicPass.job.queue[i][0] + " End");
			}
		}
	}
};

/**
 * MagicPass.job에서 적재한 작업을 클리어합니다.
 */
MagicPass.jobClear = function()
{
	MagicPass.job.queue = null;
};

/**
 * 브라우저 콘솔에 로깅합니다. 
 * (단, 브라우저 콘솔을 지원 안하는 브라우저(IE, Opera등)는 디버깅 콘솔을 <div>로 생성합니다.)
 * 
 * @param
 * 		str : 로그 메세지
 */
MagicPass.log = function(str)
{
	if(!MagicPass.option.debugScript) return;

	try
	{
		console.log(str);
	}
	catch(e) {}
};

/**
 * 매직패스를 초기화 합니다.
 */
MagicPass.init = function(siteName)
{
	var site = siteName || MagicPass.siteName;
	
	var pkiType = (MagicPass.pkiType == "GPKI")? 0 : 1;
	MagicPass.loginType = (MagicPass.loginType == null) ? MagicPass.loginSettings.ID : MagicPass.loginType;
	
	MagicPass.settings.object.Init(pkiType, MagicPass.loginSettings.cryptoAlgo, MagicPass.loginType, site);

	MagicPass.log("[exec]init");
};

/**
 * 기능 실행 후, 결과값을 받는다.
 */
MagicPass.getResult = function()
{
	var result = "";
	
	if(MagicPass.option.useApplet)
	{
		result = MagicPass.settings.object.Result();
	}
	else
	{
		result = MagicPass.settings.object.Result;
	}

	MagicPass.log("[exec]getResult-" + result);
	return result;
};

/**
 * 해당 사이트명의 토큰을 로그아웃시킨다.
 *
 * @param
 * 		siteName : 사이트명(생략가능)
 */
MagicPass.logout = function(siteName)
{
	var site = siteName || MagicPass.siteName;
	
	MagicPass.settings.object.Logout(site);

	MagicPass.log("[exec]logout-" + site);
};

/**
 * 사이트를 로그아웃합니다.
 * 
 * @param
 * 		returnUrl : 로그아웃 이후 이동할 URL
 * 		siteName : 토큰을 로그아웃할 사이트명
 */
MagicPass.siteLogout = function(siteName)
{
	var site = siteName || MagicPass.siteName;

	MagicPass.request(null, null, null, null, MagicPass.logoutUrl);
	
	MagicPass.logout(site);
	window.location.replace("http://www.kiat.or.kr/member/magicsso/logout.jsp?returnUrl=" + window.location);
};

/**
 * 서버인증서로 감싼(Envelope)한 키값을 구합니다.
 *
 * @param
 * 		siteName : 사이트명(생략가능)
 * 		isConnect : 연계처리 여부
 * @return
 *		0		: 성공
 *		other	: 실패
 */
MagicPass.getEnvKey = function(isConnect, siteName, applCode)
{
	var site = siteName || MagicPass.siteName;
	var appl = applCode || MagicPass.applCode;
	var code = null;
	
	if(isConnect)
	{
		code = MagicPass.settings.object.GetAppEnvKey(site, appl, MagicPass.serverCertificate); 
	}
	else
	{
		code = MagicPass.settings.object.GetLogonEnvKey(site, MagicPass.serverCertificate);
	}
	
	MagicPass.log("[exec]getEnvKey-" + code);
	return code;
};

/**
 * 암호화 검증을 위한 세션키를 교환합니다.
 *
 * @param
 *		encrytKey	: 암호화키
 *		siteName	: 사이트명(생략가능)
 * @return
 *		0		: 성공
 *		other	: 실패
 */
MagicPass.changeKey = function(encryptKey, isConnect, siteName, applCode)
{
	var site = siteName || MagicPass.siteName;
	var appl = applCode || MagicPass.applCode;
	var code = null;
	
	if(isConnect)
	{
		code = MagicPass.settings.object.ChangeAppKey(site, appl, encryptKey);
	}
	else
	{
		code = MagicPass.settings.object.ChangeLogonKey(site, encryptKey);
	}
	
	MagicPass.log("[exec]changeKey-" + code);
	return code;
};

/**
 * 암호화를 수행합니다. (로그인에서 사용)
 * 
 * @param
 * 		loginForm	: 로그인 <form>태그 객체
 * 		id			: 아이디 <input>태그 객체
 * 		password	: 패스워드 <input>태그 객체
 * 		siteName	: 사이트명(생략가능)
 */
MagicPass.encryptLogin = function(id, password, siteName)
{
	var site = siteName || MagicPass.siteName;
	var result = null;
	
	switch(MagicPass.loginType)
	{
		case MagicPass.loginSettings.ID :
			result = MagicPass.settings.object.EncryptLogonID(site, decodeURI(id.value), decodeURI(password.value));
			break;
		case MagicPass.loginSettings.CERT :
			result = MagicPass.settings.object.EncryptAuth(site, id);
			break;
	}
	

    MagicPass.log("[exec]encryptLogin-" + result);
    return result;
};

/**
 * 암호화를 수행합니다.
 * 
 * @param
 * 		text		: 암호화할 평문
 * 		siteName	: 사이트명(생략가능)
 * 		applCode	: 어플리케이션 코드(생략가능)
 */
MagicPass.encryptKey = function(text, siteName, applCode)
{
	var site = siteName || MagicPass.siteName;
	var appl = applCode || MagicPass.applCode;
	
	var result = MagicPass.settings.object.EncryptKey(site, appl, text);

	MagicPass.log("[exec]encryptKey-" + result);
	return result; 
};

/**
 * 토큰을 저장합니다.
 *
 * @param
 *		encryptedToken	: 암호화된 토큰
 * 		siteName		: 사이트명(생략가능)
 * @return
 *		0		: 성공
 *		other	: 실패
 */
MagicPass.setToken = function(encryptedToken, siteName)
{
	var site = siteName || MagicPass.siteName;

	var result = MagicPass.settings.object.SetToken(site, encryptedToken);
	
	MagicPass.log("[exec]setToken(" + site + ", " + encryptedToken + ")");
	return result;
};

/**
 * 토큰을 불러온다.
 *
 * @param
 * 		siteName	: 사이트명(생략가능)
 * 		applCode	: 어플리케이션 코드(생략가능)
 * @return
 *		0		: 성공
 *		other	: 실패
 */
MagicPass.getToken = function(siteName, applCode)
{
	var site = siteName || MagicPass.siteName;
	var appl = applCode || MagicPass.applCode;

	var result = MagicPass.settings.object.GetToken(site, appl);
	
	MagicPass.log("[exec]getToken-" + result);
	return result;
};

/**
 * 현재(또는 인자로 받은) 사이트가 로그인 중인지 확인합니다.
 *
 * @param
 *		siteName	: 사이트명(생략가능)
 * @return
 *		true	: 로그인중
 *		false	: 로그인되지 않음
 */
MagicPass.isLogin = function(siteName)
{
	var site = siteName || MagicPass.siteName;
	var result = false;

	if(MagicPass.settings.object.GetStatus(site) == 150) result = true;

	MagicPass.log("[exec]isLogin(" + site + ")-" + result);
	return result;
};

/**
 * 매직패스의 버전을 확인. 다운로드/업데이트/셋팅파일업데이트 여부를 확인.
 *
 * @return
 *		true		: 최신버전
 *		false		: 버전확인중 에러 발생
 *		String		: 다운로드/업데이트/셋팅파일업데이트 URL
 */
MagicPass.versionCheck = function()
{
	if(!MagicPass.option.useApplet)
	{
		switch(MagicPass.settings.objectLoaderX.VersionCheck(MagicPass.settings.configFile))
		{
			case 0 :
				break;
			case 2 :
				MagicPass.downloadAndSetup(MagicPass.settings.onlineUrl);
				break;
			case 3 :
				MagicPass.downloadAndSetup(MagicPass.settings.updateUrl);
				break;
			case 4 :
				MagicPass.downloadAndSetup(MagicPass.settings.settingUrl);
				break;
			default :
				throw "";
				break;
		}

	}

	MagicPass.log("[exec]versionCheck");
	return true;
};

/**
 * 매직패스를 다운로드하여 자동설치합니다.
 *
 * @param
 *		url		: 다운로드할 셋업파일의 URL
 * @return
 *		true	: 정상 다운로드 및 설치완료.
 *		false	: 비정상 다운로드 및 비정상 설치.
 */
MagicPass.downloadAndSetup = function(url)
{
	if(MagicPass.isSetting) return;
		
	var message = "";
	var code = -1;

	if (confirm("보안 로그인 프로그램(매직패스)을 설치 또는 업데이트합니다.\n해당 프로그램을 설치하지 않으면 정상적으로 로그인되지 않습니다.\n계속 설치를 진행하시겠습니까?"))
	{
		MagicPass.isSetting = true;

		//MagicPass가 설치될때, Port정보가 없으면 정상적인 설치가 안되는 관계로 Port가 80인 경우 :80을 붙여준다. 
		if(window.location.port == "")
		{
			url = window.location.protocol + "//" + window.location.host + ":80" + url.substring(new String(window.location.protocol + "//" + window.location.host).length);
		}

		code = MagicPass.settings.objectLoaderX.Download(url);

		if (code != 0)
		{
			MagicPass.isSetting = false;

			switch (code)
			{
				case 400:
					message = "사용자의 중지요청";
					break;
				case 404:
					message = "잘못된 다운로드 URL";
					break;
				default:
					message = "알수없는 원인";
					break;
			}
			
			MagicPass.error(message + "(으)로 다운로드가 중지되었습니다.\n[" + code + "]");
		}
		else
		{
			return;
		}

		MagicPass.log("[exec]downloadAndSetup");
	}

	MagicPass.setupOffLine();
	throw "";
};

/**
 * 매직패스가 실행중인지 여부를 확인합니다.
 *
 * @return
 *		true	: 실행중
 *		false	: 실행되지 않음
 */
MagicPass.isRunning = function()
{
	var result = false;
	
	if(!MagicPass.option.useApplet)
	{
		if(MagicPass.settings.object.GetStatus(MagicPass.siteName) != 103)
		{
			result = true;
		}
	}
	
	MagicPass.log("[exec]isRunning-" + result);
	return  result;
};

/**
 * 매직패스를 실행시킨다.
 *
 * @return
 *		true	: 정상실행
 *		false	: 실행실패
 */
MagicPass.start = function()
{
	var result = null;

	try
	{
		if(MagicPass.option.useApplet)
		{
			result = (MagicPass.settings.object.ProgramCheck()) ? true : MagicPass.settings.object.ProgramRun();
		}
		else
		{
			result = (MagicPass.settings.objectLoaderX.ProgramRun(MagicPass.settings.executeUrl, "", "MagicPass") == 0) ? true : false;
		}
		
		if(result)
		{
			MagicPass.pluginUsable = true;
		}
		else
		{
			throw "result is " + result;
		}
	}
	catch(e)
	{
		MagicPass.error("start Error " + e.message, false);
		window.setTimeout(function(){
			MagicPass.start();
		}, 2000);
		
		return;
	}

	MagicPass.log("[exec]start");

	MagicPass.pluginUsable = true;
	MagicPass.jobExecute();
};

/**
 * <Form>태그에 입력된 데이터를 암호화 처리를 위해 토큰형식으로 정의합니다.
 *
 * @param
 *		form	: <form>태그 객체
 * @return
 *		String	: 일반텍스트
 */
MagicPass.makePlainText = function(loginForm)
{
	var result = "";
	
	if(typeof(loginForm) == "string")
	{
		result = String.fromCharCode(8593) + "loginData" + String.fromCharCode(8595) + loginForm;
	}
	else
	{
		for(var i = 0; i < loginForm.elements.length; i++)
		{
			if(loginForm.elements[i].type == "text" || loginForm.elements[i].type == "password" || loginForm.elements[i].type == "hidden")
			{
				result += String.fromCharCode(8593) + loginForm.elements[i].name + String.fromCharCode(8595) + loginForm.elements[i].value;
			}
		}
		result = result.substring(1);
	}
	
	MagicPass.log("[exec]makePlainText-" + result);
	return result;
};

/**
 * 매직패스 오프라인 설치를 진행합니다.
 */
MagicPass.setupOffLine = function()
{
	//window.open(MagicPass.settings.offlineUrl, "MagicPass_Setup_popup", "scrollbars=no, status=no, resizable=no, menubar=no, toolbar=no");

	var sizeWidth = (document.body) ? document.body.offsetWidth : window.screen.availWidth;
	var bodyTag = document.getElementsByTagName("body")[0];
	
	with(bodyTag.style){width="100%";height="100%";overflow="hidden";};
	bodyTag.innerHTML	= "<div style='z-index:0;position:absolute;top:0;left:0;min-weight:100%;min-height:100%;width:100%;height:100%;background:#000;filter:alpha(opacity=50);-moz-opacity:0.5;opacity:0.5'></div>"
						+ "<div style='position:absolute;top:200px;left:" + ((sizeWidth - 450) >> 1) + "px;'><iframe src='" + MagicPass.settings.offlineUrl + "' frameborder='0' border='0' width='450' height='300'></iframe></div>"
						+ bodyTag.innerHTML;
	/**
	 * DOM 처리방식
	 * IE6 에서 setAttribute의 style 속성이 안되는 관계로 그냥 innerHTML로 때려 넣기 합니다
	 *
	var cDiv = document.createElement("div");
	var cDiv2 = document.createElement("div");
	cDiv.setAttribute("style", "position:absolute;z-index:0;top:0;left:0;min-weight:100%;min-height:100%;width:100%;height:100%;background:#000;filter:alpha(opacity=50);-moz-opacity:0.5;opacity:0.5");
	cDiv2.setAttribute("style", "position:absolute;z-index:1;top:200px;left:" + ((sizeWidth - 450) >> 1) + "px;");
	cDiv2.innerHTML = "<iframe src='" + MagicPass.settings.offlineUrl + "' frameborder='0' border='0' width='450' height='300'></iframe>";
	bodyTag.insertBefore(cDiv2, bodyTag.firstChild);
	bodyTag.insertBefore(cDiv, bodyTag.firstChild);
	 */
	
	MagicPass.log("[exec]setupOffLine");
};

/**
 * 매직패스 실행을 진행합니다.
 */
MagicPass.pluginLoading = function()
{
	if(MagicPass.pluginUsable) return;
	
	MagicPass.log("[exec]pluginLoading");
	
	try
	{
		if(!MagicPass.isRunning())
		{
			if(MagicPass.versionCheck())
			{
				MagicPass.start();
			}
		}
		else
		{
			MagicPass.pluginUsable = true;
			MagicPass.jobExecute();
		}
	}
	catch(e)
	{
		window.setTimeout(function() {
			MagicPass.pluginLoading();
		}, 3000);
	}
};

/**
 * 매직패스 플러그인(ActiveX/Applet)을 로딩합니다.
 */
MagicPass.ready = function(flag)
{
	if(MagicPass.pluginUsable) return;
	if(!ClientEnvironments.autoSetup) return;
	
	if(MagicPass.isReading)
	{
		if(!flag) return;
	}
	else
	{
		MagicPass.isReading = true;
	}
	
	MagicPass.log("[exec]ready");

	try
	{
		var pluginArea = document.getElementById("MagicSSOPluginArea");
		
		if(pluginArea == null)
		{
			var bodyTag = document.getElementsByTagName("body")[0];
			var cDiv = document.createElement("div");
			cDiv.setAttribute("id", "MagicSSOPluginArea");
			bodyTag.appendChild(cDiv);

			pluginArea = document.getElementById("MagicSSOPluginArea");
			
			if(MagicPass.option.useApplet)
			{
				var jreSetupUrl = "http://java.com/ko/download/";
				
				if(ClientEnvironments.browser == "MSIE") jreSetupUrl = "http://java.sun.com/update/1.6.0/jinstall-6-fcs-windows-i586.cab";
				else if(ClientEnvironments.browser == "FIREFOX") jreSetupUrl = "http://www.java.com/ko/download/windows_xpi.jsp?locale=ko";
				
				pluginArea.innerHTML	= "<object classid='clsid:8AD9C840-044E-11D1-B3E9-00805F499D93' id='" + ((ClientEnvironments.browser == "MSIE") ? MagicPass.settings.alias : "") + "' width='1' height='1' codebase='" + jreSetupUrl + "'>"
										+ "	<param name='java_code' value='com.naru.app.applet.PassPortApplet.class' />"
										+ "	<param name='java_codebase' value='" + MagicPass.path + "/plugins/applet' />"
										+ "	<param name='java_archive' value='passport-applet.jar, passport-j.jar' />"
										+ "	<param name='type' value='application/x-java-applet;version=1.6' />"
										+ "	<param name='browser.type' value='" + ClientEnvironments.browser + "' />"
										+ "	<param name='client.type' value='" + ((MagicPass.option.useMagicPassS) ? "passportj" : "magicpass") + "' />"
										+ "	<param name='passport.debug' value='" + MagicPass.option.debugApplet + "' />"
										+ "	<param name='client.resources' value='passport-resource.jar' />"
										+ "	<param name='client.resources.version' value='" + MagicPass.version.appletResource + "' />"
										+ "	<param name='passport-j.resources' value='passport-j-resource.jar' />"
										+ "	<param name='passport-j.resources.version' value='" + MagicPass.version.applet + "' />"
										+ "	<param name='isBrowserMonitoring' value='" + MagicPass.option.MP_monitor.use + "' />"
										+ "	<param name='interval.browser.monitoring' value='" + MagicPass.option.MP_monitor.interval + "' />"
										+ "	<param name='mayscript' value='true' />"
										+ "	<comment>"
										+ "		<embed id='" + ((ClientEnvironments.browser == "MSIE") ? "" : MagicPass.settings.alias) + "' type='application/x-java-applet;version=1.6' width='1' height='1' "
										+ "			pluginspage='" + jreSetupUrl + "' "
										+ "			java_code='com.naru.app.applet.PassPortApplet.class' "
										+ "			java_codebase='" + MagicPass.path + "/plugins/applet' "
										+ "			java_archive='passport-applet.jar, passport-j.jar' "
										+ "			browser.type='" + ClientEnvironments.browser + "' "
										+ "			client.type='" + ((MagicPass.option.useMagicPassS) ? "passportj" : "magicpass") + "' "
										+ "			passport.debug='" + MagicPass.option.debugApplet + "' "
										+ "			client.resources='passport-resource.jar' "
										+ "			client.resources.version='" + MagicPass.version.appletResource + "' "
										+ "			passport-j.resources='passport-j-resource.jar' "
										+ "			passport-j.resources.version='" + MagicPass.version.applet + "' "
										+ "			isBrowserMonitoring='" + MagicPass.option.MP_monitor.use + "' "
										+ "			interval.browser.monitoring='" + MagicPass.option.MP_monitor.interval + "' "
										+ "			mayscript='true'></embed>"
										+ "		<noembed></noembed> "
										+ "	</comment>"
										+ "</object>";
			}
			else
			{
				pluginArea.innerHTML += "<object codebase='" + MagicPass.path + "/plugins/MagicPassX.cab#version=" + MagicPass.version.MagicPassX + "' classid='clsid:AD6870C0-44B7-42FB-A119-C2C6BD9CD005' id='" + MagicPass.settings.alias + "' width='1' height='1'></object>";
			}
		}
		
		if(MagicPass.settings.object == null)
		{
			MagicPass.settings.object = document.getElementById(MagicPass.settings.alias);
			throw "MagicPass.settings.object is " + MagicPass.settings.object;
		}
	}
	catch(e)
	{
		MagicPass.error("Starts delayed action. " + e.message, false);
		window.setTimeout(function(){
			MagicPass.ready(true);
		}, 1000);
		
		return;
	}
	
	MagicPass.pluginLoading();
};

/**
 * MagicLoaderX 플러그인을 로딩합니다.
 */
MagicPass.readyLoaderX = function()
{
	if(MagicPass.option.useApplet || MagicPass.pluginUsable) return;

	try
	{
		var pluginArea = document.getElementById("MagicSSOPluginArea");

		if(document.getElementById("MagicLoaderX") == null)
		{
			pluginArea.innerHTML += "<object codebase='" + MagicPass.path + "/plugins/MagicLoaderX.cab#version=" + MagicPass.version.MagicLoaderX + "' classid='clsid:3D64E58D-CB55-4344-B809-CFE38F900838' id='MagicLoaderX' width='1' height='1'></object>";
			MagicPass.settings.objectLoaderX = document.getElementById("MagicLoaderX");
		}
	}
	catch(e)
	{
		window.setTimeout(function(){
			MagicPass.readyLoaderX();
		}, 1000);
	}
};

/**
 * NMPCertX(MPCertX) 플러그인을 로딩합니다.
 */
MagicPass.readyCertX = function()
{
	if(!MagicPass.option.useCertificate) return;

	try
	{
		var pluginArea = document.getElementById("MagicSSOPluginArea");

		if(document.getElementById("MPCertX") == null)
		{
			var clsid = (MagicPass.pkiType == "NPKI") ? "1CCA7AD8-4FF3-4449-B994-FD5CD326444C" : "000FDEEC-E017-46A9-AEA9-5520CCA8E7D5";
			
			pluginArea.innerHTML += "<object codebase='" + MagicPass.path + "/plugins/NMPCertX.cab#version=" + MagicPass.version.MPCertX + "' classid='clsid:" + clsid +"' id='MPCertX' width='1' height='1'></object>";
			MagicPass.settings.objectCertX = document.getElementById("MPCertX");
		}
	}
	catch(e)
	{
		window.setTimeout(function(){
			MagicPass.readyCertX();
		}, 1000);
	}
};

/**
 * 매직패스 처리관련 에러메세지를 출력합니다.
 *
 * @param
 *		error	: 에러코드(또는 에러문구)
 *		flag 
 *			- true : alert메세지 띄우지 않음
 *			- false(또는 생략) : alert메세지 띄움  
 * @return
 *		String	: 에러메세지
 */
MagicPass.error = function(error, flag)
{
	if(error == null || error == "")
	{
		MagicPass.log("[ERROR!] Error sentence is null"); 
		return;
	}

	var alertFlag = (typeof(flag) == "undefined") ? MagicPass.option.debugScript : flag;
	var message = null;

	if(!window.isNaN(error)) error = parseInt(error);
	
	if(typeof(error) == "number")
	{
		switch(error)
		{
			case 103	: message = "매직패스가 실행중인지 트레이의 아이콘을 확인해 주세요."; break;
			case 150	: message = "이미 로그인 중입니다. 매직패스를 확인 후 다시 시도해 주시기 바랍니다."; break;
			case 151	: message = "로그인되지 않았거나, 접근할 수 없는 시스템입니다."; break;
			case 9999	: message = "인증서버(MAS)가 연결되지 않았거나 작동중이지 않습니다."; break;

			case 10001	:
			case 10003	: message = "사용자 정보가 존재하지 않습니다."; break;
				
			case 70000	: message = "매직패스가 로딩중이거나 설치되지 않았습니다. 로딩 또는 설치가 완료된 후, 시도하시기 바랍니다."; break;
			case 70001	: message = "아아디를 입력해 주시기 바랍니다."; break;
			case 70002	: message = "비밀번호를 입력해 주시기 바랍니다."; break;
			case 70003	: message = "아아디 또는 비밀번호가 잘못 입력되었습니다."; break;
			case 70004	: message = "MagicPass(보안 로그인 프로그램)을 설치하지 않았거나 설치를 진행하고 있습니다.\n설치 완료 후, 다시 로그인을 시도해 주시기 바랍니다."; break;
			case 70005	: message = "서버인증서 조회에 실패하였습니다. 관리자에게 문의하시기 바랍니다."; break;
			case 70006	: message = "암호화 키를 확인하는 과정에서 실패하였습니다."; break;
			case 70007	: message = "암호화 세션키 교환과정에서 오류가 발생하였습니다."; break;
			case 70008	: message = "로그인 정보를 암호화 하는 과정에서 오류가 발생하였습니다."; break;
			case 70009	: message = "복호화한 데이터가 없습니다. 관리자에게 문의하시기 바랍니다."; break;
			case 70010	: message = "암호화 데이터를 복호화 하는 과정에서 필요한 시간 데이터가 유실되었습니다."; break;
			case 70011	: message = "암호화 데이터를 복호화 하는 과정에서 필요한 키 데이터가 유실되었습니다."; break;

			default	:
				if(error >= 801 && error < 1000) message = "인증서 본인확인에 실패하였습니다. 다시 한번 시도해주시기 바랍니다.";
				else if(error >= 1000 && error <= 2013) message = "작업중 표준보안API(GPKIAPI)에서 오류를 발견하였습니다.";
				else message = "알 수 없는 에러입니다.\n문제가 지속될 경우, 관리자에게 문의하시기 바랍니다.";
				break;
		}
		
		if(MagicPass.option.debugScript)message += "\nCODE " + error;
	}
	else
	{
		message = error;
	}
	
	if(alertFlag) window.alert(message);

	MagicPass.log("[ERROR!] " + message);
	return message;
};

/**
 * 매직패스에 저장되는 데이터의 캐릭터셋을 지정합니다.
 * (ActiveX 에서만 사용)
 * 
 * @param
 * 		charsetName : euc-kr, ansi (이외는 지원 안함. (0:ANSI, 1:euc-kr))
 */
MagicPass.setCharset = function(charsetName, siteName)
{
	var charset = charsetName || "euc-kr";
	var site = siteName || MagicPass.siteName;
	
	if(!MagicPass.option.useApplet)
	{
		MagicPass.settings.object.SetCharSet(site, ((charset.toLowerCase() == "euc-kr") ? 1 : 0));
	}

	MagicPass.log("[exec]setCharset-" + charset);
};

/**
 * 매직패스 로그인 정보에 표시되는 이름을 지정합니다.
 * 
 * @param
 * 		delegateName : 표시 이름 (지정안하면, siteTitle 로 지정)
 */
MagicPass.setDelegateName = function(delegateName, siteName)
{
	var delegateName = delegateName || MagicPass.siteTitle;
	var site = siteName || MagicPass.siteName;
	
	MagicPass.settings.object.SetSiteDelegate(site, delegateName);
	MagicPass.log("[exec]setDelegateName-" + delegateName);
};

/**
 * 브라우저 종료되었는지 확인하여 로그아웃을 실행합니다.
 */
MagicPass.browserOffCheck = function(siteName)
{
	var processName = null;
	var site = siteName || MagicPass.siteName;
	
	if(ClientEnvironments.os == "WINDOWS")
	{
		switch(ClientEnvironments.browser)
		{
			//case "MSIE"		: processName = "iexplore.exe"; break;	//ActiveX 사용시 자체적으로 브라우저 체크함.
			case "FIREFOX"	: processName = "firefox.exe"; break;
			case "SAFARI"	: processName = "Safari.exe"; break;
			case "CHROME"	: processName = "chrome.exe"; break;
			case "OPERA"	: processName = "opera.exe"; break;
		}
	}
	else
	{
		switch(ClientEnvironments.browser)
		{
			case "FIREFOX"	: processName = "firefox"; break;
			case "SAFARI"	: processName = "Safari"; break;
			case "CHROME"	: processName = "chrome"; break;
			case "OPERA"	: processName = "opera"; break;
		}
	}

	if(processName != null)
	{
		MagicPass.settings.object.setBrowserCheck(site, processName);
	}

	MagicPass.log("[exec]browserCheck-" + processName);
};

/**
 * 자동로그아웃 기능을 수행합니다. 
 * (지정된 시간간격 이상 스크립트가 매직패스로 액세스가 없으면 매직패스의 사이트 토큰 로그아웃)
 * 
 * @param
 * 		interval : 체크 시간간격(1초단위; 1/1000초 아님)
 */
MagicPass.siteMonitorLogout = function(interval, siteName)
{
	if(!MagicPass.option.MP_monitor.use) return;
	
	var intervalTime = interval || MagicPass.option.MP_monitor.interval;
	var site = siteName || MagicPass.siteName;
	
	MagicPass.settings.object.SetAutoLogoutSite(site, intervalTime / 1000);

	MagicPass.log("[exec]siteMonitorLogout-" + intervalTime);
};

/**
 * Ajax 처리를 지원합니다.
 * 
 * @param
 * 		mode : secure.jsp의 actionName을 지정합니다.
 * 		callbackFunction : 콜백함수(Ajax 처리 후, 호출 함수)
 * 		funtionClass : 콜백함수가 클래스형식일 경우, 클래스를 입력
 * 		params : secure.jsp로 호출할때 파라미터를 정의합니다.(String 또는 Map 타입)
 * 		url : secure.jsp 이외의 url로 Ajax처리를 요할때 파일의 URL을 지정합니다.
 * 		async
 * 			true : 비동기 방식으로 콜백함수 호출
 * 			false : 동기 방식으로 콜백함수 호출
 */
var xmlHttpRequest = null;
MagicPass.request = function(mode, callbackFunction, funtionClass, params, url, async)
{
	if(xmlHttpRequest == null)
	{
		try
		{
			xmlHttpRequest = new XMLHttpRequest();
		}
		catch(e)
		{
			try
			{
				xmlHttpRequest = new ActiveXObject("Msxml2.HTTP");
			}
			catch(f)
			{
				xmlHttpRequest = new ActiveXObject("Microsoft.XMLHTTP");
			}
		}
	}
	
	var param = "actionName=" + mode;

	//맵형식의 파라미터를 처리합니다
	for(var i in params)		
	{
		param += "&" + i + "=" + encodeURIComponent(params[i]);
	}

	var actionUrl = url || MagicPass.secureUrl;		//Ajax로 처리될 페이지를 지정합니다

	//Ajax 호출을 시도합니다
	xmlHttpRequest.open("POST", actionUrl, false);
	xmlHttpRequest.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
	xmlHttpRequest.send(param);
	
	var sync = async || false;

	if(sync)
	{
		xmlHttpRequest.onreadystatechange = function()
		{
			if(xmlHttpRequest.readyState == 4)
			{
				if(xmlHttpRequest.status == 200)
				{
					(callbackFunction).call(funtionClass, xmlHttpRequest.responseXML);
				}
				else 
				{
					MagicPass.error(xmlHttpRequest.statusText + " [" + xmlHttpRequest.status + "]");
				}
			}
		};
	}
	else
	{
		if(typeof(callbackFunction) == "function")
		{
			callbackFunction.call(funtionClass, xmlHttpRequest.responseXML);
		}
	}
};

/**
 * XML에서 특정 태그의 값을 파싱합니다.
 * 
 * @param
 * 		xmlData XML오브젝트
 * 		tag 추출대상 Tag
 * 
 * @return
 * 		추출대상태그의 nodeValue(String타입)
 */
MagicPass.xmlParse = function(xmlData, tag)
{
    var result = "";

    try
    {
    	result = xmlData.getElementsByTagName(tag)[0].firstChild.nodeValue;
    }
    catch(e)
    {
    	MagicPass.error("Undefined tag(" + tag + ") called", false);
    }

    return result;
};

/**
 * HTML엘리먼트에 이벤트를 지정합니다.
 * 
 * @param
 * 		targetObj 객체
 * 		eventType 이벤트종류 (click, keypress, ...)
 * 		callbackFunction 이벤트 후 처리
 */
MagicPass.addEvent = function(targetObj, eventType, callbackFunction)
{
	try
	{
		if(window.addEventListener) targetObj.addEventListener(eventType, callbackFunction, false);
		else targetObj.attachEvent("on" + eventType, callbackFunction);
	}
	catch(e)
	{
		MagicPass.error(targetObj + " add '" + eventType + "' event is fail.\n cause : " + e.message, false);
	}
};

/**
 * 서버인증서값을 불러온다.
 * (서버인증서를 페이지 전환시 매번 호출하는 부하를 없애기 위해 쿠키에 저장해둡니다.)
 */
MagicPass.getServerCertificate = function()
{
	if(MagicPass.serverCertificate != null) return;

	MagicPass.log("getServerCertificate");
	var currentCookie = document.cookie + ";";
	var startPoint = currentCookie.indexOf(MagicPass.cookieName);
	
	if(startPoint > -1)
	{
		var s = currentCookie.substring(startPoint + MagicPass.cookieName.length);
		s = s.substring(0, s.indexOf(";"));
		
		if(s != "")
		{
			MagicPass.serverCertificate = window.unescape(s);
			return;
		}
	}
	
	MagicPass.request("GET_SERVER_CERTIFICATION", MagicPass.setServerCertificate);
};

/**
 * 서버인증서의 값을 저장합니다.
 */
MagicPass.setServerCertificate = function(xmlData)
{
	var success = MagicPass.xmlParse(xmlData, "success");
	var message = MagicPass.xmlParse(xmlData, "message");
	
	if(success)
	{
		MagicPass.serverCertificate = message;
		document.cookie = MagicPass.cookieName + window.escape(message) + ";domain=" + document.domain + ";"; 
	}
	else
	{
		MagicPass.error("To Server Certificate loaded Error.");
	}
};
/*--------------------------------------------------------------
	String object extension
--------------------------------------------------------------*/
/**
 * 입력받은 String타입 객체가 null, ""(빈문자열), undefined 일 경우를 확인합니다.
 * 형식은 new String().isNull("문자열") 또는, "문자열".isNull()로 사용가능합니다.
 * 
 * @param
 * 		str : 비교할 문자열
 * @return
 * 		true : null값 일때
 * 		false : null값 아닐때
 */
String.prototype.isNull = function(str)
{
	var string = str || this;

	try
	{
		return !(string != null && string != undefined && string != "" && string != "null" && string != "undefined");
	}
	catch(e)
	{
		return true;
	}
};
/**
 * 입력받은 String타입 객체의 앞/뒤 공백을 제거합니다.
 * 형식은 new String().trim("문자열") 또는, "문자열".trim()과 같이 사용가능합니다.
 * 
 * @param
 * 		str : 문자열
 * @return
 * 		앞뒤 공백이 제거된 문자열
 */
String.prototype.trim = function(str)
{
	var string = str || this;

	try
	{
		return string.replace(/^\s+|\s+$/g, "");
	}
	catch(e)
	{
		return string;
	}
};

/*--------------------------------------------------------------
	Using for Applet 
--------------------------------------------------------------*/
function afterStart()
{
	MagicPass.log("[applet] afterStart");
	return true;
}

function refreshPage()
{
	MagicPass.log("[applet] refreshPage");
	window.location.reload();
	
	return true;
}

function beforeInit()
{
	MagicPass.log("[applet] beforeInit");
	return true;
}

function afterInit()
{
	MagicPass.log("[applet] afterInit");
	return true;
}

function beforeStart()
{
	MagicPass.log("[applet] beforeStart");
	return true;
}

function closeWindow()
{
	if (window.opener)
		window.opener.close();
	
	window.close();
}

/*--------------------------------------------------------
 * 	Auto Start
--------------------------------------------------------*/
MagicPass.ready();