appserverdlg.cpp

用过恒迅达交换机的人都知道。恒迅达交换机是需要在交换机内部运行中间程序来给脚本提供数据接口并且监控机器运行状态的。本程序即是完成以上功能！用C++开发、调用了数据库（sqlserver2000）存储过

	while (AnalysisSeatMessage(nID) == TRUE)
	{
		m_nSeatReceive ++;
		m_sSeatReceive.Format(_T("%d"), m_nSeatReceive);
		UpdateData(FALSE);
	}
}

//与HXD服务器通信接收处理函数
//处理过程与OnReceiveFromSeat类似
void CAppServerDlg::OnReceiveFromHXDServer(CHXDSocket *pSocket)
{
	INT nCount;

//	m_csReceQueue.Lock();
	while (nCount = pSocket->Receive(&m_sHXDServerInBuffer[m_nHXDServerInWritePtr], MAX_MESSAGE_SIZE))
	{
		if (nCount == SOCKET_ERROR)
		{
			nCount = pSocket->GetLastError();
//			m_csReceQueue.Unlock();
			break;
			return;
		}

		// 记录收发包日志
		if (m_bRecvFromHXD)
		{
			m_RecvHXDFile.Write(&m_sHXDServerInBuffer[m_nHXDServerInWritePtr], nCount);
			m_RecvHXDFile.Write("\n\r",2);	
		}


		//如果超出门限，将超出的部分移到缓冲区的头部
		m_nHXDServerInWritePtr += nCount;
		if (m_nHXDServerInWritePtr >= MAX_INBUFFER_CACHE)
		{
			m_nHXDServerInWritePtr -= MAX_INBUFFER_CACHE;
			::CopyMemory(m_sHXDServerInBuffer, &m_sHXDServerInBuffer[MAX_INBUFFER_CACHE], m_nHXDServerInWritePtr);
		}
		if (nCount < MAX_MESSAGE_SIZE)
		{
			break;
		}
	}
//	m_csReceQueue.Unlock();
	// Modified by LWJ 2002.5.10 
	
	PostMessage( WM_RECEIVEMESSAGE );
}

//座席连接处理函数
void CAppServerDlg::OnAcceptFromSeat(CListenSocket *pSocket)
{
	for (INT i = 0; i < MAX_SEAT_SUPPORTED; i ++)
	{
		if (m_pSeatSocket[i] == NULL)
		{
			break;
		}
	}
	m_pSeatSocket[i] = new CSeatSocket(this, i);
	if (m_pSeatSocket[i] == NULL)
	{
		AfxMessageBox(_T("分配内存出错!"));
		return;
	}
	if (pSocket->Accept(*m_pSeatSocket[i]) == FALSE)
	{
		delete m_pSeatSocket[i];
		m_pSeatSocket[i] = NULL;
		INT nError = pSocket->GetLastError();
		CString str;
		str.Format(_T("Accept(SeatSocket)错误! 错误代码:%d"), nError);
//		AfxMessageBox((LPCTSTR)str);
	}
	if (m_sSeatInBuffer[i] == NULL)
	{
		m_sSeatInBuffer[i] = new CHAR[INBUFFER_SIZE];
		if (m_sSeatInBuffer[i] == NULL)
		{
			AfxMessageBox(_T("分配内存出错!"));
			delete m_pSeatSocket[i];
			m_pSeatSocket[i] = NULL;
			return;
		}
		m_nSeatInReadPtr[i] = 0;
		m_nSeatInWritePtr[i] = 0;
	}
	m_pSeatSocket[i]->AsyncSelect(FD_READ | FD_CLOSE);
}

//连接消息处理函数
void CAppServerDlg::OnConnect() 
{
	// TODO: Add your control notification handler code here
	if (ConnectToHXDServer() == FALSE)
	{
		m_nWaitConnect = WAIT_CONNECT_SECONDS;
		CString str;
		str.Format(_T("%d秒后重新连接CTI服务器"), m_nWaitConnect);
		//((CButton *)GetDlgItem(IDC_CONNECT))->SetWindowText((LPCTSTR)str);
		//((CButton *)GetDlgItem(IDC_CONNECT))->EnableWindow();
		CString strTime;//=this->GetFormatTime();
		strTime="与CTI服务器连接失败!";
		//m_list2.InsertString(0,strTime);
		//if(m_list2.GetCount()>=100) m_list2.DeleteString(99);
		this->AddListMessage (3,strTime);
		Beep(1000,300);
	}
}

