// PageAddServer.cpp : implementation file
//

#include "stdafx.h"
#include "MgrNVE.h"
#include "PageAddServer.h"
#include "ConnectionManager.h"
#include "GroupName.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define DEVICE_SEARCH_TIMEOUT	20000

/////////////////////////////////////////////////////////////////////////////
// CPageAddServer dialog

CPageAddServer::CPageAddServer(CWnd* pParent, CMgrNVE* pMgrCM, CConnectionManager *pConnMgr)
	: CParamDlg(CPageAddServer::IDD, pParent, pMgrCM, pConnMgr)
{
	//{{AFX_DATA_INIT(CPageAddServer)
	m_strUserID = _T("");
	m_strUserPW = _T("");
	m_strURL = _T("rtsp://");
	m_strFilter = _T("");
	//}}AFX_DATA_INIT

	m_uListCnt = 0;
	m_uNumOfCh = 0;
	m_uIndex = 0;
	m_uStartTime = 0;
	m_uStopTime = 0;
	m_bAdminToolOpen = FALSE;
	ZeroMemory(m_uListNum, sizeof(m_uListNum));
	ZeroMemory(m_ClientInfo, sizeof(m_ClientInfo));
	m_pStorage = pMgrCM->GetStorage();
	m_pMsgMgr = pMgrCM->GetMsgManager();
	m_iWatingIndex = -1;
}

void CPageAddServer::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CPageAddServer)
	DDX_Control(pDX, IDC_CHK_ONE_PORT, m_chkOnePort);
	DDX_Control(pDX, IDC_STATIC_STATUS, m_stStatus);
	DDX_Control(pDX, IDC_CHK_FILTER, m_btnFilter);
	DDX_Control(pDX, IDC_EDIT_URL, m_edtURL);
	DDX_Control(pDX, IDC_CHK_MANUAL, m_chkManual);
	DDX_Control(pDX, IDC_LIST_SERVER, m_lstServer);
	DDX_Control(pDX, IDC_CB_PROTOCOL, m_cbProtocol);
	DDX_Text(pDX, IDC_EDT_USER_ID, m_strUserID);
	DDX_Text(pDX, IDC_EDT_USER_PW, m_strUserPW);
	DDX_Text(pDX, IDC_EDIT_URL, m_strURL);
	DDX_Text(pDX, IDC_EDIT_FILTER, m_strFilter);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CPageAddServer, CDialog)
	//{{AFX_MSG_MAP(CPageAddServer)
	ON_MESSAGE(WM_ADDCLIENT, AddClient)
	ON_MESSAGE(WM_INFORMATION, GetInfo)
	ON_WM_DESTROY()
	ON_NOTIFY(NM_CLICK, IDC_LIST_SERVER, OnClickListServer)
	ON_BN_CLICKED(IDC_BTN_ADD_SERVER, OnBtnAddServer)
	ON_BN_CLICKED(IDC_CHK_MANUAL, OnChkManual)
	ON_BN_CLICKED(IDC_CHK_FILTER, OnChkFilter)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CPageAddServer message handlers
