学习编程最好的方式是写代码实践。

学习样例

网络编程常用的函数：

• send(); recv();
• socket(); bind(); listen(); accept(); connect();
• getsockopt(); setsockopt();
• closesocket()和close()，Windows上有些不同
• getaddrinfo(); freeaddrinfo();
• getsockname(); inet_ntop(); inet_pton();

例子在windows vs和mac g++上测试过。
mac上编译命令：g++ --std=c++11 main.cpp。

#include<algorithm>
#include<iomanip>
#include<cstdio>
#include<string>
#include<vector>
#include<stdint.h>
#include<assert.h>
#include <fcntl.h>
#ifdef WIN32
#include <ws2tcpip.h>
#include <mstcpip.h>
//#include <winsock.h>
#include <winsock2.h>
#pragma comment(lib,"ws2_32.lib") // 不然链接出错
#include <windows.h>
#else
#include <sys/socket.h>
#include <netinet/tcp.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <unistd.h>
#endif

// 输出log
namespace {
    class  LogAddEnd
    {
    public:
        void operator=(std::ostream& other)
        {
            other << std::endl;
        }
    };
#define LOG LogAddEnd() = std::cout << __LINE__ << " " << "["<<__FUNCTION__<<"] "
#define LOG_NEW_LINE std::cout << std::endl
}

static int LastErrorNo()
{
#if WIN32
    return WSAGetLastError();
#else
    return errno;
#endif
}

#if WIN32
static std::string LastErrorString()
{
    LPSTR pszError = NULL;

    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL, WSAGetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_ENGLISH_US), (LPSTR)&pszError, 0, NULL);

    std::string&& szErrorString = std::string(pszError);

    LocalFree(pszError);

    return szErrorString;
}

#else
static std::string LastErrorString()
{
    return std::string(strerror(LastErrorNo()));
}
#endif

#define LOG_NET_ERR_INFO LOG << "net_errno:" << LastErrorNo() << " msg:" << LastErrorString()

namespace NetUtils {

    void SleepSomeSeconds(int seconds)
    {
#ifdef WIN32
        Sleep(seconds * 1000);
#else
        sleep(seconds);
#endif // WIN32
    }

    // 在mac上没有效果哎，win32下有效
    std::string GetLocalIPAddress()
    {
        char ip[128] = { 0 };
        addrinfo hints;
        addrinfo *answer = nullptr,*curr = nullptr;
        
        memset(&hints, 0, sizeof(addrinfo));
        hints.ai_family = AF_INET; /* Allow IPv4 */
        hints.ai_protocol = 0; /* Any protocol */
        hints.ai_socktype = SOCK_STREAM;

        // mac上第二个参数传nullptr，报错。
        int ret = getaddrinfo("", "80", &hints, &answer);
        if (ret == 0)
        {
            for (curr = answer; curr != NULL; curr = curr->ai_next)
            {
                if (curr->ai_family == AF_INET)
                {
                    sockaddr_in *addr = reinterpret_cast<sockaddr_in *>(curr->ai_addr);
                    inet_ntop(curr->ai_family, &addr->sin_addr, ip, sizeof(ip));
                    if (strcmp(ip, "127.0.0.1") == 0)
                    {
                        continue;
                    }
                }
                else if (curr->ai_family == AF_INET6)
                {
                    sockaddr_in6 *addr = reinterpret_cast<sockaddr_in6 *>(curr->ai_addr);
                    inet_ntop(curr->ai_family, &addr->sin6_addr, ip, sizeof(ip));
                    if (strcmp(ip, "::1") == 0)
                    {
                        continue;
                    }
                }
                else
                {
                    LOG << "check it";
                    continue;
                }
                break;
            }
        }
        freeaddrinfo(answer);
        return ip;
    }

    std::string GetLocalIP(int socket_id)
    {
        sockaddr_storage local_addr;
        socklen_t len = sizeof(local_addr);

        if (getsockname(socket_id, (sockaddr*)&local_addr, &len) != 0)
        {
            LOG_NET_ERR_INFO;
            return "";
        }

        void* ip_ptr = nullptr;
        if (local_addr.ss_family == AF_INET)
        {
            ip_ptr = &((sockaddr_in *)&local_addr)->sin_addr;
        }
        else if (local_addr.ss_family == AF_INET6)
        {
            ip_ptr = &((sockaddr_in6 *)&local_addr)->sin6_addr;
        }
        else
        {
            return "";
        }

        char ip_str[128] = { 0 };
        auto* ptr = inet_ntop(local_addr.ss_family, ip_ptr, ip_str, sizeof(ip_str));
        if (ptr) {
            return ptr;
        }
        else
        {
            LOG_NET_ERR_INFO;
            return "";
        }
    }

