WZ_UpdateModule_DLL.rar Update.cpp

www.pudn.com > WZ_UpdateModule_DLL.rar > Update.cpp
 
#include "WZ_UM.h" 
#include "ReadScript.h" 
#include "resource.h" 
#include "UpdateDefine.h" 
#include "Tlhelp32.h" 
 
#include ".\wz_um.h" 
 
 
/////////////////////////////////////////////////////////////////////////////////////// 
/* 
	기본 업데이트 클래스 : 이 클래스에서 FTP 와 HTTP 업데이트 클래스가 상속 받는다. 
*/ 
 
WZ_DECLAREDLL CWZUpdateModule::CWZUpdateModule() 
{ 
	InitializeCriticalSection (& m_critERROR_MSG); 
 
	memset (m_szIPADDR, '\0', sizeof(m_szIPADDR)); 
	m_wPORT = 0; 
	memset (m_szID, '\0', sizeof(m_szID)); 
	memset (m_szPASS, '\0', sizeof(m_szPASS)); 
	m_lpFN_EventCallbackProc = NULL; 
	m_iCurrentState = STATE_DISCONNECTED; 
	m_bCancelUpdate = FALSE; 
	m_uUpdateFolderCount = 0; 
	m_strtUpdatingFileInfo.lpszErrorMsg = m_szLastErrorMsg; 
	m_bUseEventProc = FALSE; 
	m_nUpdateThreadID = 0; 
	m_bLoadUpdateInfo = FALSE; 
	m_nServerNumber = 0; 
} 
 
 
WZ_DECLAREDLL CWZUpdateModule::CWZUpdateModule (LPSTR lpszIPADDR, WORD wPORT, LPSTR lpszID, LPSTR lpszPASS) 
{ 
	InitializeCriticalSection (& m_critERROR_MSG); 
 
	strcpy (m_szIPADDR, lpszIPADDR); 
	m_wPORT = wPORT; 
	strcpy (m_szID, lpszID); 
	strcpy (m_szPASS, lpszPASS); 
	m_lpFN_EventCallbackProc = NULL; 
	m_iCurrentState = STATE_DISCONNECTED; 
	m_bCancelUpdate = FALSE; 
	m_uUpdateFolderCount = 0; 
	m_strtUpdatingFileInfo.lpszErrorMsg = m_szLastErrorMsg; 
	m_bUseEventProc = FALSE; 
	m_nUpdateThreadID = 0; 
	m_bLoadUpdateInfo = FALSE; 
	m_nServerNumber = 0; 
} 
 
 
WZ_DECLAREDLL CWZUpdateModule::~CWZUpdateModule() 
{ 
	DeleteCriticalSection(&m_critERROR_MSG); 
} 
 
 
WZ_DECLAREDLL VOID CWZUpdateModule::SetLastErrorMsg (INT iERROR_MODE, INT iERROR_CODE, LPSTR szUSER_MSG) 
{ 
	EnterCriticalSection (& m_critERROR_MSG); 
 
	DWORD dwERROR_CODE = iERROR_CODE; 
	DWORD dwBUFFER_LEN = sizeof(m_szLastErrorMsg); 
 
	switch (iERROR_MODE) 
	{ 
	case CWZUpdateModule::ERROR_SYSTEM : 
		if (iERROR_CODE >= 12000) 
			InternetGetLastResponseInfo (&dwERROR_CODE, m_szLastErrorMsg, &dwBUFFER_LEN); 
		else 
			FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, iERROR_CODE, 0, m_szLastErrorMsg, sizeof (m_szLastErrorMsg), NULL); 
 
		m_iLastErrorMode = CWZUpdateModule::ERROR_SYSTEM; 
		m_strtUpdatingFileInfo.iErrorCode = iERROR_CODE; 
		break; 
	case CWZUpdateModule::ERROR_USER : 
		strcpy (m_szLastErrorMsg, szUSER_MSG); 
		m_iLastErrorMode = CWZUpdateModule::ERROR_USER; 
		m_strtUpdatingFileInfo.iErrorCode = 0; 
		break; 
	default : 
		m_szLastErrorMsg[0] = '\0'; 
		m_iLastErrorMode = CWZUpdateModule::ERROR_NONE; 
		m_strtUpdatingFileInfo.iErrorCode = 0; 
		break; 
	} 
 
	AddEvent( EVENT_ERROR ); 
 
	LeaveCriticalSection (& m_critERROR_MSG); 
} 
 
 
WZ_DECLAREDLL const LPSTR CWZUpdateModule::GetLastErrorMsg() 
{ 
	return m_szLastErrorMsg; 
} 
 
 
WZ_DECLAREDLL const INT CWZUpdateModule::GetLastErrorCode() 
{ 
	return m_iLastErrorCode; 
} 
 
 
WZ_DECLAREDLL unsigned __stdcall CWZUpdateModule::UpdateWorkerThread (LPVOID lpParam) 
{ 
	CWZUpdateModule * lpWZUM = (CWZUpdateModule *) lpParam; 
 
	if ( lpWZUM->UpdateRun() == TRUE ) 
		lpWZUM->AddEvent( EVENT_UPDATE_END_SUCCESS ); 
	else 
		lpWZUM->AddEvent( EVENT_UPDATE_END_FAIL ); 
	 
	return 0; 
} 
 
 
WZ_DECLAREDLL BOOL CWZUpdateModule::LoadLocalVerInfo() 
{ 
	if( IsUpdateInfoLoad() ) 
	{ 
		byte byVer[3]; 
		GetVersionFromString( m_info.m_szServerVer[m_nServerNumber], byVer[0], byVer[1], byVer[2] ); 
		m_btLocalVer1 = byVer[0]; 
		m_btLocalVer2 = byVer[1]; 
		m_btLocalVer3 = byVer[2]; 
		m_uLocalTotalVersion = GetTotalVersion( m_btLocalVer1, m_btLocalVer2, m_btLocalVer3 ); 
	} 
	else 
		return FALSE; 
 
	return TRUE; 
} 
 
 
WZ_DECLAREDLL BOOL CWZUpdateModule::SaveLocalVerInfo() 
{ 
	return m_info.SaveVersionInfo( m_btLocalVer1, m_btLocalVer2, m_btLocalVer3, m_nServerNumber ); 
} 
 
 
WZ_DECLAREDLL BOOL CWZUpdateModule::CheckVersion(LPSTR lpszFilePath) 
{ 
	if ( (!lpszFilePath) || (!strcmp(lpszFilePath, ""))) 
		return FALSE; 
 
	m_uUpdateFolderCount = 0; 
 
	SMDToken Token; 
	 
	__try 
	{ 
		if( (SMDFile = fopen(m_szVersionFileName, "r")) == NULL ) 
			return FALSE; 
		 
		while(TRUE) 
		{ 
			Token = (*GetToken)(); 
			if( Token == END ) 
				break; 
 
			if( Token == NAME )  
			{ 
				strcpy(m_strtUpdateFolderInfo[m_uUpdateFolderCount].m_szFolderName, TokenString); 
 
				byte byVer[3]; 
				GetVersionFromString( TokenString, byVer[0], byVer[1], byVer[2] ); 
 
				m_strtUpdateFolderInfo[m_uUpdateFolderCount].m_btVer1 = byVer[0]; 
				m_strtUpdateFolderInfo[m_uUpdateFolderCount].m_btVer2 = byVer[1]; 
				m_strtUpdateFolderInfo[m_uUpdateFolderCount].m_btVer3 = byVer[2]; 
				m_strtUpdateFolderInfo[m_uUpdateFolderCount].m_uTotalVersion = GetTotalVersion( byVer[0], byVer[1], byVer[2] ); 
 
				//새로운 버전이 현재 로컬의 버전보다 크다면.. 업데이트할 폴더의 개수를 증가시킨다. 
				if (m_strtUpdateFolderInfo[m_uUpdateFolderCount].m_uTotalVersion > m_uLocalTotalVersion) 
					m_uUpdateFolderCount++; 
 
				if( m_uUpdateFolderCount > MAX_FOLDERINFO-1 ) 
					return FALSE; 
			} 
		} 
	} 
	__finally  
	{ 
		if (SMDFile) 
			fclose(SMDFile); 
 
		CHAR szVERFILE_NAME [MAX_PATH], szVERFILE_EXE [MAX_PATH], szVERFILE_FULLNAME [MAX_PATH]; 
		_splitpath (lpszFilePath, NULL, NULL, szVERFILE_NAME, szVERFILE_EXE); 
		wsprintf(szVERFILE_FULLNAME, "%s%s", szVERFILE_NAME, szVERFILE_EXE); 
		DeleteFile (szVERFILE_FULLNAME); 
	} 
 
	return TRUE; 
} 
 
 
// 이 함수는 서버의 버전파일을 다운 받아서, 현재 클라이언트의 버전과 비교하여, 
// 업데이트를 할지 안 할지를 결정하는 함수다. 
// 버전체크 실패면, RESULT_FAIL 
// 업데이트 파일이 없으면, RESULT_NOMORE_UPDATE_FILES 
// 성공이면, RESULT_SUCCESS 
WZ_DECLAREDLL eRESULT_CONSTANT CWZUpdateModule::CheckUpdateFiles() 
{ 
	// 1 . 서버에 있는 버전 파일을 다운 받는다. 
	// 현재 다운받을려는 서버의 폴더에 있는 버전 파일을 다운 받는다. 받은 파일은 로컬에 다운받는다. 
	TCHAR szVerFilePath[MAX_PATH]; 
	GetVersionFilePath( szVerFilePath, MAX_PATH ); 
	if ( !DownloadFile( szVerFilePath ) ) 
		return RESULT_FAIL; 
	 
	// 2 . 받은 버전 파일에서 현재 클라이언트의 버전과 비교하여 받을 파일이 있으면 해당 폴더에서 목록파일을 받는다. 
	if ( !CheckVersion(m_szVersionFileName) ) 
	{ 
		MessageBox (HWND_DESKTOP, "checking version file error", "error", MB_OK | MB_ICONERROR); 
		return RESULT_FAIL; 
	} 
 
	if (m_uUpdateFolderCount == 0)  //업데이트 할 파일이 없다. 
		return RESULT_NOMORE_UPDATE_FILES; 
 
	return RESULT_SUCCESS; 
} 
 
 
// lpszFilePath는 리스트 파일의 이름이다. 기본적으로 wz_filelist.dat 이다. 
WZ_DECLAREDLL BOOL CWZUpdateModule::UpdateRun() 
{ 
	CHAR szCurrentLocalDirectory [MAX_PATH];						// 현재 로컬 호스트의 디렉토리 경로 
	CHAR szCurrentLocalFilePath [MAX_PATH]={0,};					// 로컬 호스트의 디렉토리 경로 
 
	CHAR szErrorMsg[256] = {0,};									// 에러 메시지 출력용 
 
	m_strtUpdatingFileInfo.Reset(); 
 
	// 현재 실행파일의 디렉토리를 구한다. 
	GetModuleDirectory( szCurrentLocalDirectory, MAX_PATH ); 
 
	// 업데이트 전에 현재의 로컬 버전을 알린다. 
	LoadLocalVerInfo(); 
	m_strtUpdatingFileInfo.btVer1 = m_btLocalVer1;  
	m_strtUpdatingFileInfo.btVer2 = m_btLocalVer2;  
	m_strtUpdatingFileInfo.btVer3 = m_btLocalVer3;  
	AddEvent( EVNET_VERSION_ALARM ); 
 
	for (UINT i = 0 ; i < m_uUpdateFolderCount ; i++ ) 
	{ 
		//파일리스트 파일의 경로를 얻어온다. 
		CHAR szFileListFilePath[MAX_PATH];	 
		GetFileListFilePath( szFileListFilePath, MAX_PATH, m_strtUpdateFolderInfo[i].m_szFolderName ); 
 
		//리스트 파일 다운로드, 다운받을 위치를 지정하지 않으면 실행파일이 있는 곳에 다운로드 한다. 
		if ( !DownloadFile(szFileListFilePath) ) 
			return FALSE; 
		 
		char szVerFolerPath[MAX_PATH];	 
		GetVersionFolderPath( szVerFolerPath, MAX_PATH, m_strtUpdateFolderInfo[i].m_szFolderName ); 
		 
		__try 
		{ 
			BOOL bRet = DownloadFilesOnFileList( szVerFolerPath ); 
			if( bRet == FALSE) 
				return FALSE;   //하나만 잘 못되도, 프로그램을 종료한다. 
 
			// 여기까지 왔으면 윗 버전으로의 업데이트가 성공한 것이므로 업된 버전 저장 
			m_btLocalVer1 = m_strtUpdateFolderInfo[i].m_btVer1; 
			m_btLocalVer2 = m_strtUpdateFolderInfo[i].m_btVer2; 
			m_btLocalVer3 = m_strtUpdateFolderInfo[i].m_btVer3; 
			SaveLocalVerInfo();				 
 
			// 업데이트 중 프로그램 버전을 알린다. 
			m_strtUpdatingFileInfo.btVer1 = m_btLocalVer1;  
			m_strtUpdatingFileInfo.btVer2 = m_btLocalVer2;  
			m_strtUpdatingFileInfo.btVer3 = m_btLocalVer3;  
			AddEvent( EVNET_VERSION_ALARM ); 
 
			////////////////////////////////////////////////////////////////////////// 
		} 
		__finally  
		{ 
			if (SMDFile) 
				fclose(SMDFile); 
 
			DeleteFile( DEFAULT_FILELIST_FILE ); 
			DeleteFile( m_szVersionFileName ); 
			m_iCurrentState = STATE_CONNECTED; 
		} 
	} 
 
	return TRUE; 
} 
 
 
WZ_DECLAREDLL BOOL CWZUpdateModule::AddEvent(int nEvent) 
{ 
	// 현재 상태가 DISCONNECTED상태이면 콜백함수를 호출하지 않는다. 
	BOOL bRet = FALSE; 
	if ( m_lpFN_EventCallbackProc != NULL && m_bUseEventProc != FALSE )			 
	{ 
		m_lpFN_EventCallbackProc( nEvent, (LPVOID) this, m_strtUpdatingFileInfo); 
		bRet = TRUE; 
	}	 
 
	return bRet; 
} 
 
WZ_DECLAREDLL BOOL CWZUpdateModule::UpdateStop() 
{ 
	//업데이트 중이라는건 현재 다운로드 쓰레드가 돌고 있다는 뜻이다. 
	m_bCancelUpdate = TRUE; 
	m_bUseEventProc = FALSE; 
 
	WaitForSingleObject( m_hUpdateThread, 1000 ); 
 
	m_bUseEventProc = TRUE; 
	AddEvent( EVENT_FILEDOWNLOAD_STOP ); 
	return TRUE;	 
} 
 
WZ_DECLAREDLL BOOL CWZUpdateModule::SetEventCallBackProc (LPFUNC_RECEIVEEVENT lpFN_EventCallbackFunc ) 
{ 
	if( lpFN_EventCallbackFunc == NULL) 
		return FALSE; 
 
	m_lpFN_EventCallbackProc = lpFN_EventCallbackFunc; 
 
	return TRUE; 
} 
 
WZ_DECLAREDLL void CWZUpdateModule::SetUseEventProc ( BOOL bUse ) 
{ 
	m_bUseEventProc = bUse; 
} 
 
// 01.02.03 과 같은 문자열에서 각각의 버전을 뽑아내는 함수. 
WZ_DECLAREDLL void CWZUpdateModule::GetVersionFromString( char* pszVersion, byte& byVer1, byte& byVer2, byte& byVer3 ) 
{ 
//	char* szTok; 
	string strVersion = pszVersion; 
	int nCnt = 0; 
	byte byVersion[3]; 
 
	while( strVersion.size() != 0) 
	{ 
		int nIdx = strVersion.find('.'); 
		if( nIdx == string::npos ) 
		{ 
			if( !strVersion.empty() ) 
			{ 
				byVersion[nCnt] = atoi( strVersion.c_str() ); 
			} 
 
			strVersion.clear(); 
		} 
		else 
		{ 
			string strVer = strVersion.substr( 0, nIdx ); 
			byVersion[nCnt] = atoi( strVer.c_str() ); 
			strVersion.erase( 0, nIdx + 1); 
			nCnt++; 
		} 
	} 
 
	//리턴값 대입. 
	byVer1= byVersion[0]; 
	byVer2= byVersion[1]; 
	byVer3= byVersion[2]; 
} 
 