BOOL CPageAddServer::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	// TODO: Add extra initialization here
	ULONG uLen;
	SSVType type;
	ULONG uValue;
	char szValue[NVE_MAX_STR_LENGTH];

	TRACE("Init socket\n");
	InitSocket(this->m_hWnd);
	m_bAdminToolOpen = TRUE;

	m_cbProtocol.ResetContent();
	m_cbProtocol.AddString("RTSP/RTP/UDP");
	m_cbProtocol.AddString("RTSP/RTP/TCP");
	m_cbProtocol.AddString("HTTP Tunneling");
	//m_cbProtocol.AddString("Multicast/UDP");

	if (SUCCEEDED(m_pStorage->Read("StreamingType", &type, &uLen, &uValue))) {
		m_cbProtocol.SetCurSel(uValue);
	}else{
		m_cbProtocol.SetCurSel(0);
	}

	if (m_pMgrNVE->IsSetup()) {
		//m_cbProtocol.EnableWindow(FALSE);
	}

	if (SUCCEEDED(m_pStorage->Read("URL", &type, &uLen, szValue))) {
		m_strURL = szValue;
	}

	m_strUserID = "root";
	m_strUserPW = "pass";

	if (SUCCEEDED(m_pStorage->Read("UserID", &type, &uLen, szValue))) {
		m_strUserID = szValue;
	}

	if (SUCCEEDED(m_pStorage->Read("UserPW", &type, &uLen, szValue))) {
		m_strUserPW = szValue;
	}

	if (SUCCEEDED(m_pStorage->Read("IPFilterStr", &type, &uLen, szValue))) {
		m_strFilter = szValue;
	}

	if (SUCCEEDED(m_pStorage->Read("IPFilterEnable", &type, &uLen, &uValue))) {
		if (uValue) {
			m_btnFilter.SetCheck(1);
		}
	}

	if (SUCCEEDED(m_pStorage->Read("UseOnePort", &type, &uLen, &uValue))) {
		if (uValue) {
			m_chkOnePort.SetCheck(1);
		}
	}

	TCHAR rgtsz[3][12] = {_T("Device IP"), _T("Device Name"), _T("Nick Name")};

	LV_COLUMN		lvcolumn;
	CRect rect;
	m_lstServer.GetWindowRect( &rect );

	for(int i = 0; i < 3; i++)  
	{
		lvcolumn.mask = LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT | LVCF_WIDTH | LVCF_ORDER;
		lvcolumn.fmt = LVCFMT_LEFT;
		lvcolumn.pszText = rgtsz[i];
		lvcolumn.iSubItem = i;
		lvcolumn.iOrder = i;

		switch(i)
		{
		case 0:
			lvcolumn.cx = 120;
			break;
		case 1:
			lvcolumn.cx = 120;
			break;
		}
		m_lstServer.InsertColumn(i, &lvcolumn);  
	}

	m_edtURL.EnableWindow(FALSE);
	
	for (i=0; i<4; i++) {
		CButton* pBtn = (CButton*)GetDlgItem(IDC_CHECK_CH0+i);
		pBtn->SetCheck(1);
	}

	UpdateData(FALSE);

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

BOOL CPageAddServer::SaveSetting()
{
	return TRUE;
}

BOOL CPageAddServer::ResetSetting()
{
	return TRUE;
}

BOOL CPageAddServer::UpdateSetting()
{
	return TRUE;
}

LRESULT CPageAddServer::AddClient(UINT wParam, LONG lParam)
{
	CString ServerAddr;

#if 0
	if (m_uStartTime == 0) {
		m_uStartTime = GetTickCount();
	}

	m_uStopTime = GetTickCount();
	if (m_uStopTime - m_uStartTime > DEVICE_SEARCH_TIMEOUT) {
		TRACE("Serach time is expired\n");
		CloseDll();
		m_bAdminToolOpen = FALSE;
		return E_FAIL;
	}
#endif

	if (m_uListCnt == MAX_CLIENT_NUM) {
		TRACE("Cannot add client\n");
		return E_FAIL;
	}

	SearchDevice(m_ClientInfo[lParam], lParam);
	AddClientToList(&m_ClientInfo[lParam], lParam);

	return S_OK;
}

LRESULT CPageAddServer::GetInfo(UINT wParam, LONG lParam)
{
	SearchDevice(m_ClientInfo[lParam], lParam);
	SetClientInfo(&m_ClientInfo[lParam], lParam);

	return S_OK;
}

void CPageAddServer::OnDestroy() 
{
	CDialog::OnDestroy();
	
	// TODO: Add your message handler code here
	if (m_bAdminToolOpen) {
		TRACE("close dll\n");
		CloseDll();
	}
}

