blocksock.cpp

MPEG4网络视频服务器客户端图象监控软件

// MsgSock.cpp: implementation of the CMsgSock class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "BlockSock.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
CBlockSocket::CBlockSocket()
{
	m_hSocket	= INVALID_SOCKET;
	m_dwError	= 0;
	tv			= NULL;
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
CBlockSocket::~CBlockSocket()
{
	if(tv)
	{
		delete tv;
		tv	= NULL;
	}
	Close();
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::Socket(int nSocketType, int nProtocolType, int nAddressFormat)
{
	m_hSocket = socket(nAddressFormat, nSocketType, nProtocolType);
	if(m_hSocket == INVALID_SOCKET)
		return FALSE;
	return TRUE;
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::Bind(UINT uiSocketPort, LPCTSTR lpszSocketAddress)
{
	SOCKADDR_IN sockAddr;
	ZeroMemory(&sockAddr, sizeof(sockAddr));

	LPSTR lpszAscii = (LPSTR)lpszSocketAddress;
	sockAddr.sin_family	= AF_INET;

	if(NULL == lpszAscii)
		sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else{
		DWORD lResult = inet_addr(lpszAscii);
		if(lResult == INADDR_NONE)
		{
			WSASetLastError(WSAEINVAL);
			return FALSE;
		}
		sockAddr.sin_addr.s_addr = lResult;
	}

	sockAddr.sin_port = htons((u_short)uiSocketPort);

	if(bind(m_hSocket, (SOCKADDR*)&sockAddr, sizeof(sockAddr)))
		return FALSE;
	return TRUE;
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::Create(UINT nSocketPort, BOOL bBound, LPCTSTR lpAddress, int nSocketType)
{
	if(Socket(nSocketType))
	{
		if(bBound)
		{
			if(Bind(nSocketPort, lpAddress))
			{
				return TRUE;
			}
			Close();
		}
		else{
			return TRUE;
		}
	}
//	m_dwError = TCP_CREATE_ERROR;
	return FALSE;
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::Listen()
{
	if(listen(m_hSocket, SOMAXCONN))
	{
//		m_dwError = TCP_LISTEN_ERROR;
		return FALSE;
	}
	return TRUE;
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::Accept(CBlockSocket& rcSocket, SOCKADDR* lpSockAddr, int* lpSockAddLen)
{
	SOCKET hTemp = accept(m_hSocket, lpSockAddr, lpSockAddLen);
	if(INVALID_SOCKET == hTemp)
		return FALSE;
	rcSocket.m_hSocket = hTemp;
	return TRUE;
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::Connect(LPCTSTR lpszHost, UINT uiHostPort)
{
	SOCKADDR_IN sockAddr;
	ZeroMemory(&sockAddr, sizeof(sockAddr));

	LPSTR lpszAscii = (LPSTR)lpszHost;
	sockAddr.sin_family = AF_INET;
	sockAddr.sin_addr.s_addr = inet_addr(lpszAscii);

	if (sockAddr.sin_addr.s_addr == INADDR_NONE)
	{
		LPHOSTENT lphost;
		lphost = gethostbyname(lpszAscii);
		if (lphost != NULL)
			sockAddr.sin_addr.s_addr = ((LPIN_ADDR)lphost->h_addr)->s_addr;
		else
		{
			WSASetLastError(WSAEINVAL);
			return FALSE;
		}
	}
	sockAddr.sin_port = htons((u_short)uiHostPort);

	if(connect(m_hSocket, (SOCKADDR*)&sockAddr, sizeof(sockAddr)))
	{
//		m_dwError = TCP_CONNECT_ERROR;
		return FALSE;
	}
	return TRUE;
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::SendProc(const void* lpBuf, int nBufLen, int nFlags)
{
	CString strTemp;
	int nRet = 0;
	int nTemp;
	fd_set	fdWrite;
	FD_ZERO(&fdWrite);
	FD_SET(m_hSocket, &fdWrite);
	do{
		if(0 == select(0, 0, &fdWrite, 0, tv))
		{
//			m_dwError = TCP_SEND_TIMEOUT;
//			TRACE("send timeout!\n");
			return FALSE;
		}
		if(m_hSocket == INVALID_SOCKET)
		{
//			TRACE("send invalid!\n");
//			m_dwError = TCP_SEND_ERROR;
			return FALSE;
		}
		nTemp = send(m_hSocket, (LPSTR)lpBuf+nRet, nBufLen-nRet, nFlags);
//		strTemp.Format("%d", nTemp);
//		TRACE(strTemp);
		if(SOCKET_ERROR == nTemp) 
		{
//			TRACE("send error!\n");
//			m_dwError = TCP_SEND_ERROR;
			return FALSE;
		}
	}while(nRet += nTemp, nRet < nBufLen);

	return TRUE;	
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::RecvProc(const void* lpBuf, int nBufLen, int nFlags)
{
	CString strTemp;
	int nRet = 0;
	int nTemp;

	fd_set	fdRead;
	FD_ZERO(&fdRead);
	FD_SET(m_hSocket, &fdRead);
	do{
		if(0 == select(0, &fdRead, 0, 0, tv))
		{
//			m_dwError = TCP_RECV_TIMEOUT;
			return FALSE;
		}
		if(m_hSocket == INVALID_SOCKET)
		{
//			m_dwError = TCP_RECV_ERROR;
//			TRACE("Socket = NULL closed\n");
			return FALSE;
		}
		nTemp = recv(m_hSocket, (LPSTR)lpBuf+nRet, nBufLen-nRet, nFlags);
//		strTemp.Format("%d\n", nTemp);
//		TRACE(strTemp);
		if(0 == nTemp)
		{
//			TRACE("Socket closed NORMAL\n");
			return FALSE;
		}
		if(SOCKET_ERROR == nTemp)
		{
//			m_dwError = TCP_RECV_ERROR;
//			TRACE("Socket closed ABNORMAL\n");
//			DWORD dwErr = GetLastError();
//			TRACE("Error Code = %d\n", dwErr);
			return FALSE;
		}
	}while(nRet += nTemp, nRet < nBufLen);

	return TRUE;
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
VOID CBlockSocket::Close()
{
	if(INVALID_SOCKET != m_hSocket)
	{
		closesocket(m_hSocket);
		m_hSocket = INVALID_SOCKET;
	}
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
VOID CBlockSocket::SetTimeOut(int s, int ms)
{
	if(tv)
	{
		delete tv;
		tv = NULL;
	}

	else{
		if(s == -1)
		{
			return;
		}
		else{
			tv			= new TIMEVAL;
			tv->tv_sec	= s;
			tv->tv_usec	= ms;
		}
	}
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::IsValid()
{
	if(m_hSocket) return TRUE;
	return FALSE;
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::GetPeerName(CString& rName, UINT& nPort)
{
	SOCKADDR_IN sockAddr;
	memset(&sockAddr, 0, sizeof(sockAddr));

	int nSockAddrLen = sizeof(sockAddr);
	BOOL bResult = GetPeerName((SOCKADDR*)&sockAddr, &nSockAddrLen);

	if (bResult)
	{
		nPort = ntohs(sockAddr.sin_port);
		rName = inet_ntoa(sockAddr.sin_addr);
	}
	return bResult;
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::GetPeerName(SOCKADDR* lpSockAddr, int* lpSockAddrLen)
{
	return (SOCKET_ERROR != getpeername(m_hSocket, lpSockAddr, lpSockAddrLen)); 
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
BOOL CBlockSocket::InitSocket()
{
	WORD wVersionRequested;
	WSADATA wsaData;
	int err;
 
	wVersionRequested = MAKEWORD( 2, 2 );
 
	err = WSAStartup( wVersionRequested, &wsaData );
	if ( err != 0 ) {
		return FALSE;
	}
 
	if ( LOBYTE( wsaData.wVersion ) != 2 ||
			HIBYTE( wsaData.wVersion ) != 2 ) {
		WSACleanup( );
		return FALSE; 
	}
 
	return TRUE;
}
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------
//-----------------------------------------------------------
//
//
//
//-----------------------------------------------------------