一个简单的C/S结构的通信类CServerSocket

 ServerSocket.h

#ifndef __SERVERSOCKET_H__
#define __SERVERSOCKET_H__

// #define WIN32_LEAN_AND_MEAN
#include <windows.h>

#include "SocketManage.h"

#pragma warning(disable:4786)
using namespace std;


#define DEFAULT_PORT    6000
#define LISTEN_NUM        20
#define BUFFER_SIZE        32
#define CLIENT_IP        50

/**//// class CServerSocket forward declaration
class CServerSocket;

/**//// SInfo holds the data for thread parameter.
struct    tagSInfo 
...{
    CServerSocket* pThis;
    SOCKET    ClientSocket;
    char    szMessage[BUFFER_SIZE];
    char    szClientIP[CLIENT_IP];
};

class CServerSocket
...{
public:
    CServerSocket();
    virtual    ~CServerSocket();
    /**//// Start Server
    BOOL Start();
    /**//// Stop Server
    void Stop();
    /**//// pure virtual function for future's inheritance.
    virtual void OnMessage(LPSTR lpszIP, LPSTR lpszMessage) = 0;
    /**//// Closing corresponding SOCKET's handle by its IP.
    void CloseSocketByIP(LPCSTR lpszIP);
    /**//// Send a message to client.
    int SendMessageToClient(SOCKET hSocket, LPCSTR lpszMessage);
    int SendMessageToClient(LPCSTR lpszIP, LPCSTR lpszMessage);
    /**//// Send a message to all client.
    void SendMessageToAllClient(LPCSTR lpszMessage);
    /**//// Send a message to all client except for lpszIP
    void SendMessageToAllClientExceptFor(LPCSTR lpszIP, LPCSTR lpszMessage);
    
    /**//// recording SOCKET's status.
    enum State
    ...{
        SOCK_ERR,
        SOCK_SUC
    };

private:
    /**//// Initialize SOCKET environment.
    BOOL Initialization();
    /**//// bind local with lPort
    SOCKET Bind(USHORT lPort = DEFAULT_PORT);
    /**//// accept a client's request and obtain its IP address by lpszIP.
    SOCKET AcceptClient(SOCKET sListen, LPSTR lpszIP);
    /**//// Worker Thraed that processing client's request.
    static UINT __stdcall WorkThread(LPVOID pParam);
    
protected:
    CSocketManage    ClientManage;//! CSocketManage manages SOCKET and its IP address

private:
    char szClientIP[50];
    
    CRITICAL_SECTION cs;//! Critical_Section
};

#endif

 ServerSocket.cpp 

#include "ServerSocket.h"
#include <process.h>
#include <stdio.h>
// #include <WINSOCK2.H>

#pragma comment(lib, "WS2_32")

/**//// Constructor
CServerSocket::CServerSocket()
...{
    /**//// Initialize Critical Section
    InitializeCriticalSection(&cs);
}

/**//// Destructor
CServerSocket::    ~CServerSocket()
...{
    /**//// Delete Critical Section
    DeleteCriticalSection(&cs);
    /**//// Cleanup
    Stop();
}

/**//// Initialize SOCKET environment.
BOOL CServerSocket::Initialization()
...{
    WSADATA wsd;
    /**//// Startup SOCKET library
    if( WSAStartup(MAKEWORD(2, 2), &wsd) != 0)    //! if failed, return FALSE
    ...{
        return FALSE;
    }

    return TRUE;
}

/**//// Startup server
BOOL CServerSocket::Start()
...{
    /**//// Initialize environment.
    if (Initialization() == FALSE)
    ...{
        return FALSE;
    }

    /**//// bind
    SOCKET sockListen;
    if ((sockListen = Bind(DEFAULT_PORT)) == NULL)
    ...{
        return FALSE;
    }

    /**//// listen to client's request
    while (TRUE)
    ...{
        SOCKET sockClient = NULL;
        while(sockClient == NULL)
        ...{
            sockClient = AcceptClient(sockListen, szClientIP);
        }

        /**//// Insert Client's SOCKET and its IP address to ClientManage.
        ClientManage.AddIPToSocket(sockClient, szClientIP);

        /**//// alloc a memory for struct SInfo in heap, release it in WorkThread()
         struct tagSInfo *SOCKINFO = new struct tagSInfo;

        SOCKINFO->pThis = this;
        SOCKINFO->ClientSocket = sockClient;
        strcpy(SOCKINFO->szClientIP, szClientIP);
        memset(SOCKINFO->szMessage, 0, BUFFER_SIZE);

        /**//// Startup a thread , use SOCKINFO as its parameter.
        _beginthreadex(NULL, 0, WorkThread, (LPVOID)SOCKINFO, 0, NULL);
    }

    return TRUE;
}