void CPageAddServer::OnClickListServer(NMHDR* pNMHDR, LRESULT* pResult) 
{
	// TODO: Add your control notification handler code here
#if 0
	char szModel[NVE_MAX_STR_LENGTH];
	char szName[NVE_MAX_STR_LENGTH];
	ULONG uModel;
#endif

	NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
	
	m_uIndex = pNMListView->iItem;

#if 0
	m_lstServer.GetItemText(pNMListView->iItem, 1, szName, NVE_MAX_STR_LENGTH);

	ZeroMemory(szModel, sizeof(szModel));
	if (szName[0] == 'N' && szName[1] == 'V' && szName[2] == 'E') {
		memcpy(szModel, &szName[3], 4);
		uModel = atoi(szModel);
		switch(uModel) {
		case 1000:
			m_uNumOfCh = 1;
			break;
		case 2000:
			m_uNumOfCh = 2;
			break;
		case 4000:
			m_uNumOfCh = 4;
			break;
		}
	}

	if (szName[0] == 'I' && szName[1] == 'P' && szName[2] == 'C') {
		memcpy(szModel, &szName[3], 4);
		uModel = atoi(szModel);
		switch(uModel) {
		case 1100:
			m_uNumOfCh = 1;
			break;
		case 2100:
			m_uNumOfCh = 2;
			break;
		case 4100:
			m_uNumOfCh = 4;
			break;
		}
	}
#endif

	char szURL[NVE_MAX_STR_LENGTH];
	strcpy(szURL, "rtsp://");

	m_lstServer.GetItemText(m_uIndex, 0, &szURL[strlen("rtsp://")], NVE_MAX_STR_LENGTH);
	m_uNumOfCh = 1;
	int iIndex = -1;

	for (ULONG i=0; i<MAX_CLIENT_NUM; i++) {
		if (strcmp(szURL+strlen("rtsp://"), m_ClientInfo[i].sIp) == 0) {
			iIndex = i;
			break;
		}
	}

	if (iIndex < 0) {
		MessageBox("Getting server information. Click again after a while\n");
		return;
	}

	if (!m_ClientInfo[iIndex].RTSP[0]) {
		MessageBox("Getting server information. Click again after a while\n");
		return;
	}

	safe_strcat(szURL, ":");
	safe_strcat(szURL, m_ClientInfo[iIndex].RTSP);
	GetChannelNum((LPSTR)(LPCSTR)szURL);

	*pResult = 0;
}

void CPageAddServer::SetChannelNum()
{
	CButton *pBtn;
	ULONG i;

	switch(m_uNumOfCh) {
	case 1:
		for (i=0; i<4; i++) {
			pBtn = (CButton*)GetDlgItem(IDC_CHECK_CH0+i);
			if (i==0) {
				pBtn->SetCheck(1);
				continue;
			}
			pBtn->EnableWindow(FALSE);
		}
		break;
	case 2:
		for (i=0; i<4; i++) {
			pBtn = (CButton*)GetDlgItem(IDC_CHECK_CH0+i);
			if (i<2) {
				pBtn->EnableWindow(TRUE);
			}
			if (i>1) {
				pBtn->EnableWindow(FALSE);
				continue;
			}
			pBtn->SetCheck(1);
		}
		break;
	case 4:
		for (i=0; i<4; i++) {
			pBtn = (CButton*)GetDlgItem(IDC_CHECK_CH0+i);
			pBtn->EnableWindow(TRUE);
			pBtn->SetCheck(1);
		}
		break;
	}
}

void CPageAddServer::OnBtnAddServer() 
{
	// TODO: Add your control notification handler code here
	char szURL[NVE_MAX_STR_LENGTH];
	char szIP[NVE_MAX_STR_LENGTH];
	ULONG uProtocol = m_cbProtocol.GetCurSel()+1;
	ULONG i;
	int iIndex = -1;

	UpdateData(TRUE);

	if (m_chkManual.GetCheck() == 0) {
		m_lstServer.GetItemText(m_uIndex, 0, szIP, NVE_MAX_STR_LENGTH);

		for (i=0; i<MAX_CLIENT_NUM; i++) {
			if (strcmp(m_ClientInfo[i].sIp, szIP) == 0) {
				iIndex = i;
				break;
			}
		}
		if (iIndex < 0) {
			return;
		}

		sprintf(szURL, "rtsp://%s", szIP);

		if (strcmp(m_ClientInfo[iIndex].RTSP, "") == 0) {
			MessageBox("Getting server information. Retry after a while...");
			return;
		}

		if (m_cbProtocol.GetCurSel() != NET5_ST_HTTP_TUNNELING-1) {
			sprintf(szURL, "%s:%s", szURL, m_ClientInfo[iIndex].RTSP);
		}
	}else {
		strcpy(szURL, (LPSTR)(LPCSTR)m_strURL);
		m_uNumOfCh = 4;
		m_pStorage->Write("URL", SSVT_TEXT, strlen(szURL), szURL);
	}

	if (m_chkOnePort.GetCheck()) {
		strcat(szURL, "/ch0");
	}

	for (i=0; i<m_uNumOfCh; i++) {
		CButton *pBtn = (CButton*)GetDlgItem(IDC_CHECK_CH0+i);
		if (pBtn->GetCheck()) {
			if (!m_pMgrNVE->AddServer(i, szURL, uProtocol, m_strUserID, m_strUserPW)) {
				TRACE("Add server failed[%s]\n", szURL);
				//return;
			}
		}
		GetNextURL(i+1, (LPSTR)(LPCSTR)szURL);
	}

	ULONG uStreamingType = m_cbProtocol.GetCurSel();
	m_pStorage->Write("StreamingType", SSVT_DWORD, sizeof(DWORD), &uStreamingType);
	m_pStorage->Write("UserID", SSVT_TEXT, strlen((LPSTR)(LPCSTR)m_strUserID), (LPSTR)(LPCSTR)m_strUserID);
	m_pStorage->Write("UserPW", SSVT_TEXT, strlen((LPSTR)(LPCSTR)m_strUserPW), (LPSTR)(LPCSTR)m_strUserPW);
	ULONG uUseOnePort = m_chkOnePort.GetCheck();
	m_pStorage->Write("UseOnePort", SSVT_DWORD, sizeof(DWORD), &uUseOnePort);
}

