Socket封装9

struct CommandHeader
{
    char CommandTag[4];     // 4
    WORD CommandVersion;    // 2
    WORD CommandID;         // 2
    DWORD RequestID;        // 4
    DWORD SendTime;         // 4
    DWORD RequestIP;        // 4
    DWORD DataLen;          // 4

    CommandHeader()
    {
        //memcpy(CommandTag, "SLan", 4);
        memset(CommandTag, 0, 4);
        CommandVersion = 0;
        CommandID = 0;
        RequestID = 0;
        SendTime = 0;
        RequestIP = 0;
        DataLen = 0;
    }

   CommandHeader(constCommandHeader& header)
    {
        *this = header;
    }
    CommandHeader& operator = (const CommandHeader& header)
    {
        memcpy(CommandTag, header.CommandTag, 4);
        CommandVersion = header.CommandVersion;
        CommandID = header.CommandID;
        RequestID = header.RequestID;
        SendTime = header.SendTime;
        RequestIP = header.RequestIP;
        DataLen = header.DataLen;

        return *this;
    }
};

 

#ifndef SOCKETHELPER_H
#define SOCKETHELPER_H


// #include <standard library headers>
#include <string>
#include <vector>
#include <algorithm>

class SocketHelper
{
private:
    SocketHelper();
    virtual ~SocketHelper();

public:
    static std::string GetHostIPAddress();

    static DWORD TransferIp(const std::string& ip);
    static DWORD TransferIp(const std::wstring& ip);
    static std::string TransferIp(DWORD ip);
    static std::wstring IpToWstring(DWORD ip);

    static DWORD NetToHostL(char* n);
    static WORD NetToHostS(char* n);


    static void HostToNet(char* n, DWORD h);
    static void HostToNet(char* n, WORD h);
    static std::vector<char> HostToNet(DWORD h);
    static std::vector<char> HostToNet(WORD h);

    static void SafeCopyUtf8(char* d, const std::string& str, int size);
    static void SafeCopyUtf8(char* d, const std::wstring& str, int size);
    static std::vector<char> SafeCopyUtf8(const std::string& str, int size);
    static std::vector<char> SafeCopyUtf8(const std::wstring& str, int size);

    static std::wstring SafeTransUtf8(const char* d, int size);
   
    template <typename T> static bool Equal(const T& t1, const T& t2) { return (t1 == t2); }
    template <typename T> static bool Equal(const std::list<T>& t1, const std::list<T>& t2)
    {
        if (t1.size() != t2.size())
        {
            return false;
        }
        for (std::list<T>::const_iterator it = t1.begin(); it != t1.end(); ++it)
        {
            const T& t = *it;
            if (std::find(t2.begin(), t2.end(), t) == t2.end())
            {
                return false;
            }
        }
        return true;
    }

};

 

//

// #include "customer headers"
#include "sock/Socket.h"
#include "util/encode.h"
#include "util/algo.h"
#include "SocketHelper.h"



std::string SocketHelper::GetHostIPAddress()
{
    struct hostent *theHost = NULL;
    struct in_addr in;
    char pMyName[80];
    char *ptr = NULL;
    WORD wVersionRequested;
    WSADATA wsaData;
    int nErr;
    wVersionRequested = MAKEWORD(2, 0);
    nErr = WSAStartup( wVersionRequested, &wsaData);
    if (nErr != 0)
    {
        return "";
    }
    if (LOBYTE( wsaData.wVersion ) != 2 ||
        HIBYTE( wsaData.wVersion ) != 0)
    {
        WSACleanup();
        return "";
    }
    if (gethostname(pMyName, 80) == SOCKET_ERROR)
    {
        WSACleanup();
        return "";
    }
    theHost = gethostbyname(pMyName);
    if (!theHost)
    {
        WSACleanup();
        return "";
    }
    memset((void *)&in, 0, sizeof(in));
    in.s_addr = *((DWORD *)theHost->h_addr_list[0]);
    ptr = inet_ntoa(in);
    if (!ptr)
    {
        WSACleanup();
        return "";
    }
    WSACleanup();
    return std::string(ptr);   
}


DWORD SocketHelper::TransferIp(const std::string& ip)
{
    return inet_addr(ip.c_str());
}


DWORD SocketHelper::TransferIp(const std::wstring& ip)
{
    return TransferIp(util::encode::ConvertToAscii(ip));
}


std::string SocketHelper::TransferIp(DWORD ip)
{
    in_addr addr;
    addr.s_addr = ip;
    return inet_ntoa(addr);
}


std::wstring SocketHelper::IpToWstring(DWORD ip)
{
    return util::encode::ConvertToWstring(SocketHelper::TransferIp(ip));
}


DWORD SocketHelper::NetToHostL(char* n)
{
    assert(n != NULL);

    DWORD* data = (DWORD*)n;
    return ntohl(*data);
}


WORD SocketHelper::NetToHostS(char* n)
{
    assert(n != NULL);

    unsigned short* data = (unsigned short*)n;
    return ntohs(*data);
}


void SocketHelper::HostToNet(char* n, DWORD h)
{
    assert(n != NULL);

    DWORD d = htonl(h);
    memcpy(n, &d, 4);
}


void SocketHelper::HostToNet(char* n, WORD h)
{
    assert(n != NULL);

    WORD d = htons(h);
    memcpy(n, &d, 2);
}


std::vector<char> SocketHelper::HostToNet(DWORD h)
{
    DWORD d = htonl(h);

    std::vector<char> n(4, 0);
    memcpy(&n[0], &d, 4);

    return n;
}


std::vector<char> SocketHelper::HostToNet(WORD h)
{
    WORD d = htons(h);

    std::vector<char> n(2, 0);
    memcpy(&n[0], &d, 2);

    return n;
}


std::vector<char> SocketHelper::HostToNet(const CommandHeader& header)
{
    std::vector<char> data(HEADER_LENGTH, '/0');

    memcpy(&data[0], &header.CommandTag, 4);
    HostToNet(&data[4], header.CommandVersion);
    HostToNet(&data[6], header.CommandID);
    HostToNet(&data[8], header.RequestID);
    HostToNet(&data[12], header.SendTime);
    HostToNet(&data[16], header.RequestIP);
    HostToNet(&data[20], header.DataLen);

    return data;
}

 

CommandHeader SocketHelper::NetToHostHeader(char* data)
{
    assert(data != NULL);

    CommandHeader header;

    memcpy(&header.CommandTag, &data[0], 4);
    header.CommandVersion = NetToHostS(&data[4]);
    header.CommandID = NetToHostS(&data[6]);
    header.RequestID = NetToHostL(&data[8]);
    header.SendTime = NetToHostL(&data[12]);
    header.RequestIP = NetToHostL(&data[16]);
    header.DataLen = NetToHostL(&data[20]);

    return header;
}

 

void SocketHelper::SafeCopyUtf8(char* d, const std::string& str, int size)
{
    assert(d != NULL);

    size_t si = static_cast<size_t>(size);
    size_t s = (str.size() > si) ? si : str.size();

    memset(d, 0, size);
    memcpy(d, str.c_str(), s);
}


void SocketHelper::SafeCopyUtf8(char* d, const std::wstring& str, int size)
{
    assert(d != NULL);

    std::string utf8 = util::encode::ConvertToUtf8(str);
    SafeCopyUtf8(d, utf8, size);
}


std::vector<char> SocketHelper::SafeCopyUtf8(const std::string& str, int size)
{
    std::vector<char> ret(size, '/0');
    SafeCopyUtf8(&ret[0], str, size);

    return ret;
}


std::vector<char> SocketHelper::SafeCopyUtf8(const std::wstring& str, int size)
{
    std::string utf8 = util::encode::ConvertToUtf8(str);
    return SafeCopyUtf8(utf8, size);
}


std::wstring SocketHelper::SafeTransUtf8(const char* d, int size)
{
    assert(d != NULL);

    char* data = new char[size + 1];
    memset(data, 0, size + 1);
    memcpy(data, d, size);
   
    std::wstring strRet = util::encode::ConvertUtf8ToWstring(data);
    delete []data;
    data = NULL;

    return strRet;
}