psgip.cpp

手机开发环境BREW实例

								pcSgip->m_sSMBuffer[dwRet].bFlag++;
								pcSgip->m_dwLastError4Protocol = sSgipMsg.uMessageBody.sMessageSubmitRep.bResult;
								pcSgip->m_dwLastTime4ProtocolError = dwTime;
								pcSgip->m_dwSubmitResponseFailedNumber++;
#ifdef REC_FILE
								pcSgip->m_cFileRecorder.Submit(pcSgip->m_szDebugPath, pcSgip->m_szCorpID, (BYTE*)&pcSgip->m_sSMBuffer[dwRet].sSgipMsg, ntohl(pcSgip->m_sSMBuffer[dwRet].sSgipMsg.sMessageHead.dwCommandLength), -sSgipMsg.uMessageBody.sMessageSubmitRep.bResult);
#endif
							}
							else
							{
								//记录入文件
#ifdef REC_FILE
								pcSgip->m_cFileRecorder.Submit(pcSgip->m_szDebugPath, pcSgip->m_szCorpID, (BYTE*)&pcSgip->m_sSMBuffer[dwRet].sSgipMsg, ntohl(pcSgip->m_sSMBuffer[dwRet].sSgipMsg.sMessageHead.dwCommandLength), 0);
#endif
								pcSgip->m_sSMBuffer[dwRet].bFlag = FLAG_BUFFER_VALID;
								//把楼上这个Valid入到队m_cQueueEmpty中
								if(!pcSgip->m_cQueueEmpty.In(dwRet))
								{
									ATLTRACE("在ThreadCMPPRecv入队时出错，队m_cQueueEmpty已满\n");
								}
								pcSgip->m_dwSubmitResponseSuccessedNumber++;
							}
							break;
						}
					}
				}
				break;
			}
		}
	}
	pcSgip->m_bIsRecvRun = false;
	return 0;

WAITRECV_EXIT:
	pcSgip->m_bIsRecvRun = false;
	pcSgip->Terminate();
	return 0;
}
/////////////////////////////////////////////////////////////////////////////
// CPSgip