BOOL CPageAddServer::GetNextURL(int uCh, char *pszURL)
{
	char* pszProtocol;
	char* pszAddr;
	char *pszIP;
	char* pszPort;
	char *pszMulticast;
	ULONG uPort = 0;
	char szURL[NVE_MAX_STR_LENGTH];
	BOOL bDirServer = FALSE;
	char *pToken;

	if (m_cbProtocol.GetCurSel() == NET5_ST_HTTP_TUNNELING-1) {
		if (strncmp(pszURL, "rtsp://", strlen("rtsp://")) != 0) {
			return FALSE;
		}

		strcpy(szURL, pszURL);
		pToken = strstr(szURL, "://");
		if (!pToken) return FALSE;
		pToken += 3;
		pToken = strstr(pToken, "/");
		if (pToken) {
			pToken[0] = 0;
		}

		sprintf(pszURL, "%s/%d", szURL, uCh);

		return TRUE;
	}

	if (strncmp(pszURL, "rtsp://", strlen("rtsp://")) != 0) {
		bDirServer = TRUE;
	}

	pszMulticast = strstr(pszURL, "multicast");
	if (pszMulticast) {
		ULONG uPos = pszMulticast-pszURL;
		pszURL[uPos-1] = 0;
	}

	pszProtocol = strtok(pszURL, ":");
	if(pszProtocol == NULL){
		return FALSE;
	}

	pszAddr = strtok(NULL, ":");
	if(pszAddr == NULL){
		return FALSE;
	}

	pszPort = strtok(NULL, ":");
	if(pszPort){
		uPort = atoi(pszPort);
	}else{
		uPort = NVE_DEFAULT_RTSP_PORT;
	}

	if (m_chkOnePort.GetCheck()) {
		pszIP = strtok(pszAddr, "/ch");
		if (pszIP == NULL) {
			return FALSE;
		}

		sprintf(szURL, "%s:%s/ch%d", pszProtocol, pszAddr, uCh);
	} else {
		if (bDirServer) {
			char szTemp[NVE_MAX_STR_LENGTH];
			safe_strcpy(szTemp, pszAddr);
			pToken = strtok(szTemp, "/");
			if (!pToken) return FALSE;
			ULONG uDirPort = atoi(pToken);
			ULONG uCh;
			pToken = strtok(NULL, "/");
			if (pToken) {
				uCh = atoi(pToken);
			} else {
				uCh = 0;
			}
			uCh++;
			sprintf(szURL, "%s:%d/%d", pszProtocol, uDirPort, uCh);
		} else {
			uPort++;
			if (pszMulticast) {
				sprintf(szURL, "%s:%s:%d/%s", pszProtocol, pszAddr, uPort, pszMulticast);
			} else {
				sprintf(szURL, "%s:%s:%d", pszProtocol, pszAddr, uPort);
			}
		}
	}
	
	strcpy(pszURL, szURL);

	return TRUE;
}