//각 버전의 유일한 값을 같기위한 토탈 버전 계산.. 
WZ_DECLAREDLL unsigned int CWZUpdateModule::GetTotalVersion( const byte byVer1, const byte byVer2, const byte byVer3 ) 
{ 
	return (byVer1*65536)+(byVer2*256)+byVer3; 
} 
 
//이 함수는 AutoUpdater에서 호출된다. 
//StartUpdate 
//버전파일을 다운받아 버전을 체크해서 업데이트 할 버전이 있으면, 
//업데이트 thread를 돌려서, 파일을 다운로드 한다. 
WZ_DECLAREDLL BOOL CWZUpdateModule::StartUpdate() 
{ 
	// 현재 살아 있는 클라이언트 프로세서가 있는지 없는지 체크한다. 
	BOOL bRet = CheckLiveProcess();  
	if(bRet == TRUE) //프로세서가 살아 있으면..  
	{ 
		AddEvent( EVENT_LIVE_PROCESS ); 
		return FALSE; 
	} 
 
	// 버전체크를 한다. 
	eRESULT_CONSTANT eRC = CheckUpdateFiles(); 
 
	if ( eRC == RESULT_FAIL ) 
		return FALSE; 
	else if( eRC == RESULT_NOMORE_UPDATE_FILES ) 
	{ 
		// 더 이상 없데이트 할 수 없으면, 현재 버전정보는 0 번 배열에 있다.. 
		m_strtUpdatingFileInfo.btVer1 = m_strtUpdateFolderInfo[0].m_btVer1; 
		m_strtUpdatingFileInfo.btVer2 = m_strtUpdateFolderInfo[0].m_btVer2; 
		m_strtUpdatingFileInfo.btVer3 = m_strtUpdateFolderInfo[0].m_btVer3; 
		AddEvent( EVENT_NOMORE_UPDATEFILE ); 
		return FALSE; 
	} 
 
	m_iCurrentState = STATE_FILE_DOWNLOADING; 
 
	//Update Thread 가동 
	m_nUpdateThreadID = 1; 
	m_hUpdateThread = (HANDLE) _beginthreadex (NULL, NULL, UpdateWorkerThread, (LPVOID) this, 0, &m_nUpdateThreadID); 
	if (m_hUpdateThread == INVALID_HANDLE_VALUE) 
	{ 
		if (m_lpFN_EventCallbackProc) 
		{ 
			SetLastErrorMsg(CWZUpdateModule::ERROR_SYSTEM, GetLastError()); 
			return FALSE; 
		} 
	} 
 
	return TRUE;	// 만일 FALSE라면 업데이트 프로세스 종료 
} 
 
//기본적으로 정의 되어 있는 기본값을 설정한다. 
WZ_DECLAREDLL void CWZUpdateModule::SetDefaultData(void) 
{ 
	if( IsUpdateInfoLoad() ) 
		strcpy (m_szVersionFileName, m_info.m_szFTP_VersionFileName ); 
	else 
		strcpy (m_szVersionFileName, DEFAULT_VERSION_FILE); 
} 
 
		 
WZ_DECLAREDLL void CWZUpdateModule::SetVersionFile(const char* pszFile) 
{ 
	strcpy(m_szVersionFileName, pszFile); 
} 
 
 
WZ_DECLAREDLL void	CWZUpdateModule::SetDownloadDirectory(const char* pszDirectory) 
{ 
	if(pszDirectory == NULL || (strcmp(pszDirectory, "") == 0) ) 
		m_strDownDirectory = ""; 
	else 
		m_strDownDirectory = pszDirectory; 
} 
 
 
WZ_DECLAREDLL const string	CWZUpdateModule::GetDownloadDirectory() 
{ 
	return m_strDownDirectory; 
} 
 
//로컬의 다운로드 절대 경로를 얻는다. 
WZ_DECLAREDLL void	CWZUpdateModule::GetLocalDownAbsoluteDir(string strRelativeDir, string& strAbsolteDir) 
{ 
	if( strRelativeDir.length() == 0 ) 
		strRelativeDir = "\\"; 
 
	//만일 m_strDownDirectory 가 null 이 들어 있을수 있다.. 따라서 그때는..  
	//현재 실행중인 디렉토리로 설정한다. 
 
	// 다운로드 디렉토리에 strRelativeDir(상대경로)를 덧붙여서 저장시킬 현재 로컬의 절대경로를 얻는다. 
	if(m_strDownDirectory.length() == 0) 
	{ 
		char szDir[MAX_PATH]; 
		GetModuleDirectory( szDir, MAX_PATH ); 
		strAbsolteDir = szDir; 
		strAbsolteDir += strRelativeDir; 
	} 
	else 
	{ 
		strAbsolteDir = m_strDownDirectory; 
		strAbsolteDir += "\\"; 
		strAbsolteDir += m_info.m_szServerName[m_nServerNumber]; 
		strAbsolteDir += strRelativeDir; 
	} 
} 
 
 
//현재 컴퓨터에 업데이트하고 있는 프로그램이 실행중인지 체크. 
//실행중인 프로그램이 하나라도 있으면 TRUE리턴 
//아니면 FASLE를 리턴.. 
WZ_DECLAREDLL BOOL	CWZUpdateModule::CheckLiveProcess() 
{ 
	//프로세서의 MAX값은 0-9까지 10개이다. 
	for(int i = 0; i < MAX_LIVE_PROCESS; i++) 
	{ 
		// 프로세스 체크 런쳐나 게임 클라이언트가 실행중인지 체크한다 
		HANDLE	hSnapShot; 
 
		//Get the snapshot of the system 
		hSnapShot = CreateToolhelp32Snapshot (TH32CS_SNAPALL, NULL); 
 
		PROCESSENTRY32 pEntry; 
		pEntry.dwSize = sizeof(pEntry); 
 
		//Get first process 
		Process32First (hSnapShot,&pEntry); 
 
		//Iterate thru all processes 
		DWORD dwPID = GetCurrentProcessId(); 
 
		while(TRUE) 
		{ 
			BOOL hRes = Process32Next (hSnapShot,&pEntry); 
			if(hRes == FALSE) 
				break; 
 
			if(dwPID == pEntry.th32ProcessID) 
				continue; 
 
			// 실행 중인지 체크하도록 한다. 
			if( strcmp(pEntry.szExeFile, m_info.m_szProcess[i] ) == 0 )  //현재 같은 프로그램이 실행중이라면.. 
			{ 
				return TRUE; 
			} 
 
		}// End While 
 
	}// End For 
 
	return FALSE; 
} 
 
 
WZ_DECLAREDLL void	CWZUpdateModule::GetModuleDirectory( char* szDirPath, int nSize ) 
{ 
	ZeroMemory( szDirPath, nSize ); 
	char szPath[128]; 
	char szDrive[40], szDir[256]; 
	GetModuleFileName( NULL, szPath, 128); 
	_splitpath( szPath, szDrive, szDir, NULL, NULL ); 
	sprintf( szDirPath, "%s%s", szDrive, szDir); 
} 
 
 
WZ_DECLAREDLL BOOL	CWZUpdateModule::Init(  ) 
{ 
	//로그데이터 초기화. 
	char szDir[MAX_PATH]; 
	GetModuleDirectory( szDir, MAX_PATH ); 
 
	BOOL bRet = m_info.LoadData(); 
	if( bRet == TRUE) 
	{ 
		m_bLoadUpdateInfo = TRUE; 
		strncpy( m_szIPADDR, m_info.m_szFTP_IP, MAX_PATH ); 
		m_wPORT = m_info.m_nFTP_Port; 
		SetDefaultDirectory( m_info.m_szServerName[m_nServerNumber] ); 
	} 
	else 
	{ 
		m_bLoadUpdateInfo = FALSE; 
		ZeroMemory( m_szIPADDR, MAX_PATH ); 
		strncpy( m_szIPADDR, "127.0.0.1", MAX_PATH ); 
		m_wPORT = DEFAULT_FTP_PORT; 
	} 
 
	if( !LoadLocalVerInfo() ) 
		return FALSE; 
 
	SetDefaultData(); 
 
	return TRUE; 
} 
 