STDMETHODIMP CPSgip::Bind(BSTR bStrIP, short iPort, BSTR bStrLoginName, BSTR bStrPassword, long *plError)
{
	bool bIsSocketValid = false;
	USES_CONVERSION;
	SYSTEMTIME sSystemTime4Local;
	GetLocalTime(&sSystemTime4Local);
	DWORD dwTime = sSystemTime4Local.wMonth * 100000000 + 
		sSystemTime4Local.wDay * 1000000 + 
		sSystemTime4Local.wHour * 10000 + 
		sSystemTime4Local.wMinute * 100 + 
		sSystemTime4Local.wSecond;

	*plError = ERROR_NOT;

	if(!m_bIsInit)
	{
		*plError = ERROR_INIT_FAIL;
		goto BIND_EXIT;
	}

	if(m_bIsBinded)
	{
		*plError = ERROR_ALREADY_BIND;
		goto BIND_EXIT;
	}

	if(m_bIsBinding)
	{
		*plError = ERROR_IS_BINDING;
		goto BIND_EXIT;
	}
	m_bIsBinding = true;
#ifndef _DEBUG_FILE
	bIsSocketValid = true;
	//create
	m_sSocket4MT = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
	if(m_sSocket4MT == INVALID_SOCKET) 
	{
		m_dwLastError4System = GetLastError();
		*plError = ERROR_WS_INVALID_SOCKET;
		goto BIND_EXIT;
	}

	struct sockaddr_in sSockAddr4Dest;
	DWORD dwRet;
	char szPara[MAX_PATH];
	//connect
	if(strlen(m_szLocalIP) > 6 && strlen(m_szLocalIP) < 16)
	{
		dwRet = inet_addr(m_szLocalIP);
		if(dwRet == INADDR_NONE)
		{
			*plError = ERROR_INVALID_IP_ADDRESS;
			goto BIND_EXIT;
		}
		
	}
	strncpy(szPara, W2A(bStrIP), MAX_PATH);
	dwRet = inet_addr(szPara);
	if(dwRet == INADDR_NONE)
	{
		*plError = ERROR_INVALID_IP_ADDRESS;
		goto BIND_EXIT;
	}
	BZERO(sSockAddr4Dest);
	sSockAddr4Dest.sin_addr.S_un.S_addr = dwRet;
	sSockAddr4Dest.sin_family = AF_INET;
	if(!iPort)iPort = SGIP_PORT;
	sSockAddr4Dest.sin_port = htons(iPort);

	dwRet = connect(m_sSocket4MT, (struct sockaddr*)&sSockAddr4Dest, sizeof(sSockAddr4Dest));
	if(dwRet == SOCKET_ERROR)
	{
		m_dwLastError4System = GetLastError();
		*plError = ERROR_WS_SEND_TIMEOUT;
		goto BIND_EXIT;
	}
	//bind transmitter
	BZERO(m_sSgipMsg);
	m_sSgipMsg.uMessageBody.sMessageBind.bLoginType = 1;
	strncpy(m_sSgipMsg.uMessageBody.sMessageBind.szLoginName, W2A(bStrLoginName), SGIP_MAX_LEN_USERNAME);
	strncpy(m_sSgipMsg.uMessageBody.sMessageBind.szPassword, W2A(bStrPassword), SGIP_MAX_LEN_PASSWORD);

	m_sSgipMsg.sMessageHead.dwCommandLength = htonl(sizeof(_SGIP_HEAD) + sizeof(_SGIP_BIND));
	m_sSgipMsg.sMessageHead.dwCommandID = htonl(SGIP_BIND);
	m_sSgipMsg.sMessageHead.sMsgID.dwSPID = htonl(m_dwSPID);
	m_sSgipMsg.sMessageHead.sMsgID.dwTime = htonl(dwTime);
	m_sSgipMsg.sMessageHead.sMsgID.dwSequenceNO = htonl(++m_dwSequenceNO);

	dwRet = send(m_sSocket4MT, (char *)&m_sSgipMsg, sizeof(_SGIP_HEAD) + sizeof(_SGIP_BIND), 0);
	if(dwRet == SOCKET_ERROR)
	{
		m_dwLastError4System = GetLastError();
		*plError = ERROR_WS_SEND_TIMEOUT;
		goto BIND_EXIT;
	}
	if(dwRet != sizeof(_SGIP_HEAD) + sizeof(_SGIP_BIND)) 
	{
		*plError = ERROR_WS_SEND_FAIL;
		goto BIND_EXIT;
	}

	//set option
	fd_set	sFDS4Read;
	FD_ZERO(&sFDS4Read);
	m_sTimeval4Timeout.tv_sec = m_lTimeout4Connect / 1000000;
	m_sTimeval4Timeout.tv_usec = m_lTimeout4Connect % 1000000;

	FD_SET(m_sSocket4MT, &sFDS4Read);
	dwRet = select(0, &sFDS4Read, NULL, NULL, &m_sTimeval4Timeout);
	if(dwRet == SOCKET_ERROR)
	{
		m_dwLastError4System = GetLastError();
		*plError = ERROR_WS_SET_FAIL;
		goto BIND_EXIT;
	}
	if(dwRet == 0 || !FD_ISSET(m_sSocket4MT, &sFDS4Read))
	{
		*plError = ERROR_WS_RECV_TIMEOUT;
		goto BIND_EXIT;
	}

	dwRet = recv(m_sSocket4MT, (char *)&m_sSgipMsg, sizeof(_SGIP), 0);
	if(dwRet == SOCKET_ERROR)
	{
		m_dwLastError4System = GetLastError();
		*plError = ERROR_WS_RECV_TIMEOUT;
		goto BIND_EXIT;
	}
	if(dwRet != sizeof(_SGIP_HEAD) + sizeof(_SGIP_BIND_REP)) 
	{
		*plError = ERROR_WS_RECV_FAIL;
		goto BIND_EXIT;
	}
	if(!(dwRet == ntohl(m_sSgipMsg.sMessageHead.dwCommandLength) && 
		ntohl(m_sSgipMsg.sMessageHead.dwCommandID) == SGIP_BIND_REP && 
		ntohl(m_sSgipMsg.sMessageHead.sMsgID.dwSequenceNO) == m_dwSequenceNO))
	{
		*plError = ERROR_WS_RECV_FAIL;
		goto BIND_EXIT;
	}
	m_dwCurrentError4Protocol = m_sSgipMsg.uMessageBody.sMessageBindRep.bResult;
	if(m_sSgipMsg.uMessageBody.sMessageBindRep.bResult)
	{
		*plError = ERROR_BIND_FAIL;
		m_dwLastError4Protocol = m_sSgipMsg.uMessageBody.sMessageBindRep.bResult;
		m_dwLastTime4ProtocolError = dwTime;
		goto BIND_EXIT;
	}
#endif

//	m_lNoRecvCount = 0;//未收到网关数据包的时间计数
	//bind receiver
	{
	m_bIsEnableRun = true;
	DWORD dwThreadID;
	m_hThreadAccept = CreateThread(0, 0, ThreadSGIPSend, (void *)this, 0, &dwThreadID);
	CloseHandle(m_hThreadAccept);
#ifndef _DEBUG_FILE
	m_hThreadAccept = CreateThread(0, 0, ThreadSGIPRecv, (void *)this, 0, &dwThreadID);
	CloseHandle(m_hThreadAccept);
#endif
//	HANDLE hThread4SGIPAccept = CreateThread(0, 0, Thread4SGIPAccept, (void *)this, 0, &dwThreadID);
//	CloseHandle(hThread4SGIPAccept);
	}
	m_bIsBinded = true;
	m_bIsBinding = false;
	return S_OK;

BIND_EXIT:
	if(bIsSocketValid)
	{
		closesocket(m_sSocket4MT);
		m_bIsBinded = false;
		closesocket(m_socket4SgipListen);
		m_bIsEnableListen = true;
		m_bIsListenRun = false;
	}
	m_bIsBinding = false;
	return S_OK;
}

