Win32下使用Socket：WinSock

学习socket最好能有两台以上联网的电脑，以及能获得公网IP的网络接入方式。两年前，我主要使用的是一台win2k3和Debain Linux双系统的电脑，例外有台99年的老机器装着win98，而且没有装VC，测试相当的麻烦。现在买了笔记本，使用的是Vista的win32环境（32位），可以直接和老电脑的Linux联网进行测试。另外，网络环境也换成了电信的ADSL，贵了很多，为的就是能有一个公网IP。接下来的教程我会兼顾winsock的代码，这主要是因为winsock本身对socket几乎是兼容的。所以，这里有必要先说明在VC环境中使用socket的一些简单设置，以及与Linux环境下的细微差别。
我的VC环境依然是2008 Express，在写这篇教程的时候，微软已经发布了VC 2010，目前在微软的官方主页，提供了VC 2010的下载，同时保留着VC 2008的下载。
我们在VC中建立一个控制台的空项目：



我们着手构建自己的第一个winsock程序。
首先win32下与Linux下的socket API需要包含不同的头文件。
在Linux下是这些：

#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>

win32下的winsock有多个版本，我所找到的资料中，老的版本是：

#include <winsock.h>

与之对应的需要的链接库为：



这可能可以兼容非常古老的版本中的winsock，比如win98，而微软官方所推荐的是：

#include <winsock2.h>

链接库是：ws2_32.lib，这样就可以使用高版本的winsock。
那么，什么是winsock的版本？这就涉及到winsock的初始化函数WSAStartup：
http://msdn.microsoft.com/en-us/library/ms742213(v=VS.85).aspx
上面是微软的官方说明，我这里构建一个简单的类，希望每次使用的时候引入一个类对象就可以了。

class WinsockAPI{
private:
    WSADATA wsaData;
public:
    WinsockAPI(int low_byte = 2, int high_byte = 2);
    ~WinsockAPI();
    void showVersion() const;
};

WSADATA是记录着winsock信息的结构。

//class WinsockAPI

WinsockAPI::WinsockAPI(int low_byte, int high_byte)
{
    const WORD wVersionRequested = MAKEWORD(low_byte, high_byte);
    int wsa_startup_err = WSAStartup(wVersionRequested, &wsaData);
    if (wsa_startup_err != 0) {
        std::cerr << "WSAStartup() failed." << std::endl;
        throw wsa_startup_err;
    }
}

WinsockAPI::~WinsockAPI()
{
    WSACleanup();
}

void WinsockAPI::showVersion() const
{
    std::cout    << "The version of Winsock.dll is " 
                << int(LOBYTE(wsaData.wVersion)) 
                << "." 
                << int(HIBYTE(wsaData.wVersion)) 
                << "." 
                << std::endl;
    return;
}

首先，宏MAKEWORD()将两个int转换为winsock形式的版本号，我这里默认是是2.2，就只需要MAKEWORD(2, 2)，如果是老版本的，最低应该是1.0。WSAStartup()将winsock的初始化信息写入一个WSADATA结构（我们这里的wsaData），如果成功返回0，失败将返回一个int的错误代码。这个错误代码直接表示了错误信息，微软官方建议不使用winsock的通用异常信息获取函数WSAGetLastError()获取WSAStartup()的错误信息，这可能是因为如果WSAStartup()失败，那么winsock的错误信息不一定能够正确的构建出来的缘故。
最后，winsock结束后用WSACleanup()清理。
因为socket本身的复杂性，异常信息提示非常重要。WSAGetLastError()的官方说明如下：
http://msdn.microsoft.com/en-us/library/ms741580(VS.85).aspx
错误代码所反馈的信息查询在这里：
http://msdn.microsoft.com/en-us/library/ms740668(v=VS.85).aspx
最后，需要注意的问题是，因为socket是构建在UNIX系统下的（BSD socket是当今所有socket的基础），所以socket很好的利用了UNIX体系“一切都是文件”的性质，每个socket本身也就是一个UNIX文件描述符，因此，Linux下的socket是用关闭文件的函数close()关闭的。但是win32下没这个性质，所以winsock是另外一种抽象，但是好在同样用int作为描述符，关闭需要专门为winsock定做的函数closesocket()。
下面重写了TCP Server的代码（类的抽象和构造也重新写了，将在下一章解释），作为winsock使用的演示。

 

