void cNetworkPortController::ReleasePort(const UINT nPort, const int iFlags)
{
CAsyncSocket *pSocket = NULL;
if ( iFlags & UDP )
{
m_mOpenUdpPorts.Lookup( nPort, (CObject*&)pSocket );
if ( pSocket > 0 )
{
pSocket->Close();
delete pSocket;
m_mOpenUdpPorts.RemoveKey( nPort );
}
}
pSocket = NULL;
if ( iFlags & TCP )
{
m_mOpenTcpPorts.Lookup( nPort, (CObject*&)pSocket );
if ( pSocket > 0 )
{
pSocket->Close();
delete pSocket;
m_mOpenTcpPorts.RemoveKey( nPort );
}
}
}
/*................无用...............*/
BOOL CWorkThread::Accept(CListenSocket& ListenSocket)
{
CAsyncSocket asAccept;
if(!ListenSocket.Accept(asAccept))
return FALSE;
CString strOut;
strOut.Format(_T("CPoolThread::Accept() socket :%d Accept!\n"),asAccept.m_hSocket);
TRACE(strOut);
//线程池是否已满
if(!WorkItem::IsPoolFull())
{
if(fpQueueUserWorkItem != NULL)
{
//
fpQueueUserWorkItem(WorkItem::ClientWorkItemThread, (LPVOID)asAccept.Detach(), WT_EXECUTELONGFUNCTION);
}
else
{
//启动WorkItem类的ClientWorkThread线程
AfxBeginThread(WorkItem::ClientWorkThread, (LPVOID)asAccept.Detach());
}
}
else
{
// refuse request,close socket!拒绝客户端请求，关闭socket
asAccept.Close();
}
return TRUE;
}
void CWySock :: OnAccept(int nErrorCode)
{
CWysApp* pApp = (CWysApp*)AfxGetApp();
CWysWnd* pWnd = (CWysWnd*)pApp->m_pMainWnd;
SCREENLINE sl;
INT i;
// make sure socket is listening
if (this->State != LISTENING)
return;
if (nErrorCode == WSAENETDOWN) {
sl.uColor = COLOR_RED;
sl.szText.LoadString(GetLastError());
pWnd->AddListItem(&sl);
return;
}
// find a free socket
if ((i = pApp->GetSocket()) == NOTFOUND) {
// no space to accept this connection. however will accept
// just using simple socket variable and close. Otherwise
// client program will think it is connected.
CAsyncSocket sdTemp;
Accept(sdTemp, NULL,NULL);
sdTemp.Close();
sl.uColor = COLOR_RED;
sl.szText.LoadString(IDS_NOMORESOCKETS);
pWnd->AddListItem(&sl);
return;
}
// accept the incoming connection
SOCKADDR_IN acc_sin;
INT acc_sin_len;
CWySock* pSock = pApp->pSockets[i];
acc_sin_len = sizeof(acc_sin);
this->Accept(*pSock, (LPSOCKADDR)&acc_sin,
(LPINT)&acc_sin_len);
if (pSock->m_hSocket == INVALID_SOCKET) {
sl.uColor = COLOR_RED;
sl.szText.LoadString(IDS_ACCEPTERR);
pWnd->AddListItem(&sl);
return;
}
CString szTemp;
sl.uColor = COLOR_BLUE;
szTemp.LoadString(IDS_ACCEPTCONNECT);
strcpy(pSock->IPAddress, inet_ntoa(acc_sin.sin_addr));
pSock->State = CONNECTED;
sl.szText.Format(szTemp, pSock->IPAddress);
pWnd->AddListItem(&sl);
return;
}
BOOL CServerHandshake::RequestData(CAsyncSocket &socket, UINT nCount, clock_t clkDeadline)
{
while (true)
{
DWORD dwAvailable = 0;
if (!socket.IOCtl(FIONREAD, &dwAvailable))
{
server.OnSocketError(socket.GetLastError());
return FALSE;
}
if (dwAvailable >= nCount) return TRUE;
if (clock() > clkDeadline) return FALSE;
}
}
BOOL CLANConnection::SendMessageTo(CAsyncSocket &socket, const CReference<CLANMessage> &msg,
const BYTE *lpBuf, UINT nSize, SOCKADDR_IN *sockaddr)
{
clock_t deadline = clock() + SEND_TIMEOUT * CLOCKS_PER_SEC;
// Nachricht versenden
while (true)
{
int nCount = socket.SendTo(lpBuf, nSize, (SOCKADDR *)sockaddr, sizeof(*sockaddr));
if (nCount == nSize)
{
if (m_pListener) m_pListener->OnMessageSent(msg, this);
}
else if (nCount == SOCKET_ERROR)
{
int nError = socket.GetLastError();
if (nError == WSAEWOULDBLOCK)
{
Sleep(50);
if (clock() <= deadline) continue;
TRACE("LAN send timeout\n");
}
if (m_pListener)
{
m_pListener->OnSocketError(nError, this);
m_pListener->OnMessageDiscarded(msg, this);
}
// bei Broadcast-Nachricht, deren Versenden aufgrund fehlender Verbindung zu einem lokalen
// Netzwerk fehlschlug (WSAEHOSTUNREACH), den Thread nicht unterbrechen
if (msg->GetReceiverIP() != INADDR_BROADCAST || nError != WSAEHOSTUNREACH)
{
__super::Interrupt();
return FALSE;
}
}
else
{
if (m_pListener) m_pListener->OnMessageDiscarded(msg, this);
}
break;
}
return TRUE;
}
void CListenPlayerSocket::OnAccept(int nErrorCode)
{
// TODO: 在此添加专用代码和/或调用基类
CAsyncSocket * pNewSock = new CPlayerTaskSocket;
if(!Accept(*pNewSock))
{
delete pNewSock;
}
else
{
TRACE("%08x new connection\n", pNewSock);
pNewSock->AsyncSelect(FD_READ);
}
CAsyncSocket::OnAccept(nErrorCode);
}
void DataSocket::OnAccept(int nErrorCode)
{
// Accept the connection using a temp CSocket object.
CAsyncSocket tmpSocket;
Accept(tmpSocket);
SOCKET socket = tmpSocket.Detach();
Close();
Attach(socket);
m_bConnected = TRUE;
if (!m_bInitialized)
SetTransferType(m_nTransferType);
CAsyncSocket::OnAccept(nErrorCode);
}
BOOL CLANConnection::CreateSocket(int &nError)
{
nError = 0;
if (m_hSocket != INVALID_SOCKET) return TRUE;
// Socket erzeugen
CAsyncSocket socket;
if (!socket.Socket(SOCK_DGRAM, 0)) goto error;
/* // mehrfaches Binden an selben Port erlauben
BOOL bReuseAddr = TRUE;
if (!socket.SetSockOpt(SO_REUSEADDR, &bReuseAddr, sizeof(bReuseAddr)))
goto error; */
// Socket binden
if (!socket.Bind(m_nPort)) goto error;
// Broadcast erlauben
BOOL bBroadcast = TRUE;
if (!socket.SetSockOpt(SO_BROADCAST, &bBroadcast, sizeof(bBroadcast)))
goto error;
m_hSocket = socket.Detach();
return TRUE;
error:
nError = socket.GetLastError();
return FALSE;
}
void cNetworkPortController::ReleaseAllPorts(const int iFlags)
{
POSITION Pos;
CAsyncSocket *pSocket = NULL;
unsigned short nPort = 0;
if ( iFlags & UDP )
{
Pos = m_mOpenUdpPorts.GetStartPosition();
while ( Pos )
{
m_mOpenUdpPorts.GetNextAssoc( Pos, nPort, (CObject*&)pSocket );
if ( pSocket > 0 )
{
pSocket->Close();
delete pSocket;
}
}
m_mOpenUdpPorts.RemoveAll();
}
if ( iFlags & TCP )
{
Pos = m_mOpenTcpPorts.GetStartPosition();
while ( Pos )
{
m_mOpenTcpPorts.GetNextAssoc( Pos, nPort, (CObject*&)pSocket );
if ( pSocket > 0 )
{
pSocket->Close();
delete pSocket;
}
}
m_mOpenTcpPorts.RemoveAll();
}
}
bool CCommunication::Connect(CString sServerIP,DWORD nPort)
{
CAsyncSocket asConnect;
if(!AfxSocketInit())
return false;
if(!asConnect.Create(0, SOCK_STREAM, NULL))
return false;
DWORD dwFlag = 0;
ioctlsocket(asConnect.m_hSocket, FIONBIO, &dwFlag);
if(!asConnect.Connect(sServerIP, nPort))
return false;
dwFlag=1;
ioctlsocket(asConnect.m_hSocket, FIONBIO, &dwFlag);
m_WorkSocket = asConnect.Detach();
return true;
}
void PASCAL CAsyncSocket::DoCallBack(WPARAM wParam, LPARAM lParam)
{
if (wParam == 0 && lParam == 0)
return;
// Has the socket be closed?
CAsyncSocket* pSocket = CAsyncSocket::LookupHandle((SOCKET)wParam, TRUE);
// If yes ignore message
if (pSocket != NULL)
return;
pSocket = CAsyncSocket::LookupHandle((SOCKET)wParam, FALSE);
if (pSocket == NULL)
{
// Must be in the middle of an Accept call
pSocket = CAsyncSocket::LookupHandle(INVALID_SOCKET, FALSE);
ASSERT(pSocket != NULL);
pSocket->m_hSocket = (SOCKET)wParam;
CAsyncSocket::DetachHandle(INVALID_SOCKET, FALSE);
CAsyncSocket::AttachHandle(pSocket->m_hSocket, pSocket, FALSE);
}
int nErrorCode = WSAGETSELECTERROR(lParam);
switch (WSAGETSELECTEVENT(lParam))
{
case FD_READ:
pSocket->OnReceive(nErrorCode);
break;
case FD_WRITE:
pSocket->OnSend(nErrorCode);
break;
case FD_OOB:
pSocket->OnOutOfBandData(nErrorCode);
break;
case FD_ACCEPT:
pSocket->OnAccept(nErrorCode);
break;
case FD_CONNECT:
pSocket->OnConnect(nErrorCode);
break;
case FD_CLOSE:
pSocket->OnClose(nErrorCode);
break;
}
}
void CLANConnection::Run()
{
VERIFY(AfxSocketInit());
// Socket erzeugen, falls noch nicht geschehen
int nError;
if (!CreateSocket(nError))
{
if (m_pListener)
{
m_pListener->OnSocketError(nError, this);
m_pListener->OnConnectionLost(this);
}
return;
}
CAsyncSocket socket;
ASSERT(m_hSocket != INVALID_SOCKET);
socket.Attach(m_hSocket);
// IP-Adresse und tatsächlichen Port ermitteln
SOCKADDR_IN sockaddr;
memset(&sockaddr, 0, sizeof(sockaddr));
int nSockAddrLen = sizeof(SOCKADDR_IN);
if (!socket.GetSockName((SOCKADDR *)&sockaddr, &nSockAddrLen)) goto error;
m_nPort = ntohs(sockaddr.sin_port);
m_dwIP = ntohl(sockaddr.sin_addr.S_un.S_addr);
// main thread loop
BYTE buf[LAN_BUFSIZE];
while (!IsInterrupted())
{
// Senden
{
CReference<CLANMessage> message;
if (message = GetNextMessage())
{
// Magic Number
memcpy(buf, "BotE", 4);
// Nachricht serialisieren
CMemFile memFile(&buf[4], LAN_BUFSIZE - 4);
CArchive ar(&memFile, CArchive::store);
message->Serialize(ar);
ar.Close();
UINT nSize = memFile.GetPosition() + 4;
memFile.Detach();
// Empfänger setzen
memset(&sockaddr, 0, sizeof(sockaddr));
sockaddr.sin_family = AF_INET;
sockaddr.sin_addr.S_un.S_addr = htonl(message->GetReceiverIP());
sockaddr.sin_port = htons(message->GetReceiverPort());
// Nachricht versenden, setzt bei Fehler m_bInterrupted
if (!SendMessageTo(socket, message, buf, nSize, &sockaddr)) break;
// Broadcast-Nachricht auch an den lokalen Host senden
if (message->GetReceiverIP() == INADDR_BROADCAST)
{
sockaddr.sin_addr.S_un.S_addr = htonl(INADDR_LOOPBACK);
if (!SendMessageTo(socket, message, buf, nSize, &sockaddr))
break;
}
}
}
// Empfangen
memset(&sockaddr, 0, sizeof(sockaddr));
int nSockAddrLen = sizeof(sockaddr);
int nCount = socket.ReceiveFrom(&buf, LAN_BUFSIZE, (SOCKADDR *)&sockaddr, &nSockAddrLen);
if (nCount > 0)
{
// Magic Number prüfen
if (memcmp(&buf, "BotE", 4) != 0) continue;
// Nachricht deserialisieren
CMemFile memFile(&buf[4], nCount - 4);
CArchive ar(&memFile, CArchive::load);
CReference<CLANMessage> message(new CLANMessage());
message->Serialize(ar);
ar.Close();
memFile.Detach();
// IP und Port des Absenders
DWORD dwIP = ntohl(sockaddr.sin_addr.S_un.S_addr);
UINT nPort = ntohs(sockaddr.sin_port);
message->SetSenderIP(dwIP);
message->SetSenderPort(nPort);
// Ankunft einer Nachricht melden
if (m_pListener) m_pListener->OnMessageReceived(message, this);
}
else if (nCount == 0)
{
// "Verbindung" wurde getrennt
ASSERT(FALSE);
break;
}
else if (nCount == SOCKET_ERROR)
{
int nError = socket.GetLastError();
if (nError != WSAEWOULDBLOCK)
{
if (m_pListener) m_pListener->OnSocketError(nError, this);
// WSAECONNRESET tritt auf, wenn wir zuvor eine Nachricht an eine Adresse gesendet
// haben, an der kein Server läuft; Thread dann nicht abbrechen
if (nError != WSAECONNRESET)
{
__super::Interrupt();
break;
}
}
}
Sleep(50);
}
// verbleibende Nachrichten löschen
{
CReference<CLANMessage> message;
while (message = GetNextMessage())
{
if (m_pListener) m_pListener->OnMessageDiscarded(message, this);
}
}
// socket schließen, Thread beenden
socket.Close();
m_hSocket = INVALID_SOCKET;
if (m_bSendLost && m_pListener) m_pListener->OnConnectionLost(this);
return;
error:
if (m_pListener) m_pListener->OnSocketError(socket.GetLastError(), this);
m_hSocket = INVALID_SOCKET;
if (m_pListener) m_pListener->OnConnectionLost(this);
}
BOOL cNetworkPortController::LockPort(const UINT nPort, const int iFlags)
{
m_strResult = "";
m_bTcpResult = FALSE;
m_bUdpResult = FALSE;
m_strTcpResult = "";
m_strUdpResult = "";
if ( iFlags == NONE )
{
m_strResult = "No socket type specified";
return FALSE;
}
else if ( iFlags > ALL )
{
m_strResult = "Invalid socket type specified";
return FALSE;
}
CAsyncSocket *pSocket = NULL;
CString strSocketType;
CMapWordToOb *pMap = NULL;
BOOL *pbResult = NULL;
CString *pstrResult = NULL;
int iSocketType;
if ( iFlags & UDP )
{
strSocketType = "UDP";
pMap = &m_mOpenUdpPorts;
iSocketType = SOCK_DGRAM;
pbResult = &m_bUdpResult;
pstrResult = &m_strUdpResult;
}
else
{
strSocketType = "TCP";
pMap = &m_mOpenTcpPorts;
iSocketType = SOCK_STREAM;
pbResult = &m_bTcpResult;
pstrResult = &m_strTcpResult;
}
CString strTemp;
while ( iSocketType )
{
pSocket = new CAsyncSocket();
// check for successfull construction socket
if ( !AfxIsValidAddress( pSocket, 1, FALSE ) || pSocket <= 0 )
{
m_strResult = "Error while allocating memory";
return FALSE;
}
// create the socket
if ( !pSocket->Create( nPort, iSocketType, 0 ) )
{
DWORD dwErr = GetLastError();
delete pSocket;
if ( dwErr == WSAEADDRINUSE )
*pstrResult = "In use by another app";
else
*pstrResult = "Not locked";
return FALSE;
}
else
{
// save ptr to new socket for cleanup later
pMap->SetAt( nPort, pSocket );
*pbResult = TRUE;
*pstrResult = "Locked";
}
if ( (iSocketType == SOCK_DGRAM) && (iFlags & TCP) )
{
iSocketType = SOCK_STREAM;
pMap = &m_mOpenTcpPorts;
pbResult = &m_bTcpResult;
pstrResult = &m_strTcpResult;
}
else
{
iSocketType = 0;
pMap = NULL;
pbResult = NULL;
pstrResult = NULL;
}
}
return TRUE;
}
