C++ CClientSocket类代码示例

// Handle all our clients
void CServerSocket::HandleClients( fd_set* fds )
{
    for(UINT i=0;i<ClientList.size( );i++)
	{
        CClientSocket* client = ClientList.at( i );
        if(!client->isActive)
            continue;
		if(FD_ISSET( client->sock, fds ))
		{
            if (client->isserver == true)
            {
               //Log( MSG_INFO,"ISC PACKET");
               if(!client->ISCThread()){
               client->isActive = false;
               DisconnectClient( client );}
            }
            else
			if(!client->ReceiveData( ) )
			{
                client->isActive = false;
                DisconnectClient( client ); 
			}
		}
	}  
}

int main(int argc ,char *argv[])
{
	char *addr = NULL;
	int port;
	if(argc == 1)
	{
		addr = "127.0.0.1";
		port = 8800;
	}else if(argc == 2){
		addr = argv[1];
		port = 8800;
	}else if(argc == 3){
		addr = argv[1];
		port = atoi(argv[2]);
	}else{
		cout<<"error:"<<argv[0]<<" ipaddress portnumber"<<endl;
		return -1;
	}

	CClientSocket *ccs = new CClientSocket(addr, port);

	ccs->startThread();
	
	ccs->joinHost();
	
	delete ccs;

	return 0;
}

int CServerSocket::TcpAccept(CClientSocket& socket)
{
  struct sockaddr_in client;
  socklen_t clientlen = sizeof(client);

  if (m_sock == -1)
  {
    m_error = "socket closed";
    return FAIL;
  }

  int returnv = WaitForSocket(false, "Accept");  //wait for socket to become readable
  if (returnv == FAIL || returnv == TIMEOUT)
    return returnv;
  
  int sock = accept(m_sock, reinterpret_cast<struct sockaddr*>(&client), &clientlen);
  if (sock < 0)
  {
    m_error = "accept() " + GetErrno();
    return FAIL;
  }

  if (socket.SetInfo(inet_ntoa(client.sin_addr), ntohs(client.sin_port), sock) != SUCCESS)
  {
    m_error = socket.GetError();
    return FAIL;
  }
  
  return SUCCESS;
}

void CClientSocket::UpdateUserOline(CString strUserInfo,char from[20])
 {
	 HEADER head;
	 head.type = MSG_UPDATE;
	 head.SendLen = strUserInfo.GetLength()*2;
	 memset(head.from, 0, sizeof(head.from));
	 memset(head.beizhu,0,sizeof(head.beizhu));
	 memset(head.to,0,sizeof(head.to));
	 strcpy(head.from,from);
	 char *pSend = new char[head.SendLen];
	 memset(pSend, 0, head.SendLen);

	 if( !WChar2MByte(strUserInfo.GetBuffer(0), pSend, head.SendLen))
	 {
		 AfxMessageBox(_T("用户全部退出！"));
		 delete pSend;
		 return;
	 }
	POSITION pss = m_List->GetHeadPosition();  //循环对客户端发送消息
	while(pss!=NULL)
	{
		 CClientSocket* pTemp = (CClientSocket*)m_List->GetNext(pss);
		//发送协议头
		pTemp->Send((char*)&head, sizeof(head));
		pTemp->Send(pSend,head.SendLen ); 
	}	
	delete pSend;
 }

DWORD WINAPI CClientSocket::WorkThread(LPVOID lparam)   
{
	CClientSocket *pThis = (CClientSocket *)lparam;
	char	buff[MAX_RECV_BUFFER];
	fd_set fdSocket;
	FD_ZERO(&fdSocket);
	FD_SET(pThis->m_Socket, &fdSocket);
	while (pThis->IsRunning())
	{
		fd_set fdRead = fdSocket;
		int nRet = select(NULL, &fdRead, NULL, NULL, NULL);
		if (nRet == SOCKET_ERROR)
		{
			pThis->Disconnect();
			break;
		}
		if (nRet > 0)
		{
			memset(buff, 0, sizeof(buff));
			int nSize = recv(pThis->m_Socket, buff, sizeof(buff), 0);
			if (nSize <= 0)
			{
				pThis->Disconnect();
				break;
			}
			if (nSize > 0) pThis->OnRead((LPBYTE)buff, nSize);
		}
	}

	return -1;
}