//Filename: SockClass.hpp

#ifndef SOCK_CLASS_HPP
#define SOCK_CLASS_HPP

#include <iostream>
#include <winsock2.h>

namespace sockClass
{
void error_info(const char* s);
}

class WinsockAPI{
private:
    WSADATA wsaData;
public:
    WinsockAPI(int low_byte = 2, int high_byte = 2);
    ~WinsockAPI();
    void showVersion() const;
};

class BaseSock{
protected:
    int sockFD;
public:
    BaseSock();
    virtual ~BaseSock() = 0;
    const int& showSockFD() const;
};

class TCPListenSock: public BaseSock{
private:
    sockaddr_in listenSockAddr;
public:
    TCPListenSock(unsigned short listen_port);
    ~TCPListenSock();
    void TCPListen(
        int max_connection_requests = 10) const;
};

class TCPServerSock: public BaseSock{
private:
    sockaddr_in clientSockAddr;
protected:
    char* preBuffer;
    int preBufferSize;
    mutable int preReceivedLength;
public:
    TCPServerSock(
        const TCPListenSock& listen_sock,
        int pre_buffer_size = 32);
    virtual ~TCPServerSock();
    int TCPReceive() const;
    int TCPSend(const char* send_data,
            const int& data_length) const;
};

#endif //SockClass.hpp

//Filename: SockClass.cpp

#include "SockClass.hpp"

//sockClass

namespace sockClass
{
void error_info(const char* s)
{
    std::cerr << s << std::endl;
    throw WSAGetLastError();
}
}

//class WinsockAPI

WinsockAPI::WinsockAPI(int low_byte, int high_byte)
{
    const WORD wVersionRequested = MAKEWORD(low_byte, high_byte);
    int wsa_startup_err = WSAStartup(wVersionRequested, &wsaData);
    if (wsa_startup_err != 0) {
        std::cerr << "WSAStartup() failed." << std::endl;
        throw wsa_startup_err;
    }
}

WinsockAPI::~WinsockAPI()
{
    WSACleanup();
}

void WinsockAPI::showVersion() const
{
    std::cout    << "The version of Winsock.dll is " 
                << int(LOBYTE(wsaData.wVersion)) 
                << "." 
                << int(HIBYTE(wsaData.wVersion)) 
                << "." 
                << std::endl;
    return;
}

//class BaseSock

BaseSock::BaseSock():
sockFD(-1)
{}

BaseSock::~BaseSock()
{}

const int& BaseSock::showSockFD() const
{
    return sockFD;
}

//class TCPListenSock

TCPListenSock::TCPListenSock(unsigned short listen_port)
{
    sockFD = socket(PF_INET,
                    SOCK_STREAM,
                    IPPROTO_TCP);
    if (sockFD < 0) {
        sockClass::error_info("socket() failed.");
    }
    memset(&listenSockAddr, 0, sizeof(listenSockAddr));
    listenSockAddr.sin_family = AF_INET;
    listenSockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    listenSockAddr.sin_port = htons(listen_port);
    if (bind(    sockFD,
                (sockaddr*)&listenSockAddr,
                sizeof(listenSockAddr)) < 0) {
        sockClass::error_info("bind() failed.");
    }
}

TCPListenSock::~TCPListenSock()
{
    closesocket(sockFD);
}

void TCPListenSock::TCPListen(
                        int max_connection_requests) const
{
    if (listen(    sockFD,
                max_connection_requests) < 0) {
        sockClass::error_info("listen() failed.");
    }
}

//class TCPServerSock

TCPServerSock::TCPServerSock(
                const TCPListenSock& listen_sock,
                int pre_buffer_size):
preBufferSize(pre_buffer_size),
preReceivedLength(0)
{
    preBuffer = new char[preBufferSize];

    int clientSockAddrLen = sizeof(clientSockAddr);
    sockFD = accept(    listen_sock.showSockFD(),
                        (sockaddr*)&clientSockAddr,
                        &clientSockAddrLen);
    if (sockFD < 0) {
        sockClass::error_info("accept() failed.");
    }
    std::cout    << "Client (IP: "
                << inet_ntoa(clientSockAddr.sin_addr)
                << ") conneted." << std::endl;
}

TCPServerSock::~TCPServerSock()
{
    delete [] preBuffer;
    closesocket(sockFD);
}

int TCPServerSock::TCPReceive() const
{
    preReceivedLength = recv(    sockFD,
                                preBuffer,
                                preBufferSize,
                                0);
    if (preReceivedLength < 0) {
        sockClass::error_info("recv() failed.");
    } else if (preReceivedLength == 0) {
        std::cout << "Client has been disconnected./n";
        return 0;
    }
    return preReceivedLength;
}

int TCPServerSock::TCPSend(const char* send_data,
                           const int& data_length) const
{
    if (data_length > preBufferSize) {
        throw "Data is too large, resize preBufferSize.";
    }

    int sent_length = send(    sockFD,
                            send_data,
                            data_length,
                            0);
    if (sent_length < 0) {
        sockClass::error_info("send() failed.");
    } else if (sent_length != data_length) {
        sockClass::error_info("sent unexpected number of bytes.");
    }

    return sent_length;
}

//Filename AppSock.hpp

#ifndef APP_SOCK_HPP
#define APP_SOCK_HPP

#include "SockClass.hpp"

class TCPEchoServer: public TCPServerSock{
public:
    TCPEchoServer(
        const TCPListenSock& listen_sock,
        int pre_buffer_size = 32);
    ~TCPEchoServer();
    bool handEcho() const;
};

#endif //AppSock.hpp

//Filename: AppSock.cpp

#include <string>
#include "AppSock.hpp"

TCPEchoServer::TCPEchoServer(const TCPListenSock& listen_sock, int pre_buffer_size):
TCPServerSock(listen_sock, pre_buffer_size)
{}

TCPEchoServer::~TCPEchoServer()
{}

bool TCPEchoServer::handEcho() const
{
    const std::string SHUTDOWN_CMD = "/shutdown";
    while (TCPReceive() > 0) {
        std::string cmd(preBuffer, SHUTDOWN_CMD.size());
        if (cmd == SHUTDOWN_CMD && preReceivedLength == SHUTDOWN_CMD.size()) {
            return false;
        }
        TCPSend(preBuffer, preReceivedLength);
    }
    return true;
}

//Filename: main.cpp

#include "SockClass.hpp"
#include "AppSock.hpp"

int TCP_echo_server(int argc, char* argv[]);

int main(int argc, char* argv[])
{
    int mainRtn = 0;
    try {
        mainRtn =TCP_echo_server(argc, argv);
    }
    catch (const char* s) {
        perror(s);
        return 1;
    }
    catch (const int& err) {
        std::cerr << "Error: " << err << std::endl;
        return 1;
    }

    return mainRtn;
}

int TCP_echo_server(int argc, char* argv[])
{
    const unsigned short DEFAULT_PORT = 5000;
    unsigned short listen_port = DEFAULT_PORT;
    if (argc == 2 && atoi(argv[1]) > 0) {
        listen_port = atoi(argv[1]);
    }

    WinsockAPI winsockInfo;
    winsockInfo.showVersion();

    TCPListenSock listen_sock(listen_port);
    listen_sock.TCPListen();

    bool go_on = true;
    while (go_on){
        TCPEchoServer echo_server(listen_sock);
        go_on = echo_server.handEcho();
    }

    return 0;
}