WZ_DECLAREDLL void CWZUpdateModule::SetDefaultDirectory( char* pszDir ) 
{ 
	if( !pszDir )	return; 
 
	strncpy( m_szDefaultDirectory, pszDir, MAX_PATH ); 
} 
 
//기본 디렉토리 경로를 포함하는 FTP서버상의 버전파일 경로를 구한다. 
WZ_DECLAREDLL void CWZUpdateModule::GetVersionFilePath( TCHAR* pszVerFilePath, int nSize ) 
{ 
	if( m_szDefaultDirectory == NULL || (strcmp( m_szDefaultDirectory, "" ) == 0 ) ) 
		strncpy( pszVerFilePath, m_szVersionFileName, nSize );				//만일 디폴트 디렉토리가 없으면 루트에서 찾는다. 
	else 
		_snprintf( pszVerFilePath, nSize, "%s\\%s", m_szDefaultDirectory, m_szVersionFileName ); 
} 
 
//파일리스트 파일은 반드시 다운로드 받는 버전폴더에 존재해야 한다. 
//예 : AgentServer\00.00.01\filelist.dat 
WZ_DECLAREDLL void CWZUpdateModule::GetFileListFilePath( char* pszFilePath, int nSize, const char* pszVerFolder ) 
{ 
	if( m_szDefaultDirectory == NULL || (strcmp( m_szDefaultDirectory, "" ) == 0 ) ) 
		_snprintf( pszFilePath, nSize, "%s\\%s", pszVerFolder, DEFAULT_FILELIST_FILE ); 
	else 
		_snprintf( pszFilePath, nSize, "%s\\%s\\%s", m_szDefaultDirectory, pszVerFolder, DEFAULT_FILELIST_FILE ); 
} 
 
//버전폴더의 경로를 반환한다. 
WZ_DECLAREDLL void CWZUpdateModule::GetVersionFolderPath( char* pszFileName, int nSize, const char* pszVerFolder ) 
{ 
	if( m_szDefaultDirectory == NULL || (strcmp( m_szDefaultDirectory, "" ) == 0 ) ) 
		strncpy( pszFileName, pszVerFolder, nSize ); 
	else 
		_snprintf( pszFileName, nSize, "%s\\%s", m_szDefaultDirectory, pszVerFolder ); 
} 
 
 
WZ_DECLAREDLL void CWZUpdateModule::GetServerName( char* pszServerName, int nSize ) 
{ 
	_snprintf( pszServerName, nSize, "%s", m_info.m_szServerName[m_nServerNumber] ); 
}