void CPageAddServer::OnChkManual() 
{
	// TODO: Add your control notification handler code here
	if (m_chkManual.GetCheck() == 0) {
		m_edtURL.EnableWindow(FALSE);
		m_lstServer.EnableWindow(TRUE);
	}else{
		for (ULONG i=0; i<4; i++) {
			CButton *pBtn = (CButton*)GetDlgItem(IDC_CHECK_CH0+i);
			pBtn->EnableWindow(TRUE);
		}
		m_edtURL.EnableWindow(TRUE);
		m_lstServer.EnableWindow(FALSE);
	}
}

BOOL CPageAddServer::GetChannelNum(char *pszURL)
{
	int iIndex = -1;
	m_WaitServer[m_iWatingIndex].bAvailable = FALSE;
	for (ULONG i=0; i<MAX_WAIT_SERVER; i++) {
		if (m_WaitServer[i].ThreadGetChannel.GetState() == TS_STOP) {
			iIndex = i;
			break;
		}
	}

	if (iIndex < 0) {
		return FALSE;
	}

	safe_strcpy(m_WaitServer[iIndex].szURL, pszURL);
	m_iWatingIndex = iIndex;
	if (!m_WaitServer[iIndex].ThreadGetChannel.StartThread(ThreadGetChannelProcStub, this, &m_WaitServer[iIndex], 0)) {
		TRACE("Cannot create thread\n");
		return FALSE;
	}
	m_WaitServer[iIndex].bAvailable = TRUE;
	
	return TRUE;
}

/*void CPageAddServer::EnableProtocol(BOOL bEnable)
{
	m_cbProtocol.EnableWindow(bEnable);
}*/

void CPageAddServer::OnChkFilter() 
{
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);

	m_uListCnt = 0;
	m_lstServer.DeleteAllItems();
	int iCheck = m_btnFilter.GetCheck();
	m_pStorage->Write("IPFilterStr", SSVT_TEXT, m_strFilter.GetLength(), (LPSTR)(LPCSTR)m_strFilter);
	m_pStorage->Write("IPFilterEnable", SSVT_DWORD, sizeof(iCheck), &iCheck);

	for (ULONG i=0; i<MAX_CLIENT_NUM; i++) {
		if (!m_ClientInfo[i].sIp) {
			continue;
		}
		if (!AddClientToList(&m_ClientInfo[i], i)) {
			continue;
		}
		if (!SetClientInfo(&m_ClientInfo[i], i)) {
			continue;
		}
	}
}

BOOL CPageAddServer::AddClientToList(Clientinfo *pInfo, ULONG uIndex)
{
	if (m_btnFilter.GetCheck()) {
		if (m_strFilter != "") {
			char *pszText = strstr(pInfo->sIp, (LPSTR)(LPCSTR)m_strFilter);
			if (pszText == NULL) {
				return FALSE;
			}
		}
	}

	if (strcmp(pInfo->sIp, "") == 0) {
		return FALSE;
	}

	for (int i=0; i<m_lstServer.GetItemCount(); i++) {
		char szIP[NVE_MAX_STR_LENGTH];
		m_lstServer.GetItemText(i, 0, szIP, NVE_MAX_STR_LENGTH);

		if (strcmp(pInfo->sIp, szIP) == 0) {
			return FALSE;
		}
	}

	char szName[8];
	ZeroMemory(szName, sizeof(szName));
	memcpy(szName, pInfo->Name, 4);
	if (strcmp(szName, "AXIS") == 0) {
		return FALSE;
	}

	if (!m_lstServer.GetSafeHwnd()) {
		return FALSE;
	}

	LV_ITEM lvitem;

	lvitem.iItem = m_uListCnt;
	lvitem.mask = LVIF_TEXT|LVIF_IMAGE|LVIF_INDENT|LVIF_PARAM;
	lvitem.iSubItem = 0;
	lvitem.iImage = 0;
	lvitem.stateMask = LVIS_STATEIMAGEMASK;
	lvitem.state = INDEXTOSTATEIMAGEMASK(1);
	lvitem.pszText = (LPSTR)(LPCTSTR)pInfo->sIp;
	m_uListNum[uIndex] = m_lstServer.InsertItem(&lvitem);
	m_lstServer.SetItemText(m_uListNum[uIndex], 1, pInfo->Name);
	m_uListCnt++;

	return TRUE;
}