int main()
{
    CClientSocket Client;

    // Create the socket to communicate with the Server
    if (!Client.Create(AF_INET, SOCK_STREAM)) {
        cout << "Failed to create socket\n" ;
        return 0;
    }

    // Connect to the server
    if (SOCKET_ERROR == Client.Connect("127.0.0.1", "3000")) {
        cout << "Failed to connect to server. Was it running?\n";
        return 0;
    }

    cout << "Connected to server.\n";
    cout << "Type data to send, type quit to exit\n";
    // Monitor the client socket for network events, such as data ready to receive
    Client.StartEvents();
    // Send data to the server
    string s;

    for (;;) {  // Infinite loop
        getline(cin, s);

        if (s == "quit") break;

        int i = Client.Send(s.c_str(), (int)s.length(), 0);
        cout << "Sending  " << i << " characters\n";
    }

    return 0;
}

void CClientDlg::OnBnClickedStop()
{
	SetAppState(ST_STOPING);

	for(size_t i = 0; i < m_vtClients.Size(); i++)
	{
		CClientSocket* pSocket = m_vtClients[i];

		if(pSocket->Stop())
			::LogClientStop((DWORD)i + 1);
		else
			ASSERT(FALSE);
	}

	::WaitWithMessageLoop(100L);

	CString strMsg;
	strMsg.Format(	_T(" *** Summary: expect -  %lld, send - %lld, recv - %lld"),
					m_llExpectReceived, m_llTotalSent, m_llTotalReceived);

	::LogMsg(strMsg);

	if(m_llExpectReceived == m_llTotalSent && m_llTotalSent == m_llTotalReceived)
		strMsg.Format(_T(" *** Success: time consuming -  %u millisecond !"), m_dwTimeconsuming);
	else
		strMsg.Format(_T(" *** Fail: manual terminated ? (or data lost)"));

	::LogMsg(strMsg);

	SetAppState(ST_STOPED);
}

UINT WINAPI Loop_FileManager(void* managerHandle)
{
	CClientSocket	socketClient;
	if (!socketClient.Connect(CKernelManager::m_ServerHost, CKernelManager::m_ServerPort))
		return -1;
	CFileManager	manager(&socketClient,(DWORD)managerHandle);
	socketClient.run_event_loop();
	return 0;
}

void CServer::incomingConnection(int handle)
{
    CClientSocket *client = new CClientSocket();
    //client->SetSocket(handle);
    client->SetSocket(handle);

    connect(client,SIGNAL(sendSignal(saveStruct&)),this,SLOT(sendMessage(saveStruct&)));
    connect(client,SIGNAL(deleteSignal(QString&)),this,SLOT(disconnect(QString&)));
}

void CServerSocket::OnAccept(int nErrorCode)
{
	CSingleLock sl(&m_csClientLock, TRUE);

	if( nErrorCode != 0 )
	{
		TRACE("CServerSocket::OnAccept Error : %d\n", ::WSAGetLastError());
	}
	else
	{
		// 빈 클라이언트를 찾는다
		long nClientID = -1;
		long nMaxClient = (long)m_vecnbClientUsed.size();
		for(long i = 0; i < nMaxClient; i++)
		{
			if(m_vecnbClientUsed[i] == FALSE)
			{
				nClientID = i;
				break;
			}
		}
		if(nClientID != -1)
		{
			if(m_vecpClient[nClientID] == NULL)
				m_vecpClient[nClientID] = new CClientSocket;

			CClientSocket *pCurSocket = m_vecpClient[nClientID];
			pCurSocket->InitClient(m_nClientStartID + nClientID, m_hParentWnd, m_bUseReceiveCallback, m_pParentPtr, __CallbackDataReceive);
			m_vecnbClientUsed[nClientID] = TRUE;
			m_vecpClient[nClientID]->m_bConnect = TRUE;
			Accept(*pCurSocket, NULL, NULL);

			TRACE("CServerSocket::OnAccept\n");
			if(m_hParentWnd)
				::PostMessage(m_hParentWnd, UWM_SOCKET_UPDATE_CONNECTION, nClientID, EVT_CONSUCCESS);
			else
				__CallbackDataReceive(m_pParentPtr, nClientID, (BYTE *) - 1, EVT_CONSUCCESS);
		}
		else
		{
			CSocket Socket;
			Accept(Socket, NULL, NULL);
			Socket.ShutDown();
			Socket.Close();
		}
	}

	CAsyncSocket::OnAccept(nErrorCode);
}

