?? smstraffic.cpp
字號:
// SmsTraffic.cpp: implementation of the CSmsTraffic class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "SmsTraffic.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CSmsTraffic::CSmsTraffic()
{
m_nSendIn = 0;
m_nSendOut = 0;
m_nRecvIn = 0;
m_nRecvOut = 0;
m_nSendInTimeOut=0;
m_nSendOutTimeOut=0;
m_hKillThreadEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
m_hThreadKilledEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
InitializeCriticalSection(&m_csSend);
InitializeCriticalSection(&m_csRecv);
// 啟動子線程
AfxBeginThread(SmThread, this, THREAD_PRIORITY_NORMAL);
}
CSmsTraffic::~CSmsTraffic()
{
SetEvent(m_hKillThreadEvent); // 發出關閉子線程的信號
WaitForSingleObject(m_hThreadKilledEvent, INFINITE); // 等待子線程關閉
DeleteCriticalSection(&m_csSend);
DeleteCriticalSection(&m_csRecv);
CloseHandle(m_hKillThreadEvent);
CloseHandle(m_hThreadKilledEvent);
}
// 將一條短消息放入發送隊列
bool CSmsTraffic::PutSendMessage(SM_PARAM* pparam)
{
static int busy=0;
if(busy)
return 0;
busy=1;
bool Success = TRUE;
int m_nSendIn_tmp=m_nSendIn,nDstLength;
EnterCriticalSection(&m_csSend);
if(pparam->TP_DCS==GSM_UCS2)
{
WCHAR wchar[1024];
pparam->m_this_num=1;
pparam->m_total_num=1;
nDstLength = ::MultiByteToWideChar(CP_ACP, 0, pparam->TP_UD, -1, wchar, 1024);
if(nDstLength>70)
pparam->m_total_num=(nDstLength/66)+1;
do
{
if(nDstLength>70)
{
memset(pparam->TP_UD,0,sizeof(pparam->TP_UD));
WideCharToMultiByte(CP_ACP, 0, wchar, 66, pparam->TP_UD, 160, NULL, NULL);
memcpy(wchar,&wchar[66],(nDstLength-66)*2);
nDstLength-=66;
}
else
{
memset(pparam->TP_UD,0,sizeof(pparam->TP_UD));
WideCharToMultiByte(CP_ACP, 0, wchar, 70, pparam->TP_UD, 160, NULL, NULL);
nDstLength=0;
}
memcpy(&m_SmSend[m_nSendIn_tmp], pparam, sizeof(SM_PARAM));
m_nSendIn_tmp++;
if (m_nSendIn_tmp >= MAX_SM_SEND) m_nSendIn_tmp = 0;
if(m_nSendIn_tmp==m_nSendOut)
{
Success=0;
break;
}
pparam->m_this_num++;
} while (nDstLength);
if(Success)
m_nSendIn=m_nSendIn_tmp;
}
else
{
memcpy(&m_SmSend[m_nSendIn], pparam, sizeof(SM_PARAM));
m_nSendIn++;
if (m_nSendIn >= MAX_SM_SEND) m_nSendIn = 0;
if(m_nSendIn==m_nSendOut)
Success=0;
}
LeaveCriticalSection(&m_csSend);
busy=0;
return Success;
}
// 從發送隊列中取一條短消息
BOOL CSmsTraffic::GetSendMessage(SM_PARAM* pparam)
{
BOOL fSuccess = FALSE;
EnterCriticalSection(&m_csSend);
int num=0,tmp;
tmp=m_nSendOut;
while(tmp!=m_nSendIn)
{
tmp++;
if (tmp >= MAX_SM_SEND) tmp = 0;
num++;
}
tmp=m_nSendOutTimeOut;
while(tmp!=m_nSendInTimeOut)
{
tmp++;
if (tmp >= MAX_SM_SEND) tmp = 0;
num++;
}
m_WaitNum=num;
if (m_nSendOut != m_nSendIn)
{
memcpy(pparam, &m_SmSend[m_nSendOut], sizeof(SM_PARAM));
pparam->send_times=0;
pparam->send_type=0;
m_nSendOut++;
if (m_nSendOut >= MAX_SM_SEND) m_nSendOut = 0;
fSuccess = TRUE;
}
else
{
if (m_nSendOutTimeOut != m_nSendInTimeOut)
{
memcpy(pparam, &m_SmSendTimeOut[m_nSendOutTimeOut], sizeof(SM_PARAM));
pparam->send_times=0;
pparam->send_type=1;
m_nSendOutTimeOut++;
if (m_nSendOutTimeOut >= MAX_SM_SEND) m_nSendOutTimeOut = 0;
fSuccess = TRUE;
}
}
LeaveCriticalSection(&m_csSend);
return fSuccess;
}
// 將短消息放入接收隊列
void CSmsTraffic::PutRecvMessage(SM_PARAM* pparam, int nCount)
{
EnterCriticalSection(&m_csRecv);
for (int i = 0; i < nCount; i++)
{
memcpy(&m_SmRecv[m_nRecvIn], pparam, sizeof(SM_PARAM));
m_nRecvIn++;
if (m_nRecvIn >= MAX_SM_RECV) m_nRecvIn = 0;
pparam++;
}
LeaveCriticalSection(&m_csRecv);
}
// 從接收隊列中取一條短消息
BOOL CSmsTraffic::GetRecvMessage(SM_PARAM* pparam)
{
BOOL fSuccess = FALSE;
EnterCriticalSection(&m_csRecv);
if (m_nRecvOut != m_nRecvIn)
{
memcpy(pparam, &m_SmRecv[m_nRecvOut], sizeof(SM_PARAM));
m_nRecvOut++;
if (m_nRecvOut >= MAX_SM_RECV) m_nRecvOut = 0;
fSuccess = TRUE;
}
LeaveCriticalSection(&m_csRecv);
return fSuccess;
}
void CSmsTraffic::SendTimeOut(SM_PARAM* pparam)
{
if(pparam->send_type)
{
// m_nSendOutTimeOut++;
// if (m_nSendOutTimeOut >= MAX_SM_SEND) m_nSendOutTimeOut = 0;
}
else
{
memcpy(&m_SmSendTimeOut[m_nSendInTimeOut], pparam, sizeof(SM_PARAM));
m_nSendInTimeOut++;
if (m_nSendInTimeOut >= MAX_SM_SEND) m_nSendInTimeOut = 0;
}
}
UINT CSmsTraffic::SmThread(LPVOID lParam)
{
CSmsTraffic* p=(CSmsTraffic *)lParam; // this
int nMsg; // 收到短消息條數
int nDelete; // 目前正在刪除的短消息編號
SM_BUFF buff; // 接收短消息列表的緩沖區
SM_PARAM param[256]; // 發送/接收短消息緩沖區
CTime tmOrg, tmNow; // 上次和現在的時間，計算超時用
enum {
stBeginRest, // 開始休息/延時
stContinueRest, // 繼續休息/延時
stSendMessageRequest, // 發送短消息
stSendMessageResponse, // 讀取短消息列表到緩沖區
stSendMessageWaitIdle, // 發送不成功，等待GSM就緒
stReadMessageRequest, // 發送讀取短消息列表的命令
stReadMessageResponse, // 讀取短消息列表到緩沖區
stDeleteMessageRequest, // 刪除短消息
stDeleteMessageResponse, // 刪除短消息
stDeleteMessageWaitIdle, // 刪除不成功，等待GSM就緒
stExitThread // 退出
} nState; // 處理過程的狀態
// 初始狀態
nState = stBeginRest;
// 發送和接收處理的狀態循環
while (nState != stExitThread)
{
switch(nState)
{
case stBeginRest:
// TRACE("State=stBeginRest\n");
tmOrg = CTime::GetCurrentTime();
nState = stContinueRest;
break;
case stContinueRest:
// TRACE("State=stContinueRest\n");
Sleep(300);
tmNow = CTime::GetCurrentTime();
if (p->GetSendMessage(¶m[0]))
{
nState = stSendMessageRequest; // 有待發短消息，就不休息了
}
else
if (tmNow - tmOrg >= 5) // 待發短消息隊列空，休息5秒
{
nState = stReadMessageRequest; // 轉到讀取短消息狀態
}
break;
case stSendMessageRequest:
// TRACE("State=stSendMessageRequest\n");
p->gsmSendMessage(¶m[0]);
memset(&buff, 0, sizeof(buff));
tmOrg = CTime::GetCurrentTime();
nState = stSendMessageResponse;
break;
case stSendMessageResponse:
// TRACE("State=stSendMessageResponse\n");
Sleep(100);
tmNow = CTime::GetCurrentTime();
switch (p->gsmGetResponse(&buff))
{
case GSM_OK:
// TRACE(" GSM_OK %d\n", tmNow - tmOrg);
nState = stBeginRest;
break;
case GSM_ERR:
// TRACE(" GSM_ERR %d\n", tmNow - tmOrg);
nState = stSendMessageWaitIdle;
break;
default:
// TRACE(" GSM_WAIT %d\n", tmNow - tmOrg);
if (tmNow - tmOrg >= 10) // 10秒超時
{
// TRACE(" Timeout!\n");
nState = stSendMessageWaitIdle;
}
}
break;
case stSendMessageWaitIdle:
param[0].send_times++;
if(param[0].send_type)
Sleep((5000));
else
Sleep(500);
if(param[0].send_times>10)
{
p->SendTimeOut(¶m[0]);
nState = stBeginRest;
}
else
nState = stSendMessageRequest; // 超時次數未到繼續發送
break;
case stReadMessageRequest:
// TRACE("State=stReadMessageRequest\n");
p->gsmReadMessageList();
memset(&buff, 0, sizeof(buff));
tmOrg = CTime::GetCurrentTime();
nState = stReadMessageResponse;
break;
case stReadMessageResponse:
// TRACE("State=stReadMessageResponse\n");
Sleep(100);
tmNow = CTime::GetCurrentTime();
switch (p->gsmGetResponse(&buff))
{
case GSM_OK:
// TRACE(" GSM_OK %d\n", tmNow - tmOrg);
nMsg = p->gsmParseMessageList(param, &buff);
if (nMsg > 0)
{
p->PutRecvMessage(param, nMsg);
nDelete = 0;
nState = stDeleteMessageRequest;
}
else
{
nState = stBeginRest;
}
break;
case GSM_ERR:
// TRACE(" GSM_ERR %d\n", tmNow - tmOrg);
nState = stBeginRest;
break;
default:
// TRACE(" GSM_WAIT %d\n", tmNow - tmOrg);
if (tmNow - tmOrg >= 15) // 15秒超時
{
// TRACE(" Timeout!\n");
nState = stBeginRest;
}
}
break;
case stDeleteMessageRequest:
// TRACE("State=stDeleteMessageRequest\n");
if (nDelete < nMsg)
{
p->gsmDeleteMessage(param[nDelete].index);
memset(&buff, 0, sizeof(buff));
tmOrg = CTime::GetCurrentTime();
nState = stDeleteMessageResponse;
}
else
{
nState = stBeginRest;
}
break;
case stDeleteMessageResponse:
// TRACE("State=stDeleteMessageResponse\n");
Sleep(100);
tmNow = CTime::GetCurrentTime();
switch (p->gsmGetResponse(&buff))
{
case GSM_OK:
// TRACE(" GSM_OK %d\n", tmNow - tmOrg);
nDelete++;
nState = stDeleteMessageRequest;
break;
case GSM_ERR:
// TRACE(" GSM_ERR %d\n", tmNow - tmOrg);
nState = stDeleteMessageWaitIdle;
break;
default:
// TRACE(" GSM_WAIT %d\n", tmNow - tmOrg);
if (tmNow - tmOrg >= 5) // 5秒超時
{
// TRACE(" Timeout!\n");
nState = stBeginRest;
}
}
break;
case stDeleteMessageWaitIdle:
// TRACE("State=stDeleteMessageWaitIdle\n");
Sleep(500);
nState = stDeleteMessageRequest; // 直到刪除成功為止
break;
}
// 檢測是否有關閉本線程的信號
DWORD dwEvent = WaitForSingleObject(p->m_hKillThreadEvent, 20);
if (dwEvent == WAIT_OBJECT_0) nState = stExitThread;
}
// 置該線程結束標志
SetEvent(p->m_hThreadKilledEvent);
return 9999;
}
// 可打印字符串轉換為字節數據
// 如："C8329BFD0E01" --> {0xC8, 0x32, 0x9B, 0xFD, 0x0E, 0x01}
// 輸入: pSrc - 源字符串指針
// nSrcLength - 源字符串長度
// 輸出: pDst - 目標數據指針
// 返回: 目標數據長度
int CSmsTraffic::gsmString2Bytes(const char* pSrc, unsigned char* pDst, int nSrcLength)
{
for (int i = 0; i < nSrcLength; i += 2)
{
// 輸出高4位
if ((*pSrc >= '0') && (*pSrc <= '9'))
{
*pDst = (*pSrc - '0') << 4;
}
else
{
*pDst = (*pSrc - 'A' + 10) << 4;
}
pSrc++;
// 輸出低4位
if ((*pSrc>='0') && (*pSrc<='9'))
{
*pDst |= *pSrc - '0';
}
else
{
*pDst |= *pSrc - 'A' + 10;
}
pSrc++;
pDst++;
}
// 返回目標數據長度
return (nSrcLength / 2);
}
// 字節數據轉換為可打印字符串
// 如：{0xC8, 0x32, 0x9B, 0xFD, 0x0E, 0x01} --> "C8329BFD0E01"
// 輸入: pSrc - 源數據指針
// nSrcLength - 源數據長度
// 輸出: pDst - 目標字符串指針
// 返回: 目標字符串長度
int CSmsTraffic::gsmBytes2String(const unsigned char* pSrc, char* pDst, int nSrcLength)
{
const char tab[]="0123456789ABCDEF"; // 0x0-0xf的字符查找表
for (int i = 0; i < nSrcLength; i++)
{
*pDst++ = tab[*pSrc >> 4]; // 輸出高4位
*pDst++ = tab[*pSrc & 0x0f]; // 輸出低4位
pSrc++;
}
// 輸出字符串加個結束符
*pDst = '\0';
// 返回目標字符串長度
return (nSrcLength * 2);
}
// 7bit編碼
// 輸入: pSrc - 源字符串指針
// nSrcLength - 源字符串長度
// 輸出: pDst - 目標編碼串指針
// 返回: 目標編碼串長度
int CSmsTraffic::gsmEncode7bit(const char* pSrc, unsigned char* pDst, int nSrcLength)
{
int nSrc; // 源字符串的計數值
int nDst; // 目標編碼串的計數值
int nChar; // 當前正在處理的組內字符字節的序號，范圍是0-7
unsigned char nLeft; // 上一字節殘余的數據
// 計數值初始化
nSrc = 0;
nDst = 0;
// 將源串每8個字節分為一組，壓縮成7個字節
// 循環該處理過程，直至源串被處理完
// 如果分組不到8字節，也能正確處理
while (nSrc < nSrcLength)
{
// 取源字符串的計數值的最低3位
nChar = nSrc & 7;
// 處理源串的每個字節
if(nChar == 0)
{
// 組內第一個字節，只是保存起來，待處理下一個字節時使用
nLeft = *pSrc;
}
else
{
// 組內其它字節，將其右邊部分與殘余數據相加，得到一個目標編碼字節
*pDst = (*pSrc << (8-nChar)) | nLeft;
// 將該字節剩下的左邊部分，作為殘余數據保存起來
nLeft = *pSrc >> nChar;
// 修改目標串的指針和計數值
pDst++;
nDst++;
}
// 修改源串的指針和計數值
pSrc++;
nSrc++;
}
// 返回目標串長度
return nDst;
}
// 7bit解碼
// 輸入: pSrc - 源編碼串指針
// nSrcLength - 源編碼串長度
// 輸出: pDst - 目標字符串指針
// 返回: 目標字符串長度
int CSmsTraffic::gsmDecode7bit(const unsigned char* pSrc, char* pDst, int nSrcLength)
{
int nSrc; // 源字符串的計數值
int nDst; // 目標解碼串的計數值
int nByte; // 當前正在處理的組內字節的序號，范圍是0-6
unsigned char nLeft; // 上一字節殘余的數據
// 計數值初始化
nSrc = 0;
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -