简单通讯聊天 群聊功能 Windows下的客户端 Linux下的epoll服务器

1 服务器代码  Linux eclipse C++

//============================================================================
// Name        : epollServer.cpp
// Author      : fangjunmin
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <sys/socket.h>
#include <netinet/in.h>
#include <iostream>
#include <stdio.h>
#include <arpa/inet.h>
#include <errno.h>
#include <sys/epoll.h>
#include <map>
#include <vector>
#include <memory.h>
#include "encode.h"
#include <stddef.h>

using namespace std;

int g_epfd = -1;
int g_listen_fd = -1;
u_short g_listen_port = 8000;


typedef map<int, int> mapClient ;
typedef map<int, int>::iterator itmapClient ;
typedef map<int, int>::const_iterator citmapClient ;

typedef vector<int> vecClient ;
typedef vecClient::iterator itvecClient ;
typedef vecClient::const_iterator citvecClient ;

mapClient g_mapClient;
vecClient g_vecCLient;

void InitListen();
void StartEpoll();
void BoardCast(const char* msg, long int nLen);
void removeFd(int fd);

int main()
{
    cout << "!!!Hello epoll!!!" << endl; // prints !!!Hello epoll!!!

    InitListen();
    StartEpoll();
    return 0;
}

void InitListen()
{
    g_listen_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    if (g_listen_fd == -1)
    {
        return ;
    }

    struct sockaddr_in sin;
    //bzero(&sin, sizeof(struct sockaddr_in));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;
    sin.sin_port = htons(g_listen_port);

    if (bind(g_listen_fd, (struct sockaddr *) &sin, sizeof(struct sockaddr)) != 0)
    {
        printf("bind error: %d
", errno);
        return ;
    }

    if (listen(g_listen_fd, 5) != 0)
    {
        printf("listen error!
");
        return ;
    }
}

void StartEpoll()
{
    int nSize = 5;
    g_epfd = epoll_create(nSize);

    epoll_event ev;
    ev.data.fd=g_listen_fd;
    ev.events = EPOLLIN | EPOLLET | EPOLLOUT;
    int nAddResult = epoll_ctl(g_epfd ,EPOLL_CTL_ADD, g_listen_fd ,&ev); //将新的fd添加到epoll的监听队列中
    if (nAddResult == -1)
    {
        printf ("epoll_ctl error
");
        return ;
    }


    while(true)
    {
        epoll_event events[nSize + 1];
        int nfds = epoll_wait(g_epfd, events, 20,0);
        for(int i=0; i<nfds; ++i)
        {
            printf("event num is:  %d
", nfds);
           if(events[i].data.fd == g_listen_fd) //有新的连接
           {
               sockaddr_in clientaddr;
               unsigned int clilen = sizeof(clientaddr);
               int connfd = accept(g_listen_fd, (sockaddr *)&clientaddr,  &clilen); //accept这个连接
               printf("new connection!  %d
", connfd);

               epoll_event event;
               event.data.fd=connfd;
               event.events = EPOLLIN | EPOLLET | EPOLLOUT | EPOLLHUP;
               epoll_ctl(g_epfd,EPOLL_CTL_ADD,connfd,&event); //将新的fd添加到epoll的监听队列中

               g_vecCLient.push_back(connfd);
           }

           else if( events[i].events & EPOLLIN ) //接收到数据，读socket
           {
               char szBuf[1024] = {0};
               int nRecvNum = recv(events[i].data.fd, szBuf, 1024, 0);   //读


               char szDest[1024] = {0};
               size_t nOutLen = 1024 ;
               GB2312ToUtf8(szBuf, nRecvNum, szDest, nOutLen);
               printf("recv size :%d, concent:%s
", nRecvNum, szBuf);
               printf("after conv  size :%d, concent:%s
", nOutLen ,  szDest);

               if(nRecvNum > 0)
               {
                   BoardCast(szBuf, nRecvNum);
               }
               else if(nRecvNum == -1)
               {
                   perror(NULL);
                   removeFd(events[i].data.fd);
               }

//               ev.data.ptr = md;     //md为自定义类型，添加数据
//               ev.events=EPOLLOUT|EPOLLET;
//               epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);//修改标识符，等待下一个循环时发送数据，异步处理的精髓
           }
           else if(events[i].events & EPOLLOUT) //有数据待发送，写socket
           {
               printf("EPOLLOUT
" );
//               struct myepoll_data* md = (myepoll_data*)events[i].data.ptr;    //取数据
//               sockfd = md->fd;
//               send( sockfd, md->ptr, strlen((char*)md->ptr), 0 );        //发送数据
//               ev.data.fd=sockfd;
//               ev.events=EPOLLIN|EPOLLET;
//               epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev); //修改标识符，等待下一个循环时接收数据
           }
           else if(events[i].events & EPOLLHUP) //socket disconnect
           {
               printf("socket disconnect socketid:%d
", events[i].data.fd);
               removeFd(events[i].data.fd);
           }
           else
           {
               //其他的处理
           }
        }
   }
}

void BoardCast(const char* msg, long int nLen)
{
    for(citvecClient cit = g_vecCLient.begin(); cit != g_vecCLient.end(); cit++)
    {
        int nClientFd = *cit;
        int nSendLen = send(nClientFd, (const void* )msg ,  nLen, 0);
        printf("socket nSendLen:%d
", nSendLen);
    }

}

void removeFd(int fd)
{
    epoll_ctl(g_epfd,EPOLL_CTL_DEL,fd, NULL); //delete socket in epoll
    for(itvecClient it = g_vecCLient.begin(); it != g_vecCLient.end(); it++)
    {
        if(fd == *it)
        {
            g_vecCLient.erase(it);
            return;
        }
    }
}

2 Windows下的客户端代码  Windows、visual studio 、C++

 主线程  读线程  写线程

#include "stdio.h"  
#include <WinSock2.h>
#include "cInitSock.h"
#include <string>
#pragma comment(lib,"WS2_32")


using namespace std;
//struct stMsg
//{
//    int        sCmdID;
//    int        sLen;
//    int        nValue;
//    string    strContent;
//
//    stMsg()
//    {
//        sCmdID = 0;
//        sLen = 0;
//        nValue = 0;
//        strContent = "";
//    }
//};



char g_szIp[64] = "192.168.10.32";
short  g_port = 8000;
SOCKET g_sock;


void ReadHandle();
void WriteHandle();
CRITICAL_SECTION g_cs;

static int s_na = 0;
  

void main()
{
    cInitSock initSock;
    InitializeCriticalSection(&g_cs);
    g_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    sockaddr_in sockAddr;
    memset(&sockAddr,0,sizeof(sockAddr));

    sockAddr.sin_family = AF_INET;
    sockAddr.sin_addr.S_un.S_addr = inet_addr(g_szIp); 
    sockAddr.sin_port = htons((u_short)g_port);
    int nRestle = 0;
    nRestle= connect(g_sock, (sockaddr *)&sockAddr, sizeof(sockAddr) );

    DWORD dErr = GetLastError();
    if (nRestle != 0 )
    {
        printf("连接服务器失败 
");
        return;
    }
    printf("connect success 
"); 

    int nReadThreadID;
    int nWriteThreadID;
    CreateThread(0, 0, (LPTHREAD_START_ROUTINE) ReadHandle, 0, 0, (LPDWORD)&nReadThreadID);
    CreateThread(0, 0, (LPTHREAD_START_ROUTINE) WriteHandle, 0, 0, (LPDWORD)&nWriteThreadID);

    printf("客户端开启成功
");
    while(1)
    {
        ;
    }

}


void ReadHandle()
{
    char buf[1024] = "";
    int buflen = 0;

    while (1)
    {
        memset(buf, 0, 1024);
        buflen = recv(g_sock, buf, 1024, 0);  
        if ( buflen )
        {
            EnterCriticalSection((LPCRITICAL_SECTION)&g_cs);  
            printf("recv msg : %s，msgSiez:%d
", buf, buflen);
            LeaveCriticalSection((LPCRITICAL_SECTION)&g_cs);  
        } 
    } 
}

void WriteHandle()
{
    char buf[1024] = "";
    int buflen = 0;

    while (1)
    {
        gets_s(buf);   
        //printf("the gets buf is:%s:end
", buf);
        buflen = send(g_sock, (const char* )&buf, strlen(buf), 0); 
        if ( buflen > 0)
        {
            EnterCriticalSection((LPCRITICAL_SECTION)&g_cs);  
            printf("send msg : %s，msgSiez:%d
", buf, buflen);
            LeaveCriticalSection((LPCRITICAL_SECTION)&g_cs);  
        }
        if (buflen == -1)
        {
            EnterCriticalSection((LPCRITICAL_SECTION)&g_cs);  
            printf("send msg error: %s
", buf);
            LeaveCriticalSection((LPCRITICAL_SECTION)&g_cs);  
        } 
    } 
}