/**//// Startup a thread , use the SOCKINFO as its parameter.
UINT CServerSocket::WorkThread(LPVOID pParam)
...{
    struct tagSInfo Param;
    /**//// obtaining SOCKINFO
    struct tagSInfo *lpParam = (struct tagSInfo*)pParam;

    Param.ClientSocket = lpParam->ClientSocket;
    Param.pThis = lpParam->pThis;
    strcpy(Param.szClientIP, lpParam->szClientIP);    
    strcpy(Param.szMessage, lpParam->szMessage);

    delete lpParam;    //! release memory allocating in heap.
    
    char recvbuf[BUFFER_SIZE];
    
    State    valState;

    /**//// Receiving message from client and pass it to virtual function OnMessage()
    while (TRUE)
    ...{
        int nLeftToRecv = BUFFER_SIZE;
        *recvbuf = 0;
        
        /**//// do...while loop receives message until received it completely.
        do
        ...{
            char *pLeftBuf = (char *)( recvbuf + (BUFFER_SIZE - nLeftToRecv) );
            
            int nRecvBytes = recv(Param.ClientSocket, pLeftBuf, nLeftToRecv, 0);
            
            if(nRecvBytes == SOCKET_ERROR)
            ...{
                valState = SOCK_ERR;
                break;
            }
            
            nLeftToRecv -= nRecvBytes;
        } while(nLeftToRecv > 0);
        
        /**//// if has no errors in receiving progress, pass message to OnMessage().
        if (valState != SOCK_ERR)
        ...{
            Param.pThis->OnMessage(Param.szClientIP, recvbuf);
        }
    }

    return 1;
}

/**//// bind local with lPort
SOCKET CServerSocket::Bind(USHORT lPort)
...{
    /**//// creating a socket in tcp/ip protocol.
    SOCKET sServer = socket(AF_INET, SOCK_STREAM, 0);
    
    /**//// initializing socket struct.
    struct sockaddr_in servAddr;
    servAddr.sin_family = AF_INET;
    servAddr.sin_port = htons(lPort);
     servAddr.sin_addr.s_addr = htonl(INADDR_ANY);

    /**//// call socket api to bind
    if(bind(sServer, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0)
    ...{
        return NULL;
    }
    
    /**//// set SOCKET sServer to listening mode,and listen LISTEN_NUM at one time.
    if(listen(sServer, LISTEN_NUM) != 0)
    ...{
        return NULL;
    }

    return sServer;
}

/**//// accept a client's request and obtain its IP address by lpszIP.
SOCKET CServerSocket::AcceptClient(SOCKET sListen, LPSTR lpszIP)
...{
    struct sockaddr_in cliAddrTmp;

    int cliAddrSize = sizeof(struct sockaddr_in);
    SOCKET sClient = accept(sListen, (struct sockaddr *)&cliAddrTmp, &cliAddrSize);

    if(sClient == INVALID_SOCKET)
    ...{
        return NULL;
    }

    EnterCriticalSection(&cs);

    sprintf(lpszIP, "%s", inet_ntoa(cliAddrTmp.sin_addr));

    LeaveCriticalSection(&cs);
    
    return sClient;    
}

/**//// Stop Server
void CServerSocket::Stop()
...{
    ClientManage.CloseAllSocket();
    WSACleanup();
}

/**//// close a socket by ip address.
void CServerSocket::CloseSocketByIP(LPCSTR lpszIP)
...{
    if (lpszIP == NULL)
    ...{
        return;
    }

    SOCKET    sSocket = ClientManage.GetSocketByIP(lpszIP);
    
    if (sSocket != NULL)
    ...{
        closesocket(sSocket);
        ClientManage.DeleteIPSocket(lpszIP);
    }
}

/**//// Send a message to client.
int CServerSocket::SendMessageToClient(SOCKET hSocket, LPCSTR lpszMessage)
...{
     int iResult = send(hSocket, lpszMessage, BUFFER_SIZE, 0);

    return iResult;
}

/**//// Send a message to client.
int CServerSocket::SendMessageToClient(LPCSTR lpszIP, LPCSTR lpszMessage)
...{
    int iResult;

    SOCKET hSocket = ClientManage.GetSocketByIP(lpszIP);

    iResult = send(hSocket, lpszMessage, BUFFER_SIZE, 0);

    return iResult;
}

/**//// Send a message to all client.
void CServerSocket::SendMessageToAllClient(LPCSTR lpszMessage)
...{
    std::list<std::string> lstIP;
    std::list<std::string>::iterator iter;

    ClientManage.GetAllClientIP(lstIP);
    for (iter = lstIP.begin(); iter != lstIP.end(); ++iter)
    ...{
        string IP = *iter;
        SOCKET hSocket = ClientManage.GetSocketByIP(IP.c_str());

        send(hSocket, lpszMessage, strlen(lpszMessage), 0);
    }
}

/**//// Send a message to all client except for lpszIP
void CServerSocket::SendMessageToAllClientExceptFor(LPCSTR lpszIP, LPCSTR lpszMessage)
...{
    std::list<std::string> lstIP;
    std::list<std::string>::iterator iter;
    
    ClientManage.GetAllClientIP(lstIP);
    for (iter = lstIP.begin(); iter != lstIP.end(); ++iter)
    ...{
        string IP = *iter;
        /**//// except for lpszIP
        if (strcmp(IP.c_str(), lpszIP) == 0)
        ...{
            continue;
        }

        SOCKET hSocket = ClientManage.GetSocketByIP(IP.c_str());
        
        send(hSocket, lpszMessage, strlen(lpszMessage), 0);
    }    
}

 

 SocketManage.h

#ifndef __SOCKETMANAGE_H__
#define __SOCKETMANAGE_H__

#pragma warning(disable:4786)
#pragma warning(disable:4503)
#include <vector>
#include <list>
#include <map>
#include <string>
#include <algorithm>

class CSocketManage
...{
public:
    /**//// Constructor
    CSocketManage();
    /**//// Destructor
    virtual ~CSocketManage();

    /**//// return all client's IP address by list<>
    void GetAllClientIP(std::list<std::string> & list);

    /**//// return client's number
    LONG GetSocketCount() const;

    /**//// insert a client to CSocketManage
    void AddIPToSocket(SOCKET hSocket, LPCSTR lpszIP);

    /**//// remove a client from CSocketManage
    void DeleteIPSocket(LPCSTR lpszIP);    

    /**//// get socket by ip address
    SOCKET    GetSocketByIP(LPCSTR lpszIP);

    /**//// close all socket connection.
    void CloseAllSocket();
    
private:
    std::map< std::string, std::vector<std::string> > m_mapClientToMessage;

    std::map< std::string,SOCKET > m_mapIPToSocket;
};

#endif //__SOCKETMANAGE_H__

 

 SocketManage.cpp

 

#include "stdafx.h"
#include "SocketManage.h"
#include <assert.h>

CSocketManage::CSocketManage()
...{
    m_mapIPToSocket.clear();
}

CSocketManage:: ~CSocketManage()
...{

}

void CSocketManage::GetAllClientIP(std::list<std::string> & listIP)
...{
    /**//// iterator's statement
    std::map< std::string,SOCKET >::iterator iter;

    for (iter = m_mapIPToSocket.begin();iter != m_mapIPToSocket.end();++iter)
    ...{
        listIP.push_back(iter->first);
    }
}

LONG CSocketManage::GetSocketCount() const
...{
    return m_mapIPToSocket.size();
}

void CSocketManage::AddIPToSocket(SOCKET hSocket, LPCSTR lpszIP)
...{
    m_mapIPToSocket.insert(std::make_pair(lpszIP, hSocket));
    CString str;
    str.Format("%d",m_mapIPToSocket.size());
    AfxMessageBox(str);
}

void CSocketManage::DeleteIPSocket(LPCSTR lpszIP)
...{
    std::map< std::string,SOCKET >::iterator iter;

    for (iter = m_mapIPToSocket.begin();iter != m_mapIPToSocket.end();++iter)
    ...{
        /**//// if found out target IP,then break
        if(strcmp(iter->first.c_str(), lpszIP) == 0)
        ...{
            break;
        }
    }

    /**//// remove it from CSocketManage
    m_mapIPToSocket.erase(iter);
}

SOCKET CSocketManage::GetSocketByIP(LPCSTR lpszIP)
...{
    if (lpszIP == NULL)
    ...{
        return NULL;
    }

    std::map< std::string,SOCKET >::iterator iter;

    for (iter = m_mapIPToSocket.begin();iter != m_mapIPToSocket.end();++iter)
    ...{
        if(strcmp(iter->first.c_str(), lpszIP) == 0)
        ...{
            break;
        }
    }

    return iter->second;
}

/**//// close all client's socket.
void CSocketManage::CloseAllSocket()
...{
    std::map< std::string,SOCKET >::iterator iter;
    
    for (iter = m_mapIPToSocket.begin();iter != m_mapIPToSocket.end();++iter)
    ...{
        closesocket(iter->second);
    }
}