/* 服务器端的侦听Socket在Create时应指明服务器端的端口号和IP地址 */
/* 客户端的Socket在Create时可以不用指定端口号取默认值0 */
/* 客户端的Socket在Connect时要指明服务器端的侦听Socket的端口号和IP地址 */
/* 服务器端的Socket在Accept时不用Create一个Socket，只用new一个出Socket或定义一个Sokcet即可 */
//连接到HXD服务器处理函数
BOOL CAppServerDlg::ConnectToHXDServer()
{
	if (m_pHXDSocket == NULL || m_pHXDSocket->GetConnectState() == FALSE)
	{
		//((CButton *)GetDlgItem(IDC_CONNECT))->EnableWindow(FALSE);
		CString sErrorMessage;
		INT nError;
		if (m_pHXDSocket == NULL)
		{
			m_pHXDSocket = new CHXDSocket(this);
			if (m_pHXDSocket == NULL)
			{
				AfxMessageBox(_T("分配内存出错!"));
				return FALSE;
			}
			if (m_pHXDSocket->Create(0, SOCK_STREAM, FD_READ | FD_CONNECT | FD_CLOSE, (LPCTSTR)theApp.m_sAppIpAddress) == FALSE)
			{
				nError = m_pHXDSocket->GetLastError();
				sErrorMessage.Format(_T("Create(HXDSocket)错误! 错误号:%d!"), nError);
//				AfxMessageBox((LPCTSTR)sErrorMessage);
				return FALSE;
			}
		}
//		if (m_pHXDSocket->Connect((LPCTSTR)(theApp.m_sHXDIpAddress), htons(theApp.m_nHXDPort)) == FALSE) //htons
		if (m_pHXDSocket->Connect((LPCTSTR)(theApp.m_sHXDIpAddress), theApp.m_nHXDPort) == FALSE)
		{
			nError = m_pHXDSocket->GetLastError();
			if (nError != WSAEWOULDBLOCK)
			{
				sErrorMessage.Format(_T("Connect(HXDSocket)错误! 错误号:%d!"), nError);
//				AfxMessageBox((LPCTSTR)sErrorMessage);
				return FALSE;
			}
			else
			{
				m_nWaitConnect = WAIT_CONNECT_SECONDS;
			}
		}
		else
		{
			m_pHXDSocket->SetConnectState();
		}
	}
	
	//CString str=this->GetFormatTime();
	//str+="  连接服务器成功!";
	//this->AddListMessage(3,str);
	return TRUE;
}

void CAppServerDlg::OnTimer(UINT nIDEvent) 
{
	// TODO: Add your message handler code here and/or call default
	if(nIDEvent==500)
	{
		this->TimeSendOut();
		
	}
	if (nIDEvent == IDT_SECOND)
	{
		if (m_nWaitConnect > 0)
		{
			m_nWaitConnect --;
			CString str;
			str.Format(_T("%d秒后重新连接HXD服务器"), m_nWaitConnect);
			//((CButton *)GetDlgItem(IDC_CONNECT))->SetWindowText((LPCTSTR)str);
		}
		if (m_nWaitConnect == 0)
		{
			if (ConnectToHXDServer() == FALSE || m_pHXDSocket->GetConnectState() == FALSE)
			{
				m_nWaitConnect = WAIT_CONNECT_SECONDS;
				CString strTime;//=this->GetFormatTime();
				strTime="与CTI服务器连接失败!";
				this->AddListMessage(3,strTime);
				Beep(1000,300);
			}
		}
		/*
		if (m_bCallOut == TRUE)
		{
			if (!m_bSpecChan)
			{
				if (m_nWaitConnect == -1)
				{
					SendCallOut((LPCTSTR)m_sCallerId, (LPCTSTR)m_sCalledId, -1);
//					SendTestCall((LPCTSTR)m_sCallerId, (LPCTSTR)m_sCalledId, -1);
				}
			}
		}*/
	}
	/*
	if (nIDEvent == IDT_CENTISECOND)
	{
		if (m_bCallOut == TRUE)
		{
			if (m_bSpecChan)
			{
				if (m_nWaitConnect == -1)
				{
					INT nChannel;
					WAITTABLE *pWaitTable;
					if (m_wqWaitCall.DecHead(nChannel) == TRUE)
					{
						if (m_mapWaitTable.Lookup(nChannel, pWaitTable) == TRUE)
						{
							SendCallOut(pWaitTable->m_sCallerId, pWaitTable->m_sCalledId, nChannel);
						}
						if (pWaitTable->m_nTicks == 500)
						{
							pWaitTable->m_nTicks = 10;
						}
						m_wqWaitCall.Insert(nChannel, pWaitTable->m_nTicks);
						if (pWaitTable->m_nTicks == 500)
						{
							pWaitTable->m_nTicks = 10;
						}
					}
				}
			}
		}
		
	}*/
	CDialog::OnTimer(nIDEvent);
}

//Socket通信中止处理函数
LONG CAppServerDlg::OnCloseSocket(WPARAM wParam, LPARAM lParam)
{
	CString str;
	SEATSTATE *pSeatState;

	switch (wParam)
	{
	case HXDSOCKET_TYPE_ID:	//与HXD服务器通信中止
		if (m_pHXDSocket)
		{
			m_pHXDSocket->Close();
			delete m_pHXDSocket;
			m_pHXDSocket = NULL;
			m_nServerSend = 0;
			m_sServerSend.Format(_T("%d"), m_nServerSend);
			m_nServerReceive = 0;
			m_sServerReceive.Format(_T("%d"), m_nServerReceive);
			UpdateData(FALSE);
		}
		//向所有座席发注销指示
		LogoffAllSeat();

		//设定及时器，循环重试与HXD服务器的连接
		m_nWaitConnect = WAIT_CONNECT_SECONDS;
		str.Format(_T("%d秒后重新连接HXD服务器"), m_nWaitConnect);
		//((CButton *)GetDlgItem(IDC_CONNECT))->SetWindowText((LPCTSTR)str);
		((CStatic *)GetDlgItem(IDC_CONNECTSTATE))->SetIcon(m_hIconLose);
		//((CButton *)GetDlgItem(IDC_CONNECT))->EnableWindow();
		break;

	case SEATSOCKET_TYPE_ID:	//与座席通信中止
		if (m_pSeatSocket[lParam])
		{
			pSeatState = GetSeat(lParam);
			if (pSeatState)
			{
				//复位座席状态结构，更新显示
				ResetSeat(pSeatState->nSeatID);
				DeleteSeatItem(pSeatState->nSeatID);
				pSeatState->nSocketID = -1;
				pSeatState->nSeatID = 0;
				pSeatState->nState = SEAT_DISABLE;
				pSeatState->sCalledID.Empty();
				pSeatState->sCallerID.Empty();
				pSeatState->sOperatorID.Empty();
			}
			m_pSeatSocket[lParam]->Close();
			delete m_pSeatSocket[lParam];
			m_pSeatSocket[lParam] = NULL;
		}
		break;

	default:
		break;
	}

	return 0;
}

//向HXD服务器发送数据函数
BOOL CAppServerDlg::SendToHXDServer(HXDMESSAGE *pMsg)
{
	PCHAR	pData;
	INT		iSend;
	INT		iRet;
	
	if (m_pHXDSocket == NULL || m_pHXDSocket->GetConnectState() == FALSE)
	{
		return FALSE;
	}
	
	pData = (PCHAR)pMsg;
	iSend = pMsg->m_nLength + 8;

	while( iSend ){

		iRet = m_pHXDSocket->Send(pData, iSend);
		if( iRet != SOCKET_ERROR ){
			iSend -= iRet;
			pData += iRet;
		}
		else if( WSAEWOULDBLOCK == WSAGetLastError() ){
			Sleep(1);
		}
		else
			return FALSE;

//			INT nError = m_pHXDSocket->GetLastError();
//			CString str;
//			str.Format(_T("Send(HXDSocket)错误! 错误代码:%d!"), nError);
//			return FALSE;
	}

	m_nServerSend ++;
	m_sServerSend.Format(_T("%d"), m_nServerSend);
	UpdateData(FALSE);

	return TRUE;
}