    int GetLocalPort(int socket_id)
    {
        sockaddr_storage local_addr;
        socklen_t len;
        len = sizeof(local_addr);
        if (getsockname(socket_id, (sockaddr*)&local_addr, &len) != 0)
        {
            LOG_NET_ERR_INFO;
            return -1;
        }

        if (local_addr.ss_family == AF_INET)
        {
            sockaddr_in *addr4 = (sockaddr_in *)&local_addr;
            return ntohs(addr4->sin_port);
        }
        else if (local_addr.ss_family == AF_INET6)
        {
            sockaddr_in6 *addr6 = (sockaddr_in6 *)&local_addr;
            return  ntohs(addr6->sin6_port);
        }
        else
        {
            return -1;
        }
    }

    std::string GetPeerIP(int socket_id)
    {
        sockaddr_storage local_addr;
        socklen_t len = sizeof(local_addr);

        if (getpeername(socket_id, (sockaddr*)&local_addr, &len) != 0)
        {
            LOG << LastErrorNo() << LastErrorString();
            return "error: getsockname error";
        }

        void* ip_ptr = nullptr;
        if (local_addr.ss_family == AF_INET)
        {
            ip_ptr = &((sockaddr_in *)&local_addr)->sin_addr;
        }
        else if (local_addr.ss_family == AF_INET6)
        {
            ip_ptr = &((sockaddr_in6 *)&local_addr)->sin6_addr;
        }
        else
        {
            return "";
        }

        char ip_str[128] = { 0 };
        auto* ptr = inet_ntop(local_addr.ss_family, ip_ptr, ip_str, sizeof(ip_str));
        if (ptr) {
            return ptr;
        }
        else
        {
            LOG_NET_ERR_INFO;
            return "";
        }
    }

    int GetPeerPort(int socket_id)
    {
        sockaddr_storage local_addr;
        socklen_t len;
        len = sizeof(local_addr);
        if (getpeername(socket_id, (sockaddr*)&local_addr, &len) != 0)
        {
            LOG_NET_ERR_INFO;
            return -1;
        }

        if (local_addr.ss_family == AF_INET)
        {
            sockaddr_in *addr4 = (sockaddr_in *)&local_addr;
            return ntohs(addr4->sin_port);
        }
        else if (local_addr.ss_family == AF_INET6)
        {
            sockaddr_in6 *addr6 = (sockaddr_in6 *)&local_addr;
            return  ntohs(addr6->sin6_port);
        }
        else
        {
            return -1;
        }
    }

    static void CloseSocket(int socket_id)
    {
        if (socket_id != -1)
        {
#if WIN32
            closesocket(socket_id);
#else
            close(socket_id);
#endif
        }
    }

    static void SetKeepAlive(int socket_id, int idle_time, int interval_time)
    {
#if _WIN32
        struct StTcpKeepalive
        {
            uint32_t onoff;
            uint32_t keepalivetime;
            uint32_t keepaliveinterval;
        };
        StTcpKeepalive options;
        options.onoff = 1;
        options.keepalivetime = idle_time * 1000;
        options.keepaliveinterval = interval_time * 1000;
        DWORD cbBytesReturned;
        WSAIoctl(socket_id, SIO_KEEPALIVE_VALS, &options, sizeof(options), NULL, 0, &cbBytesReturned, NULL, NULL);
#else
        int keepAlive = 1;   // 开启keepalive属性. 缺省值: 0(关闭) 
        int keepIdle = idle_time;   // 如果在idle秒内没有任何数据交互,则进行探测. 缺省值:7200(s) 
        int keepInterval = interval_time;   // 探测时发探测包的时间间隔为interval秒. 缺省值:75(s) 
        int keepCount = 2;   // 探测重试的次数. 全部超时则认定连接失效..缺省值:9(次) 
        setsockopt(socket_id, SOL_SOCKET, SO_KEEPALIVE, (void*)&keepAlive, sizeof(keepAlive));
#ifdef __linux__
        setsockopt(socket_id, IPPROTO_TCP, TCP_KEEPIDLE, (void*)&keepIdle, sizeof(keepIdle));
#endif
        setsockopt(socket_id, IPPROTO_TCP, TCP_KEEPINTVL, (void*)&keepInterval, sizeof(keepInterval));
        setsockopt(socket_id, IPPROTO_TCP, TCP_KEEPCNT, (void*)&keepCount, sizeof(keepCount));
#endif
    }