/**
 * @brief Acepta conexiones entrantes
 *
 * @return En caso de no poder aceptar ninguna conexión, devolverá false. Si se puede aceptar una conexión entrante,
 * devolverá true.
 *
 * Se intentará entablar una conexión con un cliente remoto por medio de la función SDLNet_TCP_Accept().
 * Si todo va bien, se entablará la conexión.
 */
bool CHostSocket::Accept (CClientSocket& the_client_socket) {
    TCPsocket cs;
    if ((cs = SDLNet_TCP_Accept(m_Socket))) {
        the_client_socket.SetSocket(cs);
        return true;
    }
    else
        return false;
}

void CServerSocket::CloseClientSocket(long nClientID)
{
	if(m_vecnbClientUsed[nClientID] != TRUE)
		return;
	if(m_vecpClient[nClientID] == NULL)
		return;

	CClientSocket *pCurClient = m_vecpClient[nClientID];
	pCurClient->ShutDown();
	pCurClient->Close();

	delete pCurClient;
	pCurClient = nullptr;

	m_vecpClient[nClientID] = NULL;
	m_vecnbClientUsed[nClientID] = FALSE;

	TRACE("CServerSocket::CloseClientSocket\n");
}

int main()
{
//	开机自动启动
//	CBaseSet bs;
//	bs.SetRun();
	

	string	 ServerIp;
	u_short      ServerPort = 9527;
	ServerIp = "183.184.228.68";
	HANDLE	hEvent = NULL;
	CClientSocket socketClient;
	DWORD	dwIOCPEvent;

	while(TRUE)	
	{
		if (!socketClient.Connect(ServerIp,ServerPort))
		{
			Sleep(3*60*1000);
			continue;
		}
		CKernelManager manager(&socketClient,const_cast<char*>(ServerIp.c_str()),ServerPort);
		manager.sendLoginInfo();
		socketClient.setManagerCallBack(&manager);
		Sleep(1000);

		do
		{
			hEvent = OpenEvent(EVENT_ALL_ACCESS, false, NULL);
			dwIOCPEvent = WaitForSingleObject(socketClient.m_hEvent, 100);
			Sleep(500);
		} while(hEvent == NULL && dwIOCPEvent != WAIT_OBJECT_0);

		if (hEvent != NULL)
		{
			socketClient.Disconnect();
			CloseHandle(hEvent);
		}
		
	}
	return 0;
}

bool CHostSocket::Accept(CClientSocket& clientSocket)
{
	TCPsocket clientSock;
	
	if((clientSock = SDLNet_TCP_Accept(_socket)))
	{
		clientSocket.SetSocket(clientSock);
		return true;
	}
	else{return false;}
}

void CClientSocket::MSGTranslate(char* buff,int nlen,char to[20],char from[20],char beizhu[20])
{
	 HEADER head;
	 head.type = MSG_SEND;
	 head.SendLen = nlen;
	 strcpy(head.to,to);
	 strcpy(head.from,from);
	 memset(head.beizhu,0,20);

	 POSITION ps = m_List->GetHeadPosition();  //取得，所有用户的队列
	 CString str(buff);
	 int i =  strcmp(head.to,"群聊");
	 while(ps!=NULL)
	 {
		CClientSocket* pTemp = (CClientSocket*)m_List->GetNext(ps);
		//实现群聊和一对一关键就在于此
		if(pTemp->m_strName==head.to || pTemp->m_strName==head.from || i==0 )
		{
			pTemp->Send(&head,sizeof(HEADER));  //先发送头部
			pTemp->Send(buff, nlen);			//再发送内容
		}
	 }
}