//向座席发送数据函数
BOOL CAppServerDlg::SendToSeat(HXDMESSAGE *pMsg, INT nSocketID)
{
	if (m_pSeatSocket[nSocketID] == NULL || m_pSeatSocket[nSocketID]->GetConnectState() == FALSE)
	{
		return FALSE;
	}

	if (m_pSeatSocket[nSocketID]->Send(pMsg, pMsg->m_nLength + 8) == SOCKET_ERROR)
	{
		INT nError = m_pSeatSocket[nSocketID]->GetLastError();
		CString str;
		str.Format(_T("Send(SeatSocket)错误! 错误代码:%d!"), nError);
//		AfxMessageBox((LPCTSTR)str);

		return FALSE;
	}

	m_nSeatSend ++;
	m_sSeatSend.Format(_T("%d"), m_nSeatSend);
	UpdateData(FALSE);

	return TRUE;
}


//
//分析与HXD服务器通信接收缓冲，如果有完整的数据包，处理第一个数据包
//
//返回：TRUE ——数据缓冲中还有数据需要分析
//		FALSE——数据缓冲中没有数据需要分析
//
BOOL CAppServerDlg::AnalysisHXDServerMessage()
{/* 本程序每运行一次，分析一个包 */
	INT nInReadPtr = m_nHXDServerInReadPtr;
	INT nLength;

	while (nInReadPtr != m_nHXDServerInWritePtr)
	{
		//寻找包头标示(0x1954)的第一字节，之前的数据全部丢弃
		if (m_sHXDServerInBuffer[nInReadPtr] == LOBYTE(HXD_MESSAGE_HEADER))
		{
			m_nHXDServerInReadPtr = nInReadPtr;
			nInReadPtr ++;
			if (nInReadPtr == MAX_INBUFFER_CACHE)
			{
				nInReadPtr = 0;
			}
			if (nInReadPtr == m_nHXDServerInWritePtr)
			{
				//没有更多数据，数据包尚未完整
				return FALSE;
			}
			//判断第二字节是否等于包头标示(0x1954)的第二字节
			if (m_sHXDServerInBuffer[nInReadPtr] == HIBYTE(HXD_MESSAGE_HEADER))
			{
				if (m_nHXDServerInWritePtr > m_nHXDServerInReadPtr)
				{
					nLength = m_nHXDServerInWritePtr - m_nHXDServerInReadPtr;
				}
				else
				{
					nLength = m_nHXDServerInWritePtr + MAX_INBUFFER_CACHE - m_nHXDServerInReadPtr;
				}
				if (nLength >= 8)
				{
					break;
				}
				else
				{
					//没有更多数据，数据包尚未完整
					return FALSE;
				}
			}
		}

		nInReadPtr ++;
		if (nInReadPtr == MAX_INBUFFER_CACHE)
		{
			nInReadPtr = 0;
		}
	}
	if (nInReadPtr == m_nHXDServerInWritePtr)
	{
		//没有数据待分析，缓冲已清空
		m_nHXDServerInReadPtr = nInReadPtr;

		return FALSE;
	}

	//将数据包从缓冲中取出来
	HXDMESSAGE *pHXDMessage = (HXDMESSAGE *)(&m_sHXDServerInBuffer[m_nHXDServerInReadPtr]);
	if (nLength - 8 < pHXDMessage->m_nLength)
	{
		//数据包不完整
		return FALSE;
	}

	m_nHXDServerInReadPtr += pHXDMessage->m_nLength + 8;
	if (m_nHXDServerInReadPtr >= MAX_INBUFFER_CACHE)
	{
		m_nHXDServerInReadPtr -= MAX_INBUFFER_CACHE;
	}

	if (pHXDMessage->m_nMessageId == D_MSG_AUTODIALING)//自动呼出正在进行
	{
		m_nTestCallDialed ++;
		return TRUE;