一些源码

ContractedBlock.gif ExpandedBlockStart.gif Code

//
这些事情属于那低回报的80%的时间里面的事情。那么我们应该尽可能的减少花费在这些事情上的时间,这才是我们应该从80/20定律中得出的结论。

  1. #include   
  2. #include   
  3. #include   
  4. #include   
  5. #include   
  6. #include   
  7. #include   
  8. #include   
  9. #pragma comment(lib, "ws2_32.lib")  
  10. using namespace std;  
  11. #define LOC_PORT 5678  
  12. #define LOC_ADDR "127.0.0.1"  
  13. class CSocketObject  
  14. {  
  15. public:  
  16.     CSocketObject(){WSAStartup(MAKEWORD(2,2), &m_wsaData);}  
  17.     virtual ~CSocketObject(){WSACleanup();}  
  18. public:  
  19.     virtual void Run() = 0;  
  20. protected:  
  21.     WSADATA m_wsaData;  
  22. };  
  23. class CTcpServer : public CSocketObject  
  24. {  
  25. public:  
  26.     virtual void Run();  
  27. private:  
  28.     typedef struct  
  29.     {  
  30.         WSAEVENT event;  
  31.         SOCKET sock;  
  32.     }EVENT_T;  
  33.     list m_listClient;  
  34.     static WSAEVENT& DoGetEvent(EVENT_T& ev){return ev.event;}  
  35. };  
  36. void CTcpServer::Run()  
  37. {  
  38.     SOCKET tSock = socket(AF_INET, SOCK_STREAM, 0);  
  39.     char cBuf[1024];  
  40.     SOCKADDR_IN tAddr, tComeinAddr;  
  41.     tAddr.sin_family = AF_INET;  
  42.     tAddr.sin_port = htons(LOC_PORT);  
  43.     tAddr.sin_addr.s_addr = inet_addr(LOC_ADDR);  
  44.     _ASSERT(bind(tSock,(SOCKADDR*)&tAddr, sizeof(tAddr)) == 0);  
  45.     WSAEVENT hWSAEvent = WSACreateEvent();  
  46.     WSAEventSelect(tSock, hWSAEvent, FD_ACCEPT);  
  47.     _ASSERT(listen(tSock, 5) == 0);  
  48.     EVENT_T ev = {hWSAEvent, tSock};  
  49.     m_listClient.push_back(ev);  
  50.     WSAEVENT events[64];  
  51.     for (;;)  
  52.     {  
  53.         transform(m_listClient.begin(), m_listClient.end(), events, DoGetEvent);  
  54.         int dwIndex = WSAWaitForMultipleEvents(m_listClient.size(), events, false, WSA_INFINITE, false);  
  55.         list::iterator iter = m_listClient.begin();  
  56.         int iPos = 0;  
  57.         while (iPos++ != dwIndex - WSA_WAIT_EVENT_0)++iter;  
  58.         WSANETWORKEVENTS tNetEvents;  
  59.         WSAEnumNetworkEvents(iter->sock, iter->event, &tNetEvents);  
  60.         if (FD_ACCEPT & tNetEvents.lNetworkEvents)  
  61.         {  
  62.             if (0 != tNetEvents.iErrorCode[FD_ACCEPT_BIT])  
  63.             {  
  64.                 std::cout<<"accept error occured\n";  
  65.                 continue;  
  66.             }  
  67.             else  
  68.             {     
  69.                 int dwAddrLen = sizeof(tComeinAddr);  
  70.                 SOCKET tSockIn = accept(tSock, (sockaddr*)&tComeinAddr, &dwAddrLen);  
  71.                 ev.event = WSACreateEvent();  
  72.                 WSAEventSelect(tSockIn, ev.event, FD_READ | FD_CLOSE);  
  73.                 ev.sock = tSockIn;  
  74.                 m_listClient.push_back(ev);  
  75.                 cout << "new come in..." << inet_ntoa(tComeinAddr.sin_addr) << "\n";  
  76.                 send(tSockIn, "You are welcome", strlen("You are welcome"), 0);  
  77.             }  
  78.         }  
  79.         else if (FD_READ & tNetEvents.lNetworkEvents)  
  80.         {  
  81.             if (0 != tNetEvents.iErrorCode[FD_READ_BIT])  
  82.             {  
  83.                 std::cout<<"read error occured\n";  
  84.                 continue;  
  85.             }  
  86.             else  
  87.             {  
  88.                 int dwRet = recv(iter->sock, cBuf, 1024, 0);  
  89.                 if (SOCKET_ERROR == dwRet)  
  90.                 {  
  91.                 }  
  92.                 else  
  93.                 {  
  94.                     cout << "client...data: ";  
  95.                     for (int n = 0; n != dwRet; ++n)  
  96.                     {  
  97.                          cout << "0x" << hex << (int)cBuf[n] << " ";  
  98.                     }  
  99.                     cout << endl;  
  100.                 }  
  101.             }  
  102.         }  
  103.         else if (FD_CLOSE & tNetEvents.lNetworkEvents)  
  104.         {  
  105.             int dwNameLen = sizeof(tComeinAddr);  
  106.             getpeername(iter->sock, (sockaddr*)&tComeinAddr, &dwNameLen);  
  107.             closesocket(iter->sock);  
  108.             WSACloseEvent(iter->event);  
  109.             m_listClient.erase(iter);  
  110.             cout << "client..." << inet_ntoa(tComeinAddr.sin_addr) << " quit\n";  
  111.         }  
  112.     }  
  113. }  
  114. int _tmain(int argc, TCHAR *argv[])  
  115. {  
  116.     CSocketObject *poSockServer = new CTcpServer;  
  117.     poSockServer->Run();  
  118.     delete poSockServer;  
  119.     return 0;  
  120. }  