STDMETHODIMP CPSgip::Unbind(long *plError)
{
	DWORD dwRet;
	*plError = ERROR_NOT;

	m_bIsEnableListen = false;
//	m_bEnalbeThread4AccepRunning = FALSE;
	while(m_bIsListenRun)
	{
		Sleep(m_lPauseTime4Terminate / 1000);
	}
/*	while(m_bThread4AcceptRunning)
	{
		Sleep(m_lPauseTime4Terminate / 1000);
	}
*/
	if(!m_bIsBinded)return S_OK;

#ifndef _DEBUG_FILE
	BZERO(m_sSgipMsg);
	SYSTEMTIME sSystemTime4Local;
	GetLocalTime(&sSystemTime4Local);
	dwRet = sSystemTime4Local.wMonth * 100000000 + 
		sSystemTime4Local.wDay * 1000000 + 
		sSystemTime4Local.wHour * 10000 + 
		sSystemTime4Local.wMinute * 100 + 
		sSystemTime4Local.wSecond;

	m_sSgipMsg.sMessageHead.dwCommandLength = htonl(sizeof(_SGIP_HEAD));
	m_sSgipMsg.sMessageHead.dwCommandID = htonl(SGIP_UNBIND);
	m_sSgipMsg.sMessageHead.sMsgID.dwSPID = htonl(m_dwSPID);
	m_sSgipMsg.sMessageHead.sMsgID.dwTime = htonl(dwRet);
	m_sSgipMsg.sMessageHead.sMsgID.dwSequenceNO = htonl(++m_dwSequenceNO);

	fd_set	sFDS4Write;
	FD_ZERO(&sFDS4Write);
	FD_SET(m_sSocket4MT, &sFDS4Write);
	m_sTimeval4Timeout.tv_sec = m_lTimeout4Connect / 1000000;
	m_sTimeval4Timeout.tv_usec = m_lTimeout4Connect % 1000000;
	dwRet = select(0, NULL, &sFDS4Write, NULL, &m_sTimeval4Timeout);
	if(dwRet == SOCKET_ERROR)
	{
		m_dwLastError4System = GetLastError();
		*plError = ERROR_WS_SET_FAIL;
		goto TERMINATE_EXIT;
	}
	if(dwRet == 0 || !FD_ISSET(m_sSocket4MT, &sFDS4Write))
	{
		*plError = ERROR_WS_SEND_TIMEOUT;
		goto TERMINATE_EXIT;
	}

	WSASetEvent(m_hEvent4Socket);
	send(m_sSocket4MT, (char *)&m_sSgipMsg, ntohl(m_sSgipMsg.sMessageHead.dwCommandLength), 0);
	WSAResetEvent(m_hEvent4Socket);
	m_bIsUnbind = true;

TERMINATE_EXIT:
#endif
	Terminate();

	return S_OK;
}

