//============================================================================

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

         }

     }

 }

 #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);

         }

     }

 }