为朋友写的一个管理modem池的类,post到这儿顺便自己有机会才看，不知道n年后再看这段代码会不会痛心...
文件smssocket.h
#pragma once
#include "socketthread.h"
class CSmsSocket: public CSocketThread
{
public:
CSmsSocket(void);
~CSmsSocket(void);
long StartThread(void *pParam) ;
long StopThread() ;
long PushData2AgentOutBuf(AFFAIR_CONTEXT &affair_context);
long CloseTerminate(char *pSimNumber);
private:
#pragma pack(push,1)
typedef struct _SMS_HEAD
{
char chSMSC[2];//SMSC地址信息,在本程序中,默认为0
char TP_VFP[2];//基本参数(TP-MTI/VFP),默认为11
char TP_MR[2];//TP-MR,默认为00
char chTargetCnt[2];//目标地址数字个数,一般为0d
char chTargetNumber[16];//91 68 31 58 81 27 64 F8
char TP_PID[2];//协议标识(TP-PID)
char TP_DCS[2];//用户信息编码方式(TP-DCS
char TP_VP[2];//有效期(TP-VP) 5分钟
char TP_UD[2];//用户信息(TP-UD)
}SMS_HEAD,*LPSMS_HEAD;
typedef struct _SMS_CONTEXT
{
AFFAIR_CONTEXT stAffairContext;
SMS_HEAD stSmsHead;
char stSmsData[MAX_PACKAGE_CNT];
}SMS_CONTEXT,*PSMS_CONTEXT;
typedef struct _RECV_SMS_HEAD
{
char chSourceNumber[16];//91 68 31 58 81 27 64 F8
char TP_VFP[2];//基本参数(TP-MTI/VFP),默认为11
char chTargetCnt[2];//目标地址数字个数,一般为0d
char chTargetNumber[16];//91 68 31 58 81 27 64 F8
char TP_PID[2];//协议标识(TP-PID)
char TP_DCS[2];//用户信息编码方式(TP-DCS
char TP_SCTS[14];//时间戳(TP-SCTS)
char TP_UD[2];//用户信息长度(TP-UDL)
char stSmsData[MAX_PACKAGE_CNT];
}RECV_SMS_HEAD,*LPRECV_SMS_HEAD;
#pragma pack(pop)
void CloseSocket(PPER_SOCKET_CONTEXT,BOOL bNeedNegal = FALSE);
static void DealModemDataThread(void *pParam);
long DealTerminate2ServerInvoke(PPER_TERMINATE_CONTEXT,PAFFAIR_HEAD);
long DealTerminate2ServerRespond(PPER_TERMINATE_CONTEXT,PAFFAIR_HEAD);
long DealTerminate2ServerAbort(PPER_TERMINATE_CONTEXT,PAFFAIR_HEAD);
long DealServer2TerminateInvoke(PPER_TERMINATE_CONTEXT,PAFFAIR_HEAD);
long DealServer2TerminateRespond(PPER_TERMINATE_CONTEXT,PAFFAIR_HEAD);
long DealServer2TerminateAbort(PPER_TERMINATE_CONTEXT,PAFFAIR_HEAD);
long AdjustNeedSendData2Agent();
int OpenComInitModem(int iWhichCom,HANDLE &pComHandle);
int LetModemReRecvAgain(PPER_SOCKET_CONTEXT pPerIoContext);
int FindModemAnswerFromBackString(const char *pModemBackString,DWORD *pModemAnswer);
long SendInitAtCommand(PPER_SOCKET_CONTEXT pPerIoContext);
long SendData2Modem(PPER_SOCKET_CONTEXT pWhichModem,const unsigned char *pDataBuf,int iSendCnt);
long SendSmsRequest2Modem(PPER_SOCKET_CONTEXT pWhichModem,int iSmsCnt);
long DecodeRecvSms(PPER_SOCKET_CONTEXT pWhichModem);
long DecodeSmsIn2BinaryStream(const LPRECV_SMS_HEAD pRecvSmsHead,PAFFAIR_HEAD pAffairHead);
CMainThread *m_pMainThread;
THREAD_STATE m_iThreadState;
HANDLE m_hModemThread;
HANDLE m_hModemIocp;
CRITICAL_SECTION m_csVisitData;
CRITICAL_SECTION m_csVisitLocalModem;
typedef enum MODEM_ANSWER{AT_ERROR =1,AT_OK=2,AT_READY=4,AT_RING=8
,AT_WIND=16,AT_CLIP=32,AT_GOONSEND,AT_CMTI=64};
list<PER_SOCKET_CONTEXT> m_LocalModemQueue;
list<SMS_CONTEXT> m_SendOutSmsQueue;
};
#include "smssocket.h"
#include "mainthread.h"
#include "clientthread.h"
#include "function.h"
CSmsSocket::CSmsSocket()
:m_hModemIocp(INVALID_HANDLE_VALUE)
,m_hModemThread(INVALID_HANDLE_VALUE)
,m_iThreadState(NOT_RUN)
{
}
CSmsSocket::~CSmsSocket()
{
if (INVALID_HANDLE_VALUE != m_hModemThread)
{
CloseHandle(m_hModemThread);
m_hModemThread =INVALID_HANDLE_VALUE;
}
}
long CSmsSocket::StartThread(void *pParam)
{
TraceInfo(RGB(0,0,255),"终端监听线程初始化..../n");
m_iThreadState = STOPPED;
_ASSERT(NULL != pParam);
m_pMainThread = (CMainThread*)pParam;
_ASSERT(m_hModemThread ==INVALID_HANDLE_VALUE);
if (m_hModemThread != INVALID_HANDLE_VALUE)
{
StopThread();
}
m_hModemIocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
_ASSERT(m_hModemIocp != NULL);
if (m_hModemIocp != NULL)
{
TraceInfo(RGB(0,0,255),"串口监听线程完成端口建立成功..../n");
InitializeCriticalSection(&m_csVisitLocalModem );
InitializeCriticalSection(&m_csVisitData);
int iComCnt = GetPrivateProfileInt ("SMS","comcnt",1,INIFILENAME);
int i =0;
int iComIndex = 0;
char csScoket[32] = {0};
HANDLE sScoket = INVALID_HANDLE_VALUE;
for (i=0;i<iComCnt;++i)
{
sprintf(csScoket,"comport%d",i+1);
iComIndex = GetPrivateProfileInt ("SMS",csScoket,1,INIFILENAME);
if (0 != OpenComInitModem(iComIndex,sScoket) && INVALID_HANDLE_VALUE != sScoket)
{
CloseHandle(sScoket);
sScoket = INVALID_HANDLE_VALUE;
}
}
m_hModemThread =(HANDLE) _beginthread(DealModemDataThread,0,this);
m_iThreadState = (m_hModemThread != INVALID_HANDLE_VALUE ? RUNNING :STOPPED);
}
return m_iThreadState;
}
long CSmsSocket::StopThread()
{
m_iThreadState = WANT_STOP;
return ::WaitForSingleObject (m_hModemThread,1000);
}
int CSmsSocket::OpenComInitModem(int iWhicsScoket,HANDLE &pComHandle)
{
if (iWhicsScoket <1 || iWhicsScoket > 33)
return 1;
if (pComHandle == NULL || IsBadWritePtr(&pComHandle,sizeof(HANDLE)))
return 2;
char csScoketName[32] = {0};
sprintf(csScoketName,".//COM%d",iWhicsScoket);
char chBand [256] = {0};
int iBand = GetPrivateProfileInt ("SMS","band",115200,INIFILENAME);
sprintf(chBand,"baud=%d parity=%c data=%d stop=%d", iBand, 'n', 8, 1);
pComHandle = CreateFile(csScoketName,GENERIC_READ | GENERIC_WRITE,0,NULL,OPEN_EXISTING
,FILE_FLAG_OVERLAPPED|FILE_ATTRIBUTE_NORMAL,0);
if (pComHandle == INVALID_HANDLE_VALUE)
return 3;
static COMMTIMEOUTS stCommTimeouts = {1790,10000,100000,100,1000};
if (!SetCommTimeouts(pComHandle, &stCommTimeouts))
{
CloseHandle(pComHandle);
pComHandle = INVALID_HANDLE_VALUE;
return 4;
}
DWORD dwCommEvents = 0;
if (! SetCommMask(pComHandle, dwCommEvents))
{
CloseHandle(pComHandle);
pComHandle = INVALID_HANDLE_VALUE;
return 5;
}
DCB dcb={0};
if (! GetCommState(pComHandle, &dcb))
{
CloseHandle(pComHandle);
pComHandle = INVALID_HANDLE_VALUE;
return 6;
}
dcb.fBinary = TRUE;
dcb.fRtsControl = RTS_CONTROL_ENABLE;
if (! BuildCommDCB(chBand, &dcb))
{
CloseHandle(pComHandle);
pComHandle = INVALID_HANDLE_VALUE;
return 7;
}
if (! SetCommState(pComHandle, &dcb))
{
CloseHandle(pComHandle);
pComHandle = INVALID_HANDLE_VALUE;
return 8;
}
list<PER_SOCKET_CONTEXT>::iterator iterAgent = NULL;
PER_SOCKET_CONTEXT perSocketContext = {0};
perSocketContext.modemStatus = S_NOT_INIT;
m_LocalModemQueue.push_back (perSocketContext);
iterAgent = m_LocalModemQueue.end ();
-- iterAgent;
if (iterAgent == m_LocalModemQueue.end ())
{
return 11;
}
PER_SOCKET_CONTEXT *lpModemContext = (PPER_SOCKET_CONTEXT)(&(iterAgent->Overlapped ));
lpModemContext->sScoket = (SOCKET)pComHandle;
lpModemContext->CurrentIoOperation = IO_RECV;
lpModemContext->SendBuffer.buf = lpModemContext->SendData ;
lpModemContext->SendBuffer.len = MAX_PACKAGE_CNT;
lpModemContext->RecvBuffer.buf = lpModemContext->RecvData ;
lpModemContext->RecvBuffer.len = MAX_PACKAGE_CNT;
sprintf(lpModemContext ->chSocketIp,"串口%02d",iWhicsScoket);
TraceInfo(RGB(0,0,255),"初始化%s成功!/n",lpModemContext ->chSocketIp);
m_hModemIocp = CreateIoCompletionPort(pComHandle, m_hModemIocp, (DWORD)lpModemContext, 0);
return SendInitAtCommand(lpModemContext);
}
int CSmsSocket::LetModemReRecvAgain(PPER_SOCKET_CONTEXT pPerIoContext)
{
//在每次发送前，把所有末完成的io操作全部取消掉
if (!HasOverlappedIoCompleted(&(pPerIoContext->Overlapped) ))
{
TraceInfo(RGB(0,0,255),"中止[%s]先前进行的IO操作!/n",pPerIoContext->chSocketIp );
CancelIo((HANDLE)pPerIoContext->sScoket );
}
pPerIoContext->CurrentIoOperation = IO_RECV;
DWORD dwRecvNumBytes = 0;
return ReadFile((HANDLE)pPerIoContext->sScoket , &(pPerIoContext->RecvData)
,MAX_PACKAGE_CNT,&dwRecvNumBytes,&(pPerIoContext->Overlapped));
}
int CSmsSocket::FindModemAnswerFromBackString(const char *pModemBackString,DWORD *pModemAnswer)
{
_ASSERT(!IsBadReadPtr(pModemBackString,4));
if (IsBadReadPtr(pModemBackString,4))
return 1;
_ASSERT(!IsBadWritePtr(pModemAnswer,sizeof(DWORD)));
if (IsBadWritePtr(pModemAnswer,sizeof(DWORD)))
return 2;
int iModemAnswer = 0;
int iSubStatus = 0;
*pModemAnswer = 0;
char *pFindModemAnswer = (char*)pModemBackString;
if (NULL != strstr(pFindModemAnswer,"RING"))
{
iModemAnswer |= AT_RING;
}
if (NULL != strstr(pFindModemAnswer,"ERROR"))
{
iModemAnswer |= AT_ERROR;
}
if (NULL != strstr(pFindModemAnswer,"WIND"))
{
iModemAnswer |= AT_WIND;
}
if (NULL != strstr(pFindModemAnswer,"CLIP"))
{
iModemAnswer |= AT_WIND;
}
if (NULL != strstr(pFindModemAnswer,"OK") || NULL != strstr(pFindModemAnswer,"READY"))
{
iModemAnswer |= AT_OK;
}
if (NULL != strstr(pFindModemAnswer,">"))
{
iModemAnswer |= AT_GOONSEND;
}
if (NULL != strstr(pFindModemAnswer,"+CMTI:"))
{
iModemAnswer |= AT_CMTI;
char *pFindSmsCnt = strstr(pFindModemAnswer,"+CMTI:");
char *pFindLastCMTI = strstr(pFindSmsCnt,"+CMTI:");
while (pFindLastCMTI != NULL)
{
pFindLastCMTI += lstrlen("+CMTI:");
pFindSmsCnt = pFindLastCMTI;
pFindLastCMTI = strstr(pFindSmsCnt,"+CMTI:");
}
pFindSmsCnt = strstr(pFindSmsCnt,",");
if (pFindSmsCnt != NULL)
{
pFindSmsCnt += 1;
iSubStatus = strtol(pFindSmsCnt,NULL,10);
}
}
*pModemAnswer = MAKELONG(iModemAnswer,iSubStatus);
return iModemAnswer >0 ? 0 : 3;
}
long CSmsSocket::SendInitAtCommand(PPER_SOCKET_CONTEXT pWhichModem)
{
const char *InitAtCommand[]={"AT/r","ATH/r","ATE0/r","AT+CMEE=1/r"
,"AT+CRC=1/r","AT+CLIP=1/r","AT+CMGF=0/r","AT+CPIN?/r","AT+CMGD=1,4/r"};
if (pWhichModem->modemStatus != S_NOT_INIT)
{
_ASSERT(0);
return 1;
}
if (pWhichModem->initAtCommand <S_END_INIT)
{
char *pSendAt = (char*)InitAtCommand[pWhichModem->initAtCommand ];
return SendData2Modem(pWhichModem,(const BYTE*)pSendAt,lstrlen(pSendAt));
}
else
{
pWhichModem->modemStatus =S_MODEM_IDLE;
return LetModemReRecvAgain(pWhichModem);
}
}
long CSmsSocket::SendSmsRequest2Modem(PPER_SOCKET_CONTEXT pWhichModem,int iSmsCnt)
{
pWhichModem->modemStatus =S_MODEM_ACQUIRE;
unsigned char chTemp[256] = {0};
sprintf((char*)chTemp,"AT+CMGS=%d/r",iSmsCnt );
return SendData2Modem(pWhichModem,chTemp,lstrlen((char*)chTemp));
}
long CSmsSocket::SendData2Modem(PPER_SOCKET_CONTEXT pWhichModem,const unsigned char *pDataBuf,int iSendCnt)
{
if (IsBadReadPtr(pWhichModem,sizeof(PPER_SOCKET_CONTEXT)))
return 1;
if (IsBadReadPtr(pDataBuf,iSendCnt))
return 2;
if (INVALID_HANDLE_VALUE == (HANDLE)pWhichModem ->sScoket )
return 3;
if (pWhichModem->modemStatus == S_MODEM_IDLE)
{
pWhichModem->modemStatus = S_MODEM_WAIT;
}
if (!HasOverlappedIoCompleted(&(pWhichModem->Overlapped) ))
{
TraceInfo(RGB(0,0,255),"中止[%s]先前进行的IO操作!/n",pWhichModem->chSocketIp );
CancelIo((HANDLE)pWhichModem->sScoket );
}
pWhichModem->CurrentIoOperation = IO_SEND;
memcpy(pWhichModem->SendData,pDataBuf,iSendCnt);
pWhichModem->SendBuffer.len = iSendCnt;
DWORD dwSendNumBytes =0;
TraceInfo(RGB(0,0,255),"%s发送数据%s",pWhichModem->chSocketIp,pWhichModem->SendData);
TraceData(pWhichModem->SendData,iSendCnt);
return WriteFile((HANDLE)pWhichModem ->sScoket,&(pWhichModem->SendData)
, iSendCnt, &dwSendNumBytes,&(pWhichModem->Overlapped ));
}
long CSmsSocket::CloseTerminate(char *pSimNumber)
{
return CFunction::SendTermLogin2AllClient (pSimNumber,FALSE);
}
void CSmsSocket::CloseSocket(PPER_SOCKET_CONTEXT lpModemContext,BOOL bNeedNegal )
{
EnterCriticalSection(&m_csVisitLocalModem);
__try
{
list<PER_SOCKET_CONTEXT>::iterator iterDelete = m_LocalModemQueue.begin ();
while (iterDelete != m_LocalModemQueue.end ())
{
if ((PPER_SOCKET_CONTEXT)(&(iterDelete->Overlapped)) == lpModemContext
&& iterDelete->sScoket == lpModemContext->sScoket)
{
CloseHandle((HANDLE)lpModemContext->sScoket);
TraceInfo(RGB(0,0,255),"删除代理[%s]相关信息成功!/n",iterDelete->chSocketIp );
m_LocalModemQueue.erase(iterDelete);
break;
}
++ iterDelete;
}
}
__finally
{
}
LeaveCriticalSection(&m_csVisitLocalModem);
}
long CSmsSocket::DealTerminate2ServerInvoke(PPER_TERMINATE_CONTEXT pper_modem_context,PAFFAIR_HEAD ppaffair_head)
{
//处理modem的invoke包，并必须发送相应的应答数据包到modem
long lResult = 1;
AFFAIR_CONTEXT stAffairContext = {0};
PAFFAIR_HEAD server2modem_head = (PAFFAIR_HEAD)&(stAffairContext.affair_head) ;
memcpy(server2modem_head,ppaffair_head,ppaffair_head->frame_length +2);
if (CLIENT_ADMIN == ppaffair_head->module_index &&ppaffair_head ->command ==TERM_LOGOUT)
{
//通知所有客户端该终端已经被关闭
char sim_card_number[32] = {0};
CFunction::Cast7ByteTo14SimStr((unsigned char*)ppaffair_head->lgsn ,sim_card_number );
sim_card_number[11] = '/0';
list<PER_TERMINATE_CONTEXT>::iterator iterDelete = m_pMainThread->m_TermniteQueue.begin ();
while (iterDelete != m_pMainThread->m_TermniteQueue.end ())
{
if (lstrlen(iterDelete->sim_card_number) >8 && strstr(sim_card_number,iterDelete->sim_card_number ))
{
m_pMainThread->CloseTerminate(iterDelete);
break;
}
++ iterDelete;
}
return 0;
}
else
lResult = CFunction::CheckModem2ServerPackageAndPutResult(ppaffair_head,server2modem_head,pper_modem_context);
if (NEED_SHUTDOWN == server2modem_head->msg_type )
{
//上层模块需要关闭与modem之前的连接
ppaffair_head ->module_index =CLIENT_ADMIN;
ppaffair_head ->msg_type=RESPOND;
ppaffair_head ->command=TERM_LOGOUT;
ppaffair_head->frame_length=sizeof(AFFAIR_HEAD)-2;
}
else if (0 != lResult)
{
//默认将server到modem的应答数据置为放弃本次事务ABORT
TraceInfo(RGB(255,0,0),"终端[%s]提交的INVOKE事务[%d],命令[%s]的处理失败,错误码为[%d]!/n",
pper_modem_context->sim_card_number ,ppaffair_head->sid
,KEYID(ppaffair_head->command) , lResult);
server2modem_head->msg_type = ABORT;
}
server2modem_head->crc = CFunction::CheckCrc16 (
(unsigned char*)&(server2modem_head->frame_length),server2modem_head->frame_length );
return PushData2AgentOutBuf(stAffairContext);
}
long CSmsSocket::DealTerminate2ServerRespond(PPER_TERMINATE_CONTEXT pper_modem_context,PAFFAIR_HEAD ppaffair_head)
{
//该函数处理modem到server的先前的invoke事务的respond
//查找modem的server_2_modem_queue,找到对应的invoke数据包,
list<AFFAIR_CONTEXT>::iterator affair_context_iter = pper_modem_context->server_2_modem_queue ->begin ();
while (affair_context_iter != pper_modem_context->server_2_modem_queue->end ())
{
if (affair_context_iter->affair_head.sid == ppaffair_head->sid &&
affair_context_iter->affair_head.command == (ppaffair_head->command+0x60) )
{
//found that affair
break;
}
++ affair_context_iter;
}
if (affair_context_iter == pper_modem_context->server_2_modem_queue->end ())
{
//如果没有找到,也不需要回复数据包,直接扔掉
TraceInfo(RGB(255,0,0),"终端[%s]Respond数据包[%s]末找到SID[%d]!/n",
pper_modem_context->sim_card_number,KEYID(ppaffair_head->command ),ppaffair_head->sid );
return 1;
}
//找到了,则从server_2_modem_queue删除相应invoke包,并判断是否需要回显给client
PPER_SOCKET_CONTEXT pper_socket_context=(PPER_SOCKET_CONTEXT)affair_context_iter->sender_client;
DWORD dwPackageSize = ppaffair_head->frame_length +sizeof(unsigned short);
DWORD dwRecvNumBytes= 0;
DWORD dwFlags = 0;
int nRet = 0;
//调用crc16检验是否正确，如不是，则继续发送上一包数据
if (ppaffair_head->crc != CFunction::CheckCrc16 (
(unsigned char*)&(ppaffair_head->frame_length ),ppaffair_head->frame_length ))
{
return 2;
}
//发过来的lgsn为modem的ccid,需要将其转化为modem的sim卡号,再发送到客户端
CFunction::Cast14SimStrTo7Byte(pper_modem_context->sim_card_number ,(unsigned char*)ppaffair_head->lgsn );
//调用相应处理模块的处理modem的respond信息函数
CFunction::CheckModemRespondPackage (pper_modem_context,ppaffair_head,pper_socket_context,affair_context_iter);
BOOL bFindAllUserInfoSendIn = affair_context_iter->affair_status ==SENDED_IN ? TRUE : FALSE;
switch ((DWORD)pper_socket_context)
{
case -1:
{
//发送到所有客户端
CClientThread *pClientThread = (CClientThread*)m_pMainThread->m_pClientThread ;
_ASSERT(NULL == pClientThread);
if (NULL != pClientThread)
{
list<PER_SOCKET_CONTEXT>::iterator client_socket_iter =pClientThread->listClientQueue.begin ();
while (client_socket_iter != pClientThread->listClientQueue.end ())
{
pper_socket_context =(PPER_SOCKET_CONTEXT)&(client_socket_iter->Overlapped);
if (pper_socket_context)
{
//只有在modem返回应答后才对有可能client发送数据,所以在这儿不用保护
memcpy(pper_socket_context->SendData ,ppaffair_head,dwPackageSize);
pper_socket_context->SendBuffer.len = dwPackageSize;
nRet = send(pper_socket_context->sScoket ,pper_socket_context->SendData,dwPackageSize,0);
if( nRet == SOCKET_ERROR && (ERROR_IO_PENDING != WSAGetLastError()) )
{
TraceInfo(RGB(255,0,0),"终端接收线程将终端[%s]的事务[%d]命令[%s]的应答数据包发送到客户端[%s]失败,错误码为[%d]!/n",
pper_modem_context->sim_card_number ,affair_context_iter->affair_head.sid,
KEYID(affair_context_iter->affair_head.command),
pper_socket_context->chSocketIp,WSAGetLastError() );
}
else
{
TraceInfo(RGB(0,0,255),"终端接收线程将终端[%s]的事务[%d]命令[%s]的应答数据包发送到客户端[%s]!/n",
pper_modem_context->sim_card_number ,affair_context_iter->affair_head.sid,
KEYID(affair_context_iter->affair_head.command),pper_socket_context->chSocketIp );
}
}
++ client_socket_iter;
}
}
}
break;
case 0:
{
//不需要发送到客户端,是server到modem的invoke
}
break;
default:
{
if (pper_socket_context>0)
{
//只有在modem返回应答后才对有可能client发送数据,所以在这儿不用保护
nRet = send(pper_socket_context->sScoket ,(char*)ppaffair_head,dwPackageSize,0);
if( nRet == SOCKET_ERROR && (ERROR_IO_PENDING != WSAGetLastError()) )
{
TraceInfo(RGB(255,0,0),"终端接收线程将终端[%s]的事务[%d]命令[%s]的应答数据包发送到客户端[%s]失败,错误码为[%d]!/n",
pper_modem_context->sim_card_number ,affair_context_iter->affair_head.sid,
KEYID(affair_context_iter->affair_head.command),
pper_socket_context->chSocketIp,WSAGetLastError() );
}
else
{
TraceInfo(RGB(0,0,255),"终端接收线程将终端[%s]的事务[%d]命令[%s]的应答数据包发送到客户端[%s]!/n",
pper_modem_context->sim_card_number ,affair_context_iter->affair_head.sid,
KEYID(affair_context_iter->affair_head.command),
pper_socket_context->chSocketIp );
}
}
else
{
//不属于上述三种情况就肯定有错了
_ASSERT(0);
}
}
break;
}
//删除该次由client或server到modem的保存在modem中server_2_modem_queue的事务
EnterCriticalSection (&(pper_modem_context->visit_modem_privi ));
TraceInfo(RGB(0,0,255),"终端[%s]的事务[%d]命令[%s]操作完成,剩余事务次数为[%d]!/n",
pper_modem_context->sim_card_number,affair_context_iter->affair_head.sid,
KEYID(affair_context_iter->affair_head.command),pper_modem_context->server_2_modem_queue->size()-1);
//只是简单的把affair_status置为POPED,在schedulethread中删除相应结构
if (ppaffair_head->command == SACP_USER_ALL_USER_INFO )
{
if (TRUE == bFindAllUserInfoSendIn)
affair_context_iter->affair_status =POPED;
}
else
affair_context_iter->affair_status =POPED;
//开始下一次事务操作吧
pper_modem_context->current_affair = NULL;
LeaveCriticalSection (&(pper_modem_context->visit_modem_privi ));
return 0;
}
long CSmsSocket::DealTerminate2ServerAbort(PPER_TERMINATE_CONTEXT pper_modem_context,PAFFAIR_HEAD ppaffair_head)
{
//该函数处理modem到server的先前的invoke事务的respond
//查找modem的server_2_modem_queue,找到对应的invoke数据包,
list<AFFAIR_CONTEXT>::iterator affair_context_iter = pper_modem_context->server_2_modem_queue ->begin ();
while (affair_context_iter != pper_modem_context->server_2_modem_queue->end ())
{
if (affair_context_iter->affair_head.sid == ppaffair_head->sid &&
affair_context_iter->affair_head.command == (ppaffair_head->command+0x60) )
{
//found that affair
break;
}
++ affair_context_iter;
}
if (affair_context_iter == pper_modem_context->server_2_modem_queue->end ())
{
//如果没有找到,也不需要回复数据包,直接扔掉
return 1;
}
//找到了,则从server_2_modem_queue删除相应invoke包,并判断是否需要回显给client
PPER_SOCKET_CONTEXT pper_socket_context=(PPER_SOCKET_CONTEXT)affair_context_iter->sender_client;
DWORD dwPackageSize = ppaffair_head->frame_length +sizeof(unsigned short);
DWORD dwRecvNumBytes= 0;
DWORD dwFlags = 0;
int nRet = 0;
//调用crc16检验是否正确，如不是，则继续发送上一包数据
if (ppaffair_head->crc != CFunction::CheckCrc16 (
(unsigned char*)&(ppaffair_head->frame_length ),ppaffair_head->frame_length ))
{
return 2;
}
//发过来的lgsn为modem的ccid,需要将其转化为modem的sim卡号,再发送到客户端
CFunction::Cast14SimStrTo7Byte(pper_modem_context->sim_card_number ,(unsigned char*)ppaffair_head->lgsn );
//调用相应处理模块的处理modem的respond信息函数
CFunction::CheckModemAbortPackage (pper_modem_context,ppaffair_head,pper_socket_context,affair_context_iter);
switch ((DWORD)pper_socket_context)
{
case -1:
{
//发送到所有客户端
CClientThread *pClientThread = (CClientThread*)m_pMainThread->m_pClientThread ;
_ASSERT(NULL == pClientThread);
if (NULL != pClientThread)
{
list<PER_SOCKET_CONTEXT>::iterator client_socket_iter =pClientThread->listClientQueue.begin ();
while (client_socket_iter != pClientThread->listClientQueue.end ())
{
pper_socket_context =(PPER_SOCKET_CONTEXT)&(client_socket_iter->Overlapped);
if (pper_socket_context)
{
//只有在modem返回应答后才对有可能client发送数据,所以在这儿不用保护
memcpy(pper_socket_context->SendData ,ppaffair_head,dwPackageSize);
pper_socket_context->SendBuffer.len = dwPackageSize;
nRet = send(pper_socket_context->sScoket ,pper_socket_context->SendData,dwPackageSize,0);
if( nRet == SOCKET_ERROR && (ERROR_IO_PENDING != WSAGetLastError()) )
{
TraceInfo(RGB(255,0,0),"终端接收线程将终端[%s]的事务[%d]命令[%s]的应答数据包发送到客户端[%s]失败,错误码为[%d]!/n",
pper_modem_context->sim_card_number ,affair_context_iter->affair_head.sid,
KEYID(affair_context_iter->affair_head.command),
pper_socket_context->chSocketIp,WSAGetLastError() );
}
else
{
TraceInfo(RGB(0,0,255),"终端接收线程将终端[%s]的事务[%d]命令[%s]的应答数据包发送到客户端[%s]!/n",
pper_modem_context->sim_card_number ,affair_context_iter->affair_head.sid,
KEYID(affair_context_iter->affair_head.command),pper_socket_context->chSocketIp );
}
}
++ client_socket_iter;
}
}
}
break;
case 0:
{
//不需要发送到客户端,是server到modem的invoke
}
break;
default:
{
if (pper_socket_context>0)
{
//只有在modem返回应答后才对有可能client发送数据,所以在这儿不用保护
memcpy(pper_socket_context->SendData ,ppaffair_head,dwPackageSize);
pper_socket_context->SendBuffer.len = dwPackageSize;
nRet = send(pper_socket_context->sScoket ,pper_socket_context->SendData,dwPackageSize,0);
if( nRet == SOCKET_ERROR && (ERROR_IO_PENDING != WSAGetLastError()) )
{
TraceInfo(RGB(255,0,0),"终端接收线程将终端[%s]的事务[%d]命令[%s]的应答数据包发送到客户端[%s]失败,错误码为[%d]!/n",
pper_modem_context->sim_card_number ,affair_context_iter->affair_head.sid,
KEYID(affair_context_iter->affair_head.command),
pper_socket_context->chSocketIp,WSAGetLastError() );
}
else
{
TraceInfo(RGB(0,0,255),"终端接收线程将终端[%s]的事务[%d]命令[%s]的应答数据包发送到客户端[%s]!/n",
pper_modem_context->sim_card_number ,affair_context_iter->affair_head.sid,
KEYID(affair_context_iter->affair_head.command),
pper_socket_context->chSocketIp );
}
}
else
{
//不属于上述三种情况就肯定有错了
_ASSERT(0);
}
}
break;
}
//删除该次由client或server到modem的保存在modem中server_2_modem_queue的事务
EnterCriticalSection (&(pper_modem_context->visit_modem_privi ));
TraceInfo(RGB(0,0,255),"终端[%s]的事务[%d]命令[%s]操作完成,剩余事务次数为[%d]!/n",
pper_modem_context->sim_card_number,affair_context_iter->affair_head.sid,
KEYID(affair_context_iter->affair_head.command),pper_modem_context->server_2_modem_queue->size()-1);
//只是简单的把affair_status置为POPED,在schedulethread中删除相应结构
affair_context_iter->affair_status =POPED;
//pper_modem_context->server_2_modem_queue ->erase (affair_context_iter);
//开始下一次事务操作吧
pper_modem_context->current_affair = NULL;
LeaveCriticalSection (&(pper_modem_context->visit_modem_privi ));
return 0;
}
long CSmsSocket::DealServer2TerminateInvoke(PPER_TERMINATE_CONTEXT pper_modem_context,PAFFAIR_HEAD ppaffair_head)
{
//该函数处理modem到server的先前的invoke事务的respond
//查找modem的server_2_modem_queue,找到对应的invoke数据包,
list<AFFAIR_CONTEXT>::iterator affair_context_iter = pper_modem_context->server_2_modem_queue ->begin ();
while (affair_context_iter != pper_modem_context->server_2_modem_queue->end ())
{
if (affair_context_iter->affair_head.sid == ppaffair_head->sid &&
affair_context_iter->affair_head.command == ppaffair_head->command )
{
//found that affair
break;
}
++ affair_context_iter;
}
if (affair_context_iter == pper_modem_context->server_2_modem_queue->end ())
{
//如果没有找到,
return 1;
}
char chClientIP[32] = {0};
PPER_SOCKET_CONTEXT per_socket_context=(PPER_SOCKET_CONTEXT)affair_context_iter->sender_client;
if (per_socket_context&&!IsBadWritePtr(per_socket_context,sizeof(PER_SOCKET_CONTEXT)))
sprintf(chClientIP,"客户端%s",per_socket_context->chSocketIp);
else
lstrcpy(chClientIP,"服务器");
//找到了,把该事务的相关信息置位
TraceInfo(RGB(0,0,255),"终端接收线程第[%d]次[%s]到终端[%s]的事务[%d]命令[%s]成功!/n",
affair_context_iter->retry_send_cnt,chClientIP,
pper_modem_context->sim_card_number ,ppaffair_head->sid ,KEYID(ppaffair_head->command) );
affair_context_iter->affair_status =SENDED_OUT;
return 0;
}
long CSmsSocket::DealServer2TerminateRespond(PPER_TERMINATE_CONTEXT pper_modem_context,PAFFAIR_HEAD ppaffair_head)
{
TraceInfo(RGB(0,0,255),"终端[%s]的Respond数据事务[%d]命令[%s]发送成功!/n",
pper_modem_context->sim_card_number ,ppaffair_head->sid ,KEYID(ppaffair_head->command) );
return 0;
}
long CSmsSocket::DealServer2TerminateAbort(PPER_TERMINATE_CONTEXT pper_modem_context,PAFFAIR_HEAD ppaffair_head)
{
TraceInfo(RGB(0,0,255),"终端[%s]的Abort数据事务[%d]命令[%s]发送成功!/n",
pper_modem_context->sim_card_number ,ppaffair_head->sid ,KEYID(ppaffair_head->command) );
return 0;
}
long CSmsSocket::PushData2AgentOutBuf(AFFAIR_CONTEXT &affair_context)
{
EnterCriticalSection(&m_csVisitLocalModem);
__try
{
SMS_CONTEXT stSmsContext = {0};
memcpy(&stSmsContext,&affair_context,sizeof(AFFAIR_CONTEXT));
LPSMS_HEAD pSmsHead = (LPSMS_HEAD)&(stSmsContext.stSmsHead);
memset(pSmsHead,'0',sizeof(SMS_HEAD));
pSmsHead->TP_VFP[0] = '1';
pSmsHead->TP_VFP[1] = '1';
pSmsHead->chTargetCnt[0] = '0';
pSmsHead->chTargetCnt[1] = 'd';
PAFFAIR_HEAD pAffairHead = (PAFFAIR_HEAD)&(affair_context.affair_kind);
char chSimString[32] = {0};
CFunction::Cast7ByteTo14SimStr ((BYTE*)pAffairHead->lgsn,chSimString);
char *pTarget = pSmsHead->chTargetNumber;
lstrcpy(pTarget,"9168");
pTarget += 4;
char *pCast = (char*)chSimString;
if (chSimString[0] == '8' && chSimString[1] =='6')
pCast += 2;
int i=0;
for (;i<6;++i)
{
*pTarget =pCast[i+1];
++ pTarget;
*pTarget=pCast[i];
++ pTarget;
}
pSmsHead->chTargetNumber[14] ='F';
pSmsHead->TP_DCS[1] ='5';
sprintf(pSmsHead->TP_UD,"%02d",pAffairHead->frame_length+2);
if (pAffairHead->frame_length+2 < (MAX_PACKAGE_CNT >> 1) )
{
pTarget = (char*)&(stSmsContext.stSmsData );
pCast = (char*)pAffairHead;
for (i=0;i<pAffairHead->frame_length+2;++i)
{
sprintf(pTarget,"%02X",*pCast);
++ pCast;
pTarget += 2;
}
*pTarget ++= 0x1a;
*pTarget = '/0';
m_SendOutSmsQueue.push_back (stSmsContext);
}
}
__finally
{
}
LeaveCriticalSection(&m_csVisitLocalModem);
return 0;
}
long CSmsSocket::AdjustNeedSendData2Agent()
{
EnterCriticalSection(&m_csVisitLocalModem);
list<SMS_CONTEXT>::iterator pDataOut = m_SendOutSmsQueue.begin ();
list<SMS_CONTEXT>::iterator pSend = NULL;
list<PER_SOCKET_CONTEXT>::iterator pIdelModem = NULL;
PAFFAIR_HEAD pAffairHead = NULL;
PPER_SOCKET_CONTEXT pWhichModem = NULL;
DWORD dwIoSize = 0;
__try
{
while (pDataOut != m_SendOutSmsQueue.end ())
{
pSend = pDataOut;
++ pDataOut;
pAffairHead = (PAFFAIR_HEAD)&(pSend->stAffairContext.affair_head) ;
dwIoSize = pAffairHead->frame_length+15;
if (dwIoSize >MAX_PACKAGE_CNT || PUSHED != pSend->stAffairContext.affair_status)
continue;
pIdelModem = m_LocalModemQueue.begin();
while (pIdelModem != m_LocalModemQueue.end())
{
if (pIdelModem ->modemStatus == S_MODEM_IDLE && pIdelModem->has_sms_cnt ==0)
break;
++ pIdelModem;
}
if (pIdelModem != m_LocalModemQueue.end())
{
pWhichModem = (PPER_SOCKET_CONTEXT)&(pIdelModem->Overlapped);
pWhichModem->modemStatus = S_MODEM_SEND_SMS_ACQUIRE;
SendSmsRequest2Modem(pWhichModem,dwIoSize);
pSend->stAffairContext.affair_status = SENDING_OUT;
pSend->stAffairContext.affair_mdoem_context=pWhichModem;
pWhichModem->pCurrentAffair=(void*)&(pSend->stAffairContext.affair_mdoem_context);
break;
}
}
}
__finally
{
}
LeaveCriticalSection(&m_csVisitLocalModem);
return 0;
}
long CSmsSocket::DecodeSmsIn2BinaryStream(const LPRECV_SMS_HEAD pRecvSmsHead,PAFFAIR_HEAD pAffairHead)
{
if (IsBadReadPtr(pRecvSmsHead,sizeof(RECV_SMS_HEAD)) || IsBadWritePtr(pAffairHead,sizeof(AFFAIR_HEAD)))
return 1;
char chTemp[32] = {0};
int i = atoi(pRecvSmsHead->TP_UD);
pAffairHead->frame_length = i -2;
char *pData = pRecvSmsHead->stSmsData ;
char *pDest = (char*)pAffairHead;
while (i -- >0)
{
strncpy(chTemp,pData,2);
chTemp[2] ='/0';
sscanf(chTemp,"%02X",pDest);
pData += 2;
++ pDest;
}
for (i= 0;i<6;++i)
{
chTemp[2*i+1] =pRecvSmsHead->chTargetNumber[4+2*i];
chTemp[2*i] =pRecvSmsHead->chTargetNumber[4+2*i+1];
}
chTemp[11] = '/0';
CFunction::Cast14SimStrTo7Byte(chTemp,(unsigned char*)pAffairHead->lgsn );
TraceData((char*)pAffairHead,pAffairHead->frame_length+2);
return pAffairHead->frame_length;
}
long CSmsSocket::DecodeRecvSms(PPER_SOCKET_CONTEXT pWhichModem)
{
DWORD dwIoSize = 0;
char chMsgHead[MAX_PACKAGE_CNT] = {0};
char *pFindCmgr = strstr(pWhichModem->RecvData,"+CMGR:");
if (NULL == pFindCmgr)
return 1;
pFindCmgr += 6;
pFindCmgr = strstr(pFindCmgr,"/r/n");
if (NULL == pFindCmgr)
return 2;
pFindCmgr += 2;
LPRECV_SMS_HEAD pRecvSmsHead = (LPRECV_SMS_HEAD)pFindCmgr;
PAFFAIR_HEAD pAffairHead = (PAFFAIR_HEAD)chMsgHead;
dwIoSize = DecodeSmsIn2BinaryStream(pRecvSmsHead,pAffairHead);
if (dwIoSize <= 0 )
return 3;
PER_TERMINATE_CONTEXT stTerminalContext = {0};
PPER_TERMINATE_CONTEXT pPerTerminateContext = NULL;
char sim_card_number[32] = {0};
CFunction::Cast7ByteTo14SimStr((unsigned char*)pAffairHead->lgsn ,sim_card_number );
sim_card_number[11] = '/0';
CFunction::GetModemByHisSimNo(sim_card_number,&pPerTerminateContext);
if (NULL == pPerTerminateContext)
{
TraceInfo(RGB(255,0,0),"末能找到终端[%s]的相关数据结构/n",sim_card_number);
return 4;
}
if (pAffairHead->frame_length +2 == dwIoSize)
{
//判断是事务发到modem后modem的respond数据包,还是modem的invoke数据包
switch (pAffairHead->msg_type)
{
case INVOKE:
//modem到server的invoke数据包
DealTerminate2ServerInvoke(pPerTerminateContext,pAffairHead);
break;
case RESPOND:
//modem到server的先前事务的应答包
DealTerminate2ServerRespond(pPerTerminateContext,pAffairHead);
break;
case ABORT:
//modem到server的先前事务的应答包,但先前事务的数据不正确
DealTerminate2ServerAbort(pPerTerminateContext,pAffairHead);
break;
default:
_ASSERT(0);
break;
}
}
else
{
TraceInfo(RGB(255,0,0),"处理线程接收到的数据包位数[Need:%d Real:%d]不正确!/n",
pAffairHead->frame_length +2,dwIoSize);
pAffairHead->msg_type = ABORT;
}
return 0;
}
void CSmsSocket::DealModemDataThread(void *pParam)
{
CSmsSocket *pModemThread = (CSmsSocket*)pParam;
_ASSERT(NULL != pModemThread);
_ASSERT(! IsBadReadPtr(pModemThread,sizeof(CSmsSocket)));
if (NULL == pModemThread || IsBadReadPtr(pModemThread,sizeof(CSmsSocket)))
return ;
DWORD dwThreadId = GetCurrentThreadId();
HANDLE hIOCP = (HANDLE)pModemThread->m_hModemIocp ;
BOOL bNeedRecv = TRUE;
DWORD dwIoSize = 0;
DWORD dwRecvNumBytes = 0;
DWORD dwLastError = 0;
DWORD dwFlags = 0;
DWORD dwModemAnswerStatus = 0;
int iModemAnswer = 0;
int iModemSubAnswer = 0;
char chReadSmsIndex[32] = {0};
PSMS_CONTEXT pSendSms = NULL;
PPER_SOCKET_CONTEXT lpModemContext = NULL;
LPWSAOVERLAPPED lpOverlapped = NULL;
while (RUNNING == pModemThread->m_iThreadState )
{
try
{
bNeedRecv = GetQueuedCompletionStatus(hIOCP,&dwIoSize,(PDWORD_PTR)&lpModemContext,
(LPOVERLAPPED *)&lpOverlapped,1700);
dwLastError = GetLastError();
if( !bNeedRecv )
{
switch (dwLastError)
{
case WAIT_TIMEOUT:
{
pModemThread->AdjustNeedSendData2Agent();
}
break;
case ERROR_OPERATION_ABORTED:
{
//线程主动调用中止所有末完成的io操作
TraceInfo(RGB(0,0,255),"代理线程[%d]主动调用中止所有末完成的io操作!/n",dwThreadId);
}
break;
default:
{
TraceInfo(RGB(255,0,0),"完成端口检测到事件[%d]/r",dwLastError);
SetLastError(0);
}
break;
}
continue;
}
if( lpModemContext == NULL )
{
//要求本线程退出执行,父线程调用PostQueuedCompletionStatus(hIOCP, 0, 0, NULL);
TraceInfo(RGB(255,0,0),"终端处理线程[%d]退出循环!/n",dwThreadId);
return ;
}
bNeedRecv = TRUE;
switch(lpModemContext->CurrentIoOperation )
{
case IO_RECV:
{
pModemThread->FindModemAnswerFromBackString(lpModemContext->RecvData,&dwModemAnswerStatus);
iModemAnswer = LOWORD(dwModemAnswerStatus);
iModemSubAnswer = HIWORD(dwModemAnswerStatus);
TraceInfo(RGB(0,0,255),"%s接收到数据为%s",lpModemContext->chSocketIp,lpModemContext->RecvData);
if ( iModemAnswer &AT_CMTI)
{
lpModemContext->has_sms_cnt+=iModemSubAnswer;
}
switch (lpModemContext->modemStatus)
{
case S_NOT_INIT:
{
if (iModemAnswer &AT_OK)
++ lpModemContext->initAtCommand;
if (iModemAnswer &AT_OK || iModemAnswer & AT_ERROR)
{
pModemThread->SendInitAtCommand(lpModemContext);
bNeedRecv = FALSE;
}
}
break;
case S_MODEM_SEND_SMS_ACQUIRE:
{
pSendSms = (PSMS_CONTEXT)lpModemContext->pCurrentAffair;
if (iModemAnswer &AT_GOONSEND)
{
lpModemContext->modemStatus=S_MODEM_SMS_SENDING;
TraceData((char*)pSendSms->stSmsData,lstrlen(pSendSms->stSmsData));
pModemThread->SendData2Modem(lpModemContext
,(BYTE*)pSendSms->stSmsData,lstrlen(pSendSms->stSmsData));
bNeedRecv = FALSE;
}
else if (iModemAnswer &AT_ERROR)
{
Sleep(100);
pModemThread->SendData2Modem(lpModemContext
,(BYTE*)lpModemContext->SendData,lpModemContext->SendBuffer.len);
bNeedRecv = FALSE;
}
}
break;
case S_MODEM_SMS_SENDING:
{
if (iModemAnswer &AT_OK || iModemAnswer &AT_ERROR)
{
pSendSms = (PSMS_CONTEXT)lpModemContext->pCurrentAffair;
EnterCriticalSection(&(pModemThread->m_csVisitLocalModem));
list<SMS_CONTEXT>::iterator pFindSms= pModemThread->m_SendOutSmsQueue.begin ();
PSMS_CONTEXT pFindSmsContext = NULL;
while (pFindSms != pModemThread->m_SendOutSmsQueue.end ())
{
pFindSmsContext = (PSMS_CONTEXT)&(pFindSms->stAffairContext) ;
if (0 == memcmp(&(pFindSmsContext->stSmsData)
,&(pSendSms->stSmsData),MAX_PACKAGE_CNT))
{
pModemThread->m_SendOutSmsQueue.erase(pFindSms);
break;
}
++ pFindSms;
}
LeaveCriticalSection(&(pModemThread->m_csVisitLocalModem));
lpModemContext->modemStatus=S_MODEM_IDLE;
}
}
case S_MODEM_IDLE:
case S_MODEM_DELSMS:
case S_MODEM_WAIT:
{
if (lpModemContext->has_sms_cnt >0)
{
sprintf(chReadSmsIndex,"AT+CMGR=%d/r",lpModemContext->has_sms_cnt);
lpModemContext->modemStatus = S_MODEM_WAIT_SMS;
pModemThread->SendData2Modem(lpModemContext
,(BYTE*)chReadSmsIndex,lstrlen(chReadSmsIndex));
bNeedRecv = FALSE;
}
}
break;
case S_MODEM_WAIT_SMS:
{
if (iModemAnswer & AT_OK )
{
-- lpModemContext->has_sms_cnt;
//分析接受到的短消息
pModemThread->DecodeRecvSms(lpModemContext);
}
if (lpModemContext->has_sms_cnt <= 0)
{
sprintf(chReadSmsIndex,"AT+CMGD=1,1/r");
lpModemContext->modemStatus = S_MODEM_DELSMS;
pModemThread->SendData2Modem(lpModemContext
,(BYTE*)chReadSmsIndex,lstrlen(chReadSmsIndex));
bNeedRecv = FALSE;
}
else
{
sprintf(chReadSmsIndex,"AT+CMGR=%d/r",lpModemContext->has_sms_cnt);
lpModemContext->modemStatus = S_MODEM_WAIT_SMS;
pModemThread->SendData2Modem(lpModemContext
,(BYTE*)chReadSmsIndex,lstrlen(chReadSmsIndex));
bNeedRecv = FALSE;
}
}
break;
}
}
break;
case IO_SEND:
if (0 ==FlushFileBuffers((HANDLE)lpModemContext->sScoket))
{
Sleep(100);
}
break;
default:
_ASSERT(0);
}
if (TRUE == bNeedRecv)
{
pModemThread->LetModemReRecvAgain(lpModemContext);
}
}
catch(...)
{
}
}
}
9733
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