    bool SetNoBlock(int fd)
    {
#ifdef WIN32
        unsigned long flag = 1;
        if (ioctlsocket(fd, FIONBIO, (unsigned long *)&flag) < 0)
        {
            LOG << "ioctlsocket set fail";
            return false;
        }
        return true;
#else
        int flags;
        if ((flags = fcntl(fd, F_GETFL)) == -1)
        {
            LOG << "fcntl get fail";
            return false;
        }

        flags |= O_NONBLOCK; //设置非阻塞标志位
        if (fcntl(fd, F_SETFL, flags) == -1)
        {
            LOG << "fcntl set fail";
            return false;
        }
        return true;
#endif
    }

    bool IsAlive(int socket_id) {
        int type = 0;
        socklen_t typesize = sizeof(type);
        int iCode = getsockopt(socket_id, SOL_SOCKET, SO_ERROR, (char*)&type, &typesize);
        return (iCode == 0);
    }

    // @params sock_type
    // TCP : SOCK_STREAM
    // UDP : SOCK_DGRAM
    int Connect(const std::string hostname_or_ip, uint16_t port, int sock_type)
    {
        addrinfo *answer, hint, *curr;
        int ret;
        memset(&hint, 0, sizeof(hint));
        hint.ai_family = AF_UNSPEC;// 也可以用AF_INET或AF_INET6指定ipv4或ipv6
        hint.ai_socktype = sock_type;

        if ((ret = getaddrinfo(hostname_or_ip.c_str(), std::to_string(port).c_str(), &hint, &answer)) != 0) {
            LOG << "getaddrinfo fail errno:" << LastErrorNo() << " errstr:" << LastErrorString()
                << " extra_info:" << gai_strerror(ret);
            return -1;
        }

        sockaddr_in  sockaddr_ipv4;
        sockaddr_in6 sockaddr_ipv6;

        bool bValid = false;
        bool bIpv6Flag = false;
        for (curr = answer; curr != NULL; curr = curr->ai_next)
        {
            switch (curr->ai_family)
            {
            case AF_INET:
            {
                auto* sockaddr_ipv4_ptr = reinterpret_cast<sockaddr_in *>(curr->ai_addr);
                memset(&sockaddr_ipv4, 0, sizeof(sockaddr_ipv4));
                sockaddr_ipv4.sin_family = curr->ai_family;
                sockaddr_ipv4.sin_addr = sockaddr_ipv4_ptr->sin_addr;
                sockaddr_ipv4.sin_port = htons(port);
                bValid = true;
            }
            break;
            case AF_INET6:
            {
                auto* sockaddr_ipv6_ptr = reinterpret_cast<sockaddr_in6 *>(curr->ai_addr);
                memset(&sockaddr_ipv6, 0, sizeof(sockaddr_ipv6));
                sockaddr_ipv6.sin6_family = curr->ai_family;
                sockaddr_ipv6.sin6_addr = sockaddr_ipv6_ptr->sin6_addr;
                sockaddr_ipv6.sin6_port = htons(port);
                bValid = true;
                bIpv6Flag = true;
            }
            break;
            }
            if (bValid)
            {
                break;
            }
        }
        freeaddrinfo(answer);

        if (!bValid)
        {
            LOG << "getaddrinfo does not get valid sock_addr";
            return -1;
        }

        int addr_af = bIpv6Flag ? AF_INET6 : AF_INET;
        sockaddr * addr_ptr = bIpv6Flag ? (sockaddr *)&sockaddr_ipv6 : (sockaddr *)&sockaddr_ipv4;
        int addr_len = bIpv6Flag ? sizeof(sockaddr_ipv6) : sizeof(sockaddr_ipv4);

        int socket_id = socket(addr_af, sock_type, 0);
        if (socket_id < 0) {
            LOG_NET_ERR_INFO;
            return -1;
        }

        if (connect(socket_id, addr_ptr, addr_len) < 0) {
            LOG_NET_ERR_INFO;
            CloseSocket(socket_id);
            return -1;
        }

        SetNoBlock(socket_id);
        
        // TCP
        if(sock_type == SOCK_STREAM)
        {
            const int on = 1;
            setsockopt(socket_id, IPPROTO_TCP, TCP_NODELAY, (const char*)&on, sizeof(on));
        }

#ifndef WIN32 // 信号会引起崩溃
        {
            const int set = 1;
            setsockopt(socket_id, SOL_SOCKET, SO_NOSIGPIPE, (const void *)&set, sizeof(set));
        }
#endif
        return socket_id;
    }