BOOL CPageAddServer::SetClientInfo(Clientinfo *pInfo, ULONG uIndex)
{
	if (m_btnFilter.GetCheck()) {
		if (m_strFilter != "") {
			if (!strstr(pInfo->sIp, (LPSTR)(LPCSTR)m_strFilter)) {
				return FALSE;
			}
		}
	}

	if (strcmp(pInfo->RTSP, "") == 0) {
		strcpy(pInfo->RTSP, "554");
	}

	if (!m_lstServer.GetSafeHwnd()) {
		return FALSE;
	}

	for (int i=0; i<m_lstServer.GetItemCount(); i++) {
		char szName[NVE_MAX_STR_LENGTH];
		m_lstServer.GetItemText(i, 0, szName, NVE_MAX_STR_LENGTH);

		if (strcmp(pInfo->sIp, szName) == 0) {
			m_lstServer.SetItemText(i, 2, pInfo->NickName);
			//TRACE("######## ip[%s], port[%s]\n", pInfo->sIp, pInfo->RTSP);
		}
	}

	return TRUE;
}

DWORD WINAPI CPageAddServer::ThreadGetChannelProcStub(LPVOID lpParameter)
{
	THREAD_PARAM_SET *pParamSet = (THREAD_PARAM_SET*)lpParameter;
	CPageAddServer *pAddServer = (CPageAddServer*)pParamSet->pParam2;

	return static_cast<CPageAddServer*>(pAddServer)->ThreadGetChannelProc(lpParameter);
}

DWORD WINAPI CPageAddServer::ThreadGetChannelProc(LPVOID lpParameter)
{
	IUnknown *pUnknown;
	HMODULE hModule;
	UDA5GlobAPI Uda5Api;
	INet5 *pNet5Api;
	ICod5 *pCod5Api;
	BOOL bSuccess = FALSE;

	THREAD_PARAM_SET *pParamSet = (THREAD_PARAM_SET*)lpParameter;
	CUserThread *pThread = (CUserThread*)pParamSet->pParam1;
	WAIT_SERVER *pWaitServer = (WAIT_SERVER*)pParamSet->pParam3;

	m_stStatus.SetWindowText("Getting number of channel..\n");

	do {
		hModule = LoadLibrary("UdaNVE.dll");
		if(hModule){
			*(FARPROC*)&Uda5Api.Cmn5CreateInstance  = GetProcAddress(hModule,"Cmn5CreateInstance");
		}else{
			break;
		}
		
		Uda5Api.Cmn5CreateInstance(&pUnknown);
		pUnknown->QueryInterface (IID_INet5,(void**)&pNet5Api);
		pUnknown->QueryInterface (IID_ICod5,(void**)&pCod5Api);
		pUnknown->Release();

		if (!pNet5Api || !pCod5Api) {
			break;
		}

		if (!pNet5Api->Net5ConnectEx(pWaitServer->szURL, NET5_ST_RTP_TCP, 3)) {
			break;
		}

		CMN5_BOARD_INFO_DESC InfoDesc = { sizeof(COD5_BOARD_INFO), CMN5_BOARD_INFO_VERSION };
		COD5_BOARD_INFO BoardInfo;
		if (!pCod5Api->Cod5GetBoardInfo(0, &InfoDesc, &BoardInfo)) {
			break;
		}

		m_uNumOfCh = BoardInfo.uMaxChannel;
		SetChannelNum();
		bSuccess = TRUE;

		m_stStatus.SetWindowText("Done\n");
	} while (0);

	if (pWaitServer->bAvailable && !bSuccess) {
		m_stStatus.SetWindowText("Cannot get number of channel\n");
	}

	if (pNet5Api) {
		pNet5Api->Net5Logout();
		pNet5Api->Net5Disconnect();
		pNet5Api->Release();
		pNet5Api = NULL;
	}

	if (pCod5Api) {
		pCod5Api->Release();
		pCod5Api = NULL;
	}

	if (hModule) {
		FreeLibrary(hModule);
		hModule = NULL;
	}

	pThread->ReleaseHandle();

	return 0;
}