STDMETHODIMP CPSgip::Submit(BSTR bStrMobileCode, VARIANT *pMessageContent, long *plError)
{
	*plError = ERROR_NOT;

	if(!m_bIsBinded)
	{
		*plError = ERROR_BIND_FAIL;
		goto SUBMIT_EXIT;
	}

	if(bStrMobileCode)
	{
		put_MobileID(bStrMobileCode);
		if(pMessageContent->vt != VT_ERROR)
		{
			//单条发送
			put_MessageContent(*pMessageContent);
			if(!AddMobileID(bStrMobileCode))
			{
				*plError = ERROR_BUFFER_FULL;
				goto SUBMIT_EXIT;
			}
			if(m_lBufferIndex4MultiSM >= 0)
			{
				m_sSMBuffer[m_lBufferIndex4MultiSM].bFlag = FLAG_BUFFER_READY;
				//放入缓冲区的内容位置入到m_cQueueReady
				if(!m_cQueueReady.In(m_lBufferIndex4MultiSM))
				{
					ATLTRACE("Submit中调用m_cQueueReady.In(m_lBufferIndex4MultiSM)返回False(1)\n");
				}
				m_lBufferIndex4MultiSM = -1;
			}
		}
		else
		{
			//继续多条发送
			if(!AddMobileID(bStrMobileCode))
			{
				*plError = ERROR_BUFFER_FULL;
				goto SUBMIT_EXIT;
			}
		}
	}
	else
	{
		//结束多条发送
		if(m_lBufferIndex4MultiSM >= 0)
		{
			m_sSMBuffer[m_lBufferIndex4MultiSM].bFlag = FLAG_BUFFER_READY;
			//放入缓冲区的内容位置入到m_cQueueReady
			if(!m_cQueueReady.In(m_lBufferIndex4MultiSM))
			{
				ATLTRACE("Submit中调用m_cQueueReady.In(m_lBufferIndex4MultiSM)返回False(2)\n");
			}
			m_lBufferIndex4MultiSM = -1;
		}
		if(pMessageContent->vt != VT_ERROR)
		{
			//开始多条发送
			put_MessageContent(*pMessageContent);
		}
	}

SUBMIT_EXIT:
	return S_OK;
}

STDMETHODIMP CPSgip::get_MobileID(BSTR *pVal)
{
	USES_CONVERSION;
	*pVal = A2BSTR(m_szMobileID);

	return S_OK;
}

STDMETHODIMP CPSgip::put_MobileID(BSTR newVal)
{
	USES_CONVERSION;
	strncpy(m_szMobileID, W2A(newVal), MAX_BUFFER_LEN_MOBILE_ID);

	return S_OK;
}

STDMETHODIMP CPSgip::get_MessageContent(VARIANT *pVal)
{
	if(m_lMesageContentLength)
	{
		pVal->vt = VT_UI1 | VT_ARRAY;

		SAFEARRAYBOUND rgsabound[1];
		rgsabound[0].lLbound = 0;
		rgsabound[0].cElements = m_lMesageContentLength;
		pVal->parray = SafeArrayCreate(VT_UI1, 1, rgsabound);
		if(pVal->parray)
		{
			SafeArrayLock(pVal->parray);
			for(int i = 0; i < m_lMesageContentLength; i++)
				((BYTE *)(pVal->parray->pvData))[i] = m_BMessageContent[i];
			SafeArrayUnlock(pVal->parray);
		}
	}
	else
	{
		pVal->vt = VT_BSTR;
		pVal->bstrVal = A2BSTR((char *)m_BMessageContent);
	}

	return S_OK;
}

STDMETHODIMP CPSgip::put_MessageContent(VARIANT newVal)
{
	if(newVal.vt & VT_UI1 && newVal.vt & VT_ARRAY)
	{
		unsigned int i;
		for(i = newVal.parray->rgsabound->lLbound; i < ((MAX_BUFFER_LEN_CONTENT > newVal.parray->rgsabound->cElements)?newVal.parray->rgsabound->cElements:MAX_BUFFER_LEN_CONTENT); i++)
		{
			m_BMessageContent[i] = ((BYTE*)((newVal.vt & VT_BYREF)?(*newVal.pparray)->pvData:newVal.parray->pvData))[i];
		}
		m_lMesageContentLength = i;
	}
	if(newVal.vt & VT_BSTR)
	{
		USES_CONVERSION;
		strncpy((char *)m_BMessageContent, 
			W2A((newVal.vt & VT_BYREF)?*(newVal.pbstrVal):newVal.bstrVal), 
			MAX_BUFFER_LEN_CONTENT);
		m_lMesageContentLength = strlen((char *)m_BMessageContent);
	}

	return S_OK;
}

STDMETHODIMP CPSgip::get_Priority(BYTE *pVal)
{
	*pVal = m_bPriority;

	return S_OK;
}

STDMETHODIMP CPSgip::put_Priority(BYTE newVal)
{
	m_bPriority = newVal;

	return S_OK;
}

STDMETHODIMP CPSgip::get_ScheduleTime(BSTR *pVal)
{
	USES_CONVERSION;

	m_szScheduleTime[12] = 0;
	*pVal = A2BSTR(m_szScheduleTime);