    int Listen(uint16_t port, int sock_type, std::string _bindAddress = "")
    {
        const int on = 1;
        int ret;
        int socket_id = -1;

        sockaddr_in  sockaddr_ipv4;
        memset(&sockaddr_ipv4, 0, sizeof(sockaddr_ipv4));
        sockaddr_ipv4.sin_family = AF_INET;
        sockaddr_ipv4.sin_addr.s_addr = INADDR_ANY;
        sockaddr_ipv4.sin_port = htons(port);
        // bind address
        if (_bindAddress.length() > 0)
        {
            inet_pton(AF_INET, _bindAddress.c_str(), (void*)&sockaddr_ipv4.sin_addr);
        }

        socket_id = socket(AF_INET, sock_type, 0);
        if (socket_id < 0)
        {
            LOG_NET_ERR_INFO;
            return -1;
        }
        // 重复使用本地址与socket文件进行绑定
        // 如果不设置系统，会保留此连接直到最后一引用才释放，进程结束后系统需要几分钟后才能重新进行绑定
        setsockopt(socket_id, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));
        SetNoBlock(socket_id);
        ret = bind(socket_id, (struct sockaddr*)&sockaddr_ipv4, sizeof(sockaddr_ipv4));
        if (ret != 0)
        {
            LOG_NET_ERR_INFO;
            CloseSocket(socket_id);
            return -1;
        }

        listen(socket_id, 50);

        return socket_id;
    }

    int Accept(int socket_id)
    {
        sockaddr_storage client;
        socklen_t client_len = sizeof(client);

        /* new client */
        int fd = accept(socket_id, (struct sockaddr *)&client, &client_len);
        return fd;
    }

}

// 定义了个简单报文协议，开头两个字节的长度，| len(2) | data |
// 主要用于TCP
class CodeRingBuf {
public:
    CodeRingBuf()
    {
        _head = 0;
        _tail = 0;
    }

    int GetUsedBufLength()
    {
        return _tail - _head;
    }

    int GetFreeBufLength()
    {
        return BUF_REAL_LEN - GetUsedBufLength();
    }
    
    void Clear()
    {
        _head = _tail = 0;
    }

    // 输出缓存相关函数
    bool CheckFreeBufEnough(int len)
    {
        return GetFreeBufLength() >= len;
    }

    inline void _PutInOneChar(uint8_t ch)
    {
        _buf[_tail&BUF_REAL_LEN] = ch;
        ++_tail;
    }

    void PutInOneCode(const char* buf, int len)
    {
        len += 2;// 加上两个长度字节
        assert(GetFreeBufLength() >= len);
        _PutInOneChar((len >> 8) & 0xff);
        _PutInOneChar(len & 0xff);
        len -= 2;
        for (int i = 0; i < len; ++i)
        {
            _PutInOneChar(buf[i]);
        }
    }

    int CopyInfo(char* out_buf, int len) {
        int copy_len = GetUsedBufLength();
        if (len < copy_len) copy_len = len;

        for (int i = 0; i < copy_len; ++i)
        {
            out_buf[i] = _buf[(_head + i)&BUF_REAL_LEN];
        }
        return copy_len;
    }

    void Consume(int len)
    {
        assert(GetUsedBufLength() >= len);
        _head += len;
    }

    void PutIn(const char* buf, int len)
    {
        assert(GetFreeBufLength() >= len);
        for (int i = 0; i < len; ++i)
        {
            _PutInOneChar(buf[i]);
        }
    }

