简单通讯聊天 群聊功能 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 = -;
 int g_listen_fd = -;
 u_short g_listen_port = ;

 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 ;
 }

 void InitListen()
 {
     g_listen_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
     if (g_listen_fd == -)
     {
         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)) != )
     {
         printf("bind error: %d\n", errno);
         return ;
     }

     if (listen(g_listen_fd, ) != )
     {
         printf("listen error!\n");
         return ;
     }
 }

 void StartEpoll()
 {
     int nSize = ;
     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 == -)
     {
         printf ("epoll_ctl error\n");
         return ;
     }

     while(true)
     {
         epoll_event events[nSize + ];
         int nfds = epoll_wait(g_epfd, events, ,);
         for(int i=; i<nfds; ++i)
         {
             printf("event num is:  %d\n", 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\n", 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[] = {};
                int nRecvNum = recv(events[i].data.fd, szBuf, , );   //读

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

                if(nRecvNum > )
                {
                    BoardCast(szBuf, nRecvNum);
                }
                else if(nRecvNum == -)
                {
                    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\n" );
 //               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\n", 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, );
         printf("socket nSendLen:%d\n", 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[] = "192.168.10.32";
 short  g_port = ;
 SOCKET g_sock;

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

 static int s_na = ;

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

     sockaddr_in sockAddr;
     memset(&sockAddr,,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 = ;
     nRestle= connect(g_sock, (sockaddr *)&sockAddr, sizeof(sockAddr) );

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

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

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

 }

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

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

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

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