clistensocket.cpp

WINCE下的播放器

// 
// CListenSocket.cpp
// 

#include "stdafx.h"
#include "CListenSocket.h"
//#include "SimplePlayerDlg.h"

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

//////////////////////////////////////////////////////////////////////////////

CListenSocket::CListenSocket()
{
	m_pWorkerSock = NULL;
	m_hSocket     = NULL;
	m_bListening  = FALSE;
//	m_nLimitCount = 1;
	// Initialize thread event
	m_hThrdFinish = ::CreateEvent(NULL,    // pointer to security attributes 
	    						TRUE,      // flag for manual-reset event 
								FALSE,     // flag for initial state 
								NULL);     // pointer to event-object name

}

CListenSocket::~CListenSocket()
{
	// Stop listening first!
	if (m_bListening)
		StopListen();
	// Close the listen socket
	if (m_hSocket)
	{
		closesocket(m_hSocket);
		m_hSocket = NULL;
	}
	// Release the client sockets
/*	SOCKET  pSock;
	POSITION pos = m_ClientList.GetHeadPosition();
	while (pos)
	{
		pSock = (SOCKET) m_ClientList.GetNext(pos);
		closesocket(pSock);
	}
	m_ClientList.RemoveAll();
*/
	// Release the thread event
	if (m_hThrdFinish)
	{
		CloseHandle(m_hThrdFinish);
		m_hThrdFinish = NULL;
	}
}

// Create a socket and place it in listening state
bool CListenSocket::Create(int inPort)
{
	// Already start listening...
	if (m_hSocket)
		return TRUE;

	// Create a TCP socket
	m_hSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);//监听Socket
	if (m_hSocket == INVALID_SOCKET)
	{
		m_hSocket = NULL;
		return FALSE;
	}

	// Settings on socket
/*	BOOL  sopt = TRUE;
	setsockopt(m_hSocket, IPPROTO_TCP, TCP_NODELAY, (char *)&sopt, sizeof(BOOL));
	setsockopt(m_hSocket, SOL_SOCKET, SO_DONTLINGER, (char *)&sopt, sizeof(BOOL));
*/
	// Bind socket and listen
	struct in_addr bindAddr;
	bindAddr.S_un.S_addr = INADDR_ANY;//填入本机IP

	SOCKADDR_IN   saddr;//本机地址信息
	memset(&saddr, 0, sizeof(SOCKADDR_IN));

	saddr.sin_addr   = bindAddr;//IP地址
	saddr.sin_family = AF_INET;//internet地址族
	saddr.sin_port   = htons(inPort);//监听端口号

	if (bind(m_hSocket, (SOCKADDR *)&saddr, sizeof(SOCKADDR_IN)) == SOCKET_ERROR) 
	{
		closesocket(m_hSocket);
		m_hSocket = NULL;
		return FALSE;
	}
	if (listen(m_hSocket, SOMAXCONN) !=0) 
	{
		closesocket(m_hSocket);
		m_hSocket = NULL;
		return FALSE;
	}

	return TRUE;
}

// Start up an independent thread to listen socket-connection blockingly
bool CListenSocket::StartListen(void)
{
	if (m_hSocket)
	{
		if (m_bListening)
			return TRUE;

		// Start a thread
		m_bListening = TRUE;
		ResetEvent(m_hThrdFinish);
		// Make socket blocking
		u_long   nonBlock = FALSE;
		ioctlsocket(m_hSocket, FIONBIO, &nonBlock);
		AfxBeginThread((AFX_THREADPROC)CListenSocket::ListeningThrd, this);
		return TRUE;
	}
	return FALSE;
}

void CListenSocket::StopListen(void)
{
	if (m_hSocket && m_bListening)
	{
		m_bListening = FALSE;
		// Close the socket
		closesocket(m_hSocket);
		m_hSocket    = NULL;	
	}
}

// Accept socket connection
bool CListenSocket::Accept(void)
{
	if (m_hSocket)
	{
		SOCKADDR_IN  saddr;//客户端地址信息
		int len = sizeof(SOCKADDR_IN);

		/*accs: 数据传输Socket; m_hSocket: 监听Socket*/
		SOCKET accs = accept(m_hSocket, (SOCKADDR *)&saddr, &len);
		if (accs == INVALID_SOCKET)
		{
			return FALSE;
		}
/*		
		// Connection limited checking...
		if (m_ClientList.GetCount() >= m_nLimitCount)
		{
			closesocket(accs);
			return TRUE;
		}
*/
		// Settings on the new created socket
		BOOL   sopt = TRUE;
		setsockopt(accs, IPPROTO_TCP, TCP_NODELAY, (char *)&sopt, sizeof(BOOL));
		setsockopt(accs, SOL_SOCKET, SO_DONTLINGER, (char *)&sopt, sizeof(BOOL));

//		m_ClientList.AddTail(accs);

		char pData[sizeof(MSG_HEADER)];
		PMSG_HEADER pMsg = (PMSG_HEADER) pData;
		pMsg->nDataSize  = 0;
		pMsg->nMsgType   = DATA_REQUEST;//指定一个负载类型（要求发送数据）
		send(accs,pData, sizeof(MSG_HEADER),0);
	
		 m_pWorkerSock = new CMediaSocketClient();
         if( !m_pWorkerSock )
         {
         	//RETAILMSG( 1,( TEXT("new m_pWorkerSock failed.\r\n") ) );
		    return FALSE;	
         }
         
         m_pWorkerSock->m_hSocket = accs;
		 m_pWorkerSock->StartReceiving();

		// Send out a message
//		::SendMessage(AfxGetMainWnd()->GetSafeHwnd(), WM_NEW_SOCKET, 0, 0);

		return TRUE;
	}
	return FALSE;
}

// Socket listening thread, blockingly...
UINT CListenSocket::ListeningThrd(void *pParam)
{
	CListenSocket * pListen = (CListenSocket *) pParam;
	if (pListen == NULL)
		return 0;

	while (pListen->m_bListening)
	{
		// If accept failure, exit
		if (!pListen->Accept())
			break;
	}

	SetEvent(pListen->m_hThrdFinish);
	return 1;
}
/*
// Connection limited feature
void CListenSocket::SetLimitConnection(int inMax)
{
	m_nLimitCount = inMax;
}

int CListenSocket::GetLimitConnection(void)
{
	return m_nLimitCount;
}
*/