// Module Name: eventselect.cpp
//
// Description:
//
//    This sample illustrates how to develop a simple echo server Winsock
//    application using the WSAEventSelect() I/O model. This sample is
//    implemented as a console-style application and simply prints
//    messages when connections are established and removed from the server.
//    The application listens for TCP connections on port 5150 and accepts them
//    as they arrive. When this application receives data from a client, it
//    simply echos (this is why we call it an echo server) the data back in
//    it's original form until the client closes the connection.
//
// Compile:
//
//    cl -o eventselect eventselect.cpp ws2_32.lib
//
// Command Line Options:
//
//    eventselect.exe 
//
//    Note: There are no command line options for this sample.

#include 
<winsock2.h>
#include 
<windows.h>
#include 
<stdio.h>

#pragma comment(lib,"ws2_32.lib")
#define PORT 5150
#define DATA_BUFSIZE 8192

//SOCKET 信息
typedef struct _SOCKET_INFORMATION {
    CHAR Buffer[DATA_BUFSIZE];
    WSABUF DataBuf;
    SOCKET Socket;
    DWORD BytesSEND;
    DWORD BytesRECV;
} SOCKET_INFORMATION, 
* LPSOCKET_INFORMATION;

BOOL CreateSocketInformation(SOCKET s);
void FreeSocketInformation(DWORD Event);

DWORD EventTotal 
= 0;
WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS];
LPSOCKET_INFORMATION SocketArray[WSA_MAXIMUM_WAIT_EVENTS];

void main(void)
{
    SOCKET Listen;
    SOCKET Accept;
    SOCKADDR_IN InternetAddr;
    DWORD Event;
    WSANETWORKEVENTS NetworkEvents;
    WSADATA wsaData;
    DWORD Ret;
    DWORD Flags;
    DWORD RecvBytes;
    DWORD SendBytes;

    
if ((Ret = WSAStartup(0x0202&wsaData)) != 0)
    {
        printf(
"WSAStartup() failed with error %d\n", Ret);
        
return;
    }

    
if ((Listen = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
    {
        printf(
"socket() failed with error %d\n", WSAGetLastError());
        
return;
    } 

    CreateSocketInformation(Listen);

    
if (WSAEventSelect(Listen, EventArray[EventTotal - 1], FD_ACCEPT|FD_CLOSE) == SOCKET_ERROR)
    {
        printf(
"WSAEventSelect() failed with error %d\n", WSAGetLastError());
        
return;
    }

    InternetAddr.sin_family 
= AF_INET;
    InternetAddr.sin_addr.s_addr 
= htonl(INADDR_ANY);
    InternetAddr.sin_port 
= htons(PORT);

    
if (bind(Listen, (PSOCKADDR) &InternetAddr, sizeof(InternetAddr)) == SOCKET_ERROR)
    {
        printf(
"bind() failed with error %d\n", WSAGetLastError());
        
return;
    }

    
if (listen(Listen, 5))
    {
        printf(
"listen() failed with error %d\n", WSAGetLastError());
        
return;
    }


    
while(TRUE)
    {
        
// Wait for one of the sockets to receive I/O notification and 
        if ((Event = WSAWaitForMultipleEvents(EventTotal, EventArray, FALSE,
            WSA_INFINITE, FALSE)) 
== WSA_WAIT_FAILED)
        {
            printf(
"WSAWaitForMultipleEvents failed with error %d\n", WSAGetLastError());
            
return;
        }


        
if (WSAEnumNetworkEvents(SocketArray[Event - WSA_WAIT_EVENT_0]->Socket, EventArray[Event - 
            WSA_WAIT_EVENT_0], 
&NetworkEvents) == SOCKET_ERROR)
        {
            printf(
"WSAEnumNetworkEvents failed with error %d\n", WSAGetLastError());
            
return;
        }


        
if (NetworkEvents.lNetworkEvents & FD_ACCEPT)
        {
            
if (NetworkEvents.iErrorCode[FD_ACCEPT_BIT] != 0)
            {
                printf(
"FD_ACCEPT failed with error %d\n", NetworkEvents.iErrorCode[FD_ACCEPT_BIT]);
                
break;
            }

            
if ((Accept = accept(SocketArray[Event - WSA_WAIT_EVENT_0]->Socket, NULL, NULL)) == INVALID_SOCKET)
            {        
                printf(
"accept() failed with error %d\n", WSAGetLastError());
                
break;
            }

            
if (EventTotal > WSA_MAXIMUM_WAIT_EVENTS)
            {
                printf(
"Too many connections - closing socket.\n");
                closesocket(Accept);
                
break;
            }

            CreateSocketInformation(Accept);

            
if (WSAEventSelect(Accept, EventArray[EventTotal - 1], FD_READ|FD_WRITE|FD_CLOSE) == SOCKET_ERROR)
            {
                printf(
"WSAEventSelect() failed with error %d\n", WSAGetLastError());
                
return;
            }

            printf(
"Socket %d connected\n", Accept);
        }


        
// Try to read and write data to and from the data buffer if read and write events occur.

        
if (NetworkEvents.lNetworkEvents & FD_READ ||
            NetworkEvents.lNetworkEvents 
& FD_WRITE)
        {
            
if (NetworkEvents.lNetworkEvents & FD_READ &&
                NetworkEvents.iErrorCode[FD_READ_BIT] 
!= 0)
            {
                printf(
"FD_READ failed with error %d\n", NetworkEvents.iErrorCode[FD_READ_BIT]);
                
break;
            }

            
if (NetworkEvents.lNetworkEvents & FD_WRITE && 
                NetworkEvents.iErrorCode[FD_WRITE_BIT] 
!= 0)
            {
                printf(
"FD_WRITE failed with error %d\n", NetworkEvents.iErrorCode[FD_WRITE_BIT]);
                
break;
            }

            LPSOCKET_INFORMATION SocketInfo 
= SocketArray[Event - WSA_WAIT_EVENT_0];

            
// Read data only if the receive buffer is empty.

            
if (SocketInfo->BytesRECV == 0)
            {
                SocketInfo
->DataBuf.buf = SocketInfo->Buffer;
                SocketInfo
->DataBuf.len = DATA_BUFSIZE;

                Flags 
= 0;
                
if (WSARecv(SocketInfo->Socket, &(SocketInfo->DataBuf), 1&RecvBytes,
                    
&Flags, NULL, NULL) == SOCKET_ERROR)
                {
                    
if (WSAGetLastError() != WSAEWOULDBLOCK)
                    {
                        printf(
"WSARecv() failed with error %d\n", WSAGetLastError());
                        FreeSocketInformation(Event 
- WSA_WAIT_EVENT_0);
                        
return;
                    }
                } 
                
else
                {
                    SocketInfo
->BytesRECV = RecvBytes;
                }
            }

            
// Write buffer data if it is available.

            
if (SocketInfo->BytesRECV > SocketInfo->BytesSEND)
            {
                SocketInfo
->DataBuf.buf = SocketInfo->Buffer + SocketInfo->BytesSEND;
                SocketInfo
->DataBuf.len = SocketInfo->BytesRECV - SocketInfo->BytesSEND;

                
if (WSASend(SocketInfo->Socket, &(SocketInfo->DataBuf), 1&SendBytes, 0,
                    NULL, NULL) 
== SOCKET_ERROR)
                {
                    
if (WSAGetLastError() != WSAEWOULDBLOCK)
                    {
                        printf(
"WSASend() failed with error %d\n", WSAGetLastError());
                        FreeSocketInformation(Event 
- WSA_WAIT_EVENT_0);
                        
return;
                    }

                    
// A WSAEWOULDBLOCK error has occured. An FD_WRITE event will be posted
                    
// when more buffer space becomes available
                }
                
else
                {
                    SocketInfo
->BytesSEND += SendBytes;

                    
if (SocketInfo->BytesSEND == SocketInfo->BytesRECV)
                    {
                        SocketInfo
->BytesSEND = 0;
                        SocketInfo
->BytesRECV = 0;
                    }
                }
            }
        }

        
if (NetworkEvents.lNetworkEvents & FD_CLOSE)
        {
            
if (NetworkEvents.iErrorCode[FD_CLOSE_BIT] != 0)
            {
                printf(
"FD_CLOSE failed with error %d\n", NetworkEvents.iErrorCode[FD_CLOSE_BIT]);
                
break;
            }

            printf(
"Closing socket information %d\n", SocketArray[Event - WSA_WAIT_EVENT_0]->Socket);

            FreeSocketInformation(Event 
- WSA_WAIT_EVENT_0);
        }
    }
    
return;
}


BOOL CreateSocketInformation(SOCKET s)
{
    LPSOCKET_INFORMATION SI;

    
if ((EventArray[EventTotal] = WSACreateEvent()) == WSA_INVALID_EVENT)
    {
        printf(
"WSACreateEvent() failed with error %d\n", WSAGetLastError());
        
return FALSE;
    }

    
if ((SI = (LPSOCKET_INFORMATION) GlobalAlloc(GPTR,
        
sizeof(SOCKET_INFORMATION))) == NULL)
    {
        printf(
"GlobalAlloc() failed with error %d\n", GetLastError());
        
return FALSE;
    }

    
// Prepare SocketInfo structure for use.

    SI
->Socket = s;
    SI
->BytesSEND = 0;
    SI
->BytesRECV = 0;

    SocketArray[EventTotal] 
= SI;

    EventTotal
++;

    
return(TRUE);
}


void FreeSocketInformation(DWORD Event)
{
    LPSOCKET_INFORMATION SI 
= SocketArray[Event];
    DWORD i;

    closesocket(SI
->Socket);

    GlobalFree(SI);

    WSACloseEvent(EventArray[Event]);

    
// Squash the socket and event arrays

    
for (i = Event; i < EventTotal; i++)
    {
        EventArray[i] 
= EventArray[i + 1];
        SocketArray[i] 
= SocketArray[i + 1];
    }

    EventTotal
--;
}

转载于:https://www.cnblogs.com/xianqingzh/archive/2009/09/15/1566995.html

你可能感兴趣的:(一些源码)