    int GetOutOneCode(char* out_buf, int buf_len)
    {
        int used_buf = GetUsedBufLength();
        if (used_buf < 2)
        {
            return -1;
        }

        int len = _buf[_head&BUF_REAL_LEN] << 8;
        len |= _buf[(_head + 1)&BUF_REAL_LEN];
        if (len < 2 || len > BUF_REAL_LEN)
        {
            LOG << "protocol error len=" << len;
            Clear();
            return -1;
        }

        if (GetUsedBufLength() < len)
        {
            return -1;
        }

        len -= 2;
        if (buf_len < len) {
            assert(!"this situation should not happen");
            Clear();
            return -1;
        }
        _head += 2;
        for (int i = 0; i < len; ++i)
        {
            out_buf[i] = _buf[_head&BUF_REAL_LEN];
            ++_head;
        }
        return len;
    }

private:
    // 代码有优化
    // buf长度一定要是2^n，有效长度是2^n-1.
    // 如果总流量<2^32，_tail就是总流量
    const static int BUF_LEN = 1 << 16;
    const static int BUF_REAL_LEN = BUF_LEN - 1;
    uint8_t _buf[BUF_LEN];
    uint32_t _head;
    uint32_t _tail;
};

class NetConnect {
public:
    virtual ~NetConnect() {};

    virtual int Connect(const std::string hostname_or_ip, uint16_t port) = 0;
    virtual void SendOneCode(const char* msg, int len) = 0;
    virtual int RecvOneCode(char* buf, int len) = 0;

    // 测试用
    virtual void SendMsg(const std::string msg)
    {
        SendOneCode(msg.c_str(), msg.length());
    }
    virtual std::string RecvMsg() {
        char buf[1500] = {0};
        // 一定要读到一组数据才结束
        while (RecvOneCode(buf, sizeof(buf)) < 0);
        return buf;
    }
};

class TCPConnect :public NetConnect {
public:
    TCPConnect() :_socket_id(-1), _is_breaked_by_server(false) {}

    TCPConnect& operator=(int socket_id)
    {
        _socket_id = socket_id;
        _is_breaked_by_server = false;
        return *this;
    }

    void LogInfo(std::string head)
    {
        LOG << head
            << " sock = " << NetUtils::GetLocalIP(_socket_id)
            << ":" << NetUtils::GetLocalPort(_socket_id)
            << " peer = " << NetUtils::GetPeerIP(_socket_id)
            << ":" << NetUtils::GetPeerPort(_socket_id);
    }

    int GetSocketId()
    {
        return _socket_id;
    }

    int Connect(const std::string hostname_or_ip, uint16_t port)
    {
        _send_buf.Clear();
        _recv_buf.Clear();
        _socket_id = NetUtils::Connect(hostname_or_ip, port, SOCK_STREAM);
        return _socket_id;
    }

    void SendOneCode(const char* msg, int len)
    {
        if (_send_buf.CheckFreeBufEnough(len + 2))
        {
            _send_buf.PutInOneCode(msg, len);
        }
        else
        {
            LOG << "buf overflow";
            return;
        }
        SendBuf();
    }

    void SendBuf()
    {
        if (_send_buf.GetUsedBufLength() > 0)
        {
            char buf[1024];
            int send_len,success_len;
            while ((send_len = _send_buf.CopyInfo(buf, sizeof(buf))) > 0)
            {
                success_len = send(_socket_id, buf, send_len, 0);
                if (success_len < 0)
                {
                    // todo(check errno)
                    break;
                }
                _send_buf.Consume(success_len);
            }
        }
    }

    int RecvOneCode(char* buf, int len)
    {
        // first read buf
        {
            int code_len = _recv_buf.GetOutOneCode(buf, len);
            if (code_len >= 0) {
                return code_len;
            }
        }

        for (;;)
        {
            char buf[1024];
            int recv_len;
            recv_len = recv(_socket_id, buf, len, 0);
            if (recv_len > 0)
            {
                if (_recv_buf.CheckFreeBufEnough(recv_len))
                {
                    _recv_buf.PutIn(buf, recv_len);
                }
                else
                {
                    LOG << "buf overflow";
                    // todo(reset connect)
                    break;
                }
                
            }
            else if (recv_len == 0)
            {
                // TCP recv()==0, connect is breaked
                break;
            }
            else if (recv_len < 0)
            {
                // todo(check errno)
                break;
            }
        }

        // last read buf
        {
            int code_len = _recv_buf.GetOutOneCode(buf, len);
            if (code_len >= 0) {
                return code_len;
            }
        }

        // get one code fail
        return -1;
    }

private:
    int _socket_id;
    bool _is_breaked_by_server;
    CodeRingBuf _send_buf;
    CodeRingBuf _recv_buf;
};

class UDPConnect :public NetConnect {
public:
    UDPConnect():_socket_id(-1) {}

    UDPConnect& operator=(int socket_id)
    {
        _socket_id = socket_id;
        return *this;
    }
    UDPConnect(int socket_id) : _socket_id(socket_id) {}

    int GetSocketId()
    {
        return _socket_id;
    }

    void LogInfo(std::string head)
    {
        LOG << head
            << " sock = " << NetUtils::GetLocalIP(_socket_id)
            << ":" << NetUtils::GetLocalPort(_socket_id);
    }

    int Connect(const std::string hostname_or_ip, uint16_t port)
    {
        _socket_id = NetUtils::Connect(hostname_or_ip, port, SOCK_DGRAM);
        return _socket_id;
    }

    void SendOneCode(const char* msg, int len)
    {
        // UDP不用分包
        int success_len = send(_socket_id, msg, len, 0);
        if (success_len < 0)
        {
            // todo(check errno)
        }
    }

    int RecvOneCode(char* buf, int len)
    {
        int success_len = recv(_socket_id, buf, len, 0);
        if (success_len < 0)
        {
            // todo(check errno)
            return -1;
        }
        return success_len;
    }
private:
    int _socket_id;
};

class TCPListenConnect {
public:
    TCPListenConnect():_socket_id(-1){}

    void LogInfo()
    {
        LOG << "socket_id:" << _socket_id
            << " listen on " << NetUtils::GetLocalIP(_socket_id)
            << ":" << NetUtils::GetLocalPort(_socket_id);
    }

    int GetSocketId()
    {
        return _socket_id;
    }

    int Listen(uint16_t port, std::string bind_address = "")
    {
        _socket_id = NetUtils::Listen(port, SOCK_STREAM, bind_address);
        return _socket_id;
    }

    int Accept()
    {
        return NetUtils::Accept(_socket_id);
    }
private:
    int _socket_id;
};

class UDPListenConnect {
public:
    UDPListenConnect():_socket_id(-1){}

    void LogInfo()
    {
        LOG << "socket_id:" << _socket_id
            << " listen on " << NetUtils::GetLocalIP(_socket_id)
            << ":" << NetUtils::GetLocalPort(_socket_id);
    }

    int GetSocketId()
    {
        return _socket_id;
    }

    int Listen(uint16_t port, std::string bind_address = "")
    {
        _socket_id = NetUtils::Listen(port, SOCK_DGRAM, bind_address);
        return _socket_id;
    }

    // 测试函数，反射多少包才结束，
    void ReflectALL(int num)
    {
        sockaddr_storage client;
        socklen_t client_len = sizeof(client);
        char buf[1024];
        int recv_len;
        for (;;)
        {
            recv_len = recvfrom(_socket_id, buf, sizeof(buf), 0, (sockaddr*)&client, &client_len);
            if (recv_len >= 0)
            {
                sendto(_socket_id, buf, recv_len, 0, (sockaddr*)&client, client_len);
                --num;
            }
            else
            {
                // todo(check errno)
                if (num <= 0)
                    break;
            }
        }
    }

private:
    int _socket_id;
};

int main() {
#ifdef WIN32
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
        LOG << LastErrorNo() << LastErrorString();
        return 0;
    };
#endif

    std::string local_ip = "127.0.0.1";
#ifdef WIN32
    LOG << "local ip = " << NetUtils::GetLocalIPAddress();
#endif
    
    LOG_NEW_LINE;
    LOG << "TCP no block test start";
    {
        TCPListenConnect listen_connect;
        listen_connect.Listen(8080);
        listen_connect.LogInfo();
        TCPConnect client_connect;
        client_connect.Connect(local_ip, 8080);
        int id;
        TCPConnect server_connect;
        for (;;)
        {
            id = listen_connect.Accept();
            if (id > 0)
            {
                server_connect = id;
                break;
            }
        }
        client_connect.LogInfo("client");
        server_connect.LogInfo("server");

        client_connect.SendMsg("hello");
        LOG << "server recv: " << server_connect.RecvMsg();
        server_connect.SendMsg("hi");
        LOG << "client recv: " << client_connect.RecvMsg();
    }

    LOG_NEW_LINE;
    LOG << "UDP no block test start";
    {
        UDPListenConnect listen_connect;
        listen_connect.Listen(8080);
        listen_connect.LogInfo();
        UDPConnect client_connect;
        client_connect.Connect(local_ip, 8080);

        client_connect.LogInfo("client");

        client_connect.SendMsg("hello");

        listen_connect.ReflectALL(1);
        LOG << "client reflect: " << client_connect.RecvMsg();
    }

#ifdef WIN32
    WSACleanup();
#endif // WIN32
}