tars源码分析之19

这个文件太经典了，对网络编程socket感兴趣的你，千万不要错过：

#include <unistd.h>
#include <fcntl.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <cerrno>
#include <cassert>
#include <ifaddrs.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <netinet/in.h>
 
#include "util/tc_socket.h"
#include "util/tc_common.h"
 
namespace tars
{
 
TC_Socket::TC_Socket() : _sock(INVALID_SOCKET), _bOwner(true), _iDomain(AF_INET)
{
}
 
TC_Socket::~TC_Socket()
{
    if(_bOwner)
    {
        close();
    }
}
 
void TC_Socket::init(int fd, bool bOwner, int iDomain)
{
    if(_bOwner)
    {
        close();
    }
 
    _sock       = fd;
    _bOwner     = bOwner;
    _iDomain    = iDomain;
}
 
void TC_Socket::createSocket(int iSocketType, int iDomain)
{
    assert(iSocketType == SOCK_STREAM || iSocketType == SOCK_DGRAM);
    close();
 
    _iDomain    = iDomain;
    _sock       = socket(iDomain, iSocketType, 0);
 
    if(_sock < 0)
    {
        _sock = INVALID_SOCKET;
        throw TC_Socket_Exception("[TC_Socket::createSocket] create socket error! :" + string(strerror(errno)));
    }
}
 
void TC_Socket::getPeerName(string &sPeerAddress, uint16_t &iPeerPort)
{
    assert(_iDomain == AF_INET);
 
    struct sockaddr stPeer;
    bzero(&stPeer, sizeof(struct sockaddr));
    socklen_t iPeerLen = sizeof(sockaddr);
 
    getPeerName(&stPeer, iPeerLen);
 
    char sAddr[INET_ADDRSTRLEN] = "\0";
    struct sockaddr_in *p = (struct sockaddr_in *)&stPeer;
 
    inet_ntop(_iDomain, &p->sin_addr, sAddr, sizeof(sAddr));
 
    sPeerAddress= sAddr;
    iPeerPort   = ntohs(p->sin_port);
}
 
void TC_Socket::getPeerName(string &sPathName)
{
    assert(_iDomain == AF_LOCAL);
 
    struct sockaddr_un stSock;
    bzero(&stSock, sizeof(struct sockaddr_un));
    socklen_t iSockLen = sizeof(stSock);
    getPeerName((struct sockaddr *)&stSock, iSockLen);
 
    sPathName = stSock.sun_path;
}
 
void TC_Socket::getPeerName(struct sockaddr *pstPeerAddr, socklen_t &iPeerLen)
{
    if(getpeername(_sock, pstPeerAddr, &iPeerLen) < 0)
    {
        throw TC_Socket_Exception("[TC_Socket::getPeerName] getpeername error", errno);
    }
}
 
void TC_Socket::getSockName(string &sSockAddress, uint16_t &iSockPort)
{
    assert(_iDomain == AF_INET);
 
    struct sockaddr stSock;
    bzero(&stSock, sizeof(struct sockaddr));
    socklen_t iSockLen = sizeof(sockaddr);
 
    getSockName(&stSock, iSockLen);
 
    char sAddr[INET_ADDRSTRLEN] = "\0";
    struct sockaddr_in *p = (struct sockaddr_in *)&stSock;
 
    inet_ntop(_iDomain, &p->sin_addr, sAddr, sizeof(sAddr));
 
    sSockAddress = sAddr;
    iSockPort = ntohs(p->sin_port);
}
 
void TC_Socket::getSockName(string &sPathName)
{
    assert(_iDomain == AF_LOCAL);
 
    struct sockaddr_un stSock;
    bzero(&stSock, sizeof(struct sockaddr_un));
    socklen_t iSockLen = sizeof(stSock);
    getSockName((struct sockaddr *)&stSock, iSockLen);
 
    sPathName = stSock.sun_path;
}
 
void TC_Socket::getSockName(struct sockaddr *pstSockAddr, socklen_t &iSockLen)
{
    if(getsockname(_sock, pstSockAddr, &iSockLen) < 0)
    {
        throw TC_Socket_Exception("[TC_Socket::getSockName] getsockname error", errno);
    }
}
 
int TC_Socket::accept(TC_Socket &tcSock, struct sockaddr *pstSockAddr, socklen_t &iSockLen)
{
    assert(tcSock._sock == INVALID_SOCKET);
 
    int ifd;
 
    while ((ifd = ::accept(_sock, pstSockAddr, &iSockLen)) < 0 && errno == EINTR);
 
    tcSock._sock    = ifd;
    tcSock._iDomain = _iDomain;
 
    return tcSock._sock;
}
 
void TC_Socket::parseAddr(const string &sAddr, struct in_addr &stSinAddr)
{
    int iRet = inet_pton(AF_INET, sAddr.c_str(), &stSinAddr);
    if(iRet < 0)
    {
        throw TC_Socket_Exception("[TC_Socket::parseAddr] inet_pton error", errno);
    }
    else if(iRet == 0)
    {
        struct hostent stHostent;
        struct hostent *pstHostent;
        char buf[2048] = "\0";
        int iError;
 
        gethostbyname_r(sAddr.c_str(), &stHostent, buf, sizeof(buf), &pstHostent, &iError);
 
        if (pstHostent == NULL)
        {
            throw TC_Socket_Exception("[TC_Socket::parseAddr] gethostbyname_r error! :" + string(hstrerror(iError)));
        }
        else
        {
            stSinAddr = *(struct in_addr *) pstHostent->h_addr;
        }
    }
}
 
void TC_Socket::bind(const string &sServerAddr, int port)
{
    assert(_iDomain == AF_INET);
 
    struct sockaddr_in bindAddr;
 
    bzero(&bindAddr, sizeof(bindAddr));
 
    bindAddr.sin_family   = _iDomain;
    bindAddr.sin_port     = htons(port);
 
    if (sServerAddr == "")
    {
        bindAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    }
    else
    {
        parseAddr(sServerAddr, bindAddr.sin_addr);
    }
 
    try
    {
        bind((struct sockaddr *)(&bindAddr), sizeof(bindAddr));
    }
    catch(...)
    {
        throw TC_Socket_Exception("[TC_Socket::bind] bind '" + sServerAddr + ":" + TC_Common::tostr(port) + "' error", errno);
    }
}
 
void TC_Socket::bind(const char *sPathName)
{
    assert(_iDomain == AF_LOCAL);
 
    unlink(sPathName);
 
    struct sockaddr_un stBindAddr;
    bzero(&stBindAddr, sizeof(struct sockaddr_un));
    stBindAddr.sun_family = _iDomain;
    strncpy(stBindAddr.sun_path, sPathName, sizeof(stBindAddr.sun_path));
 
    try
    {
        bind((struct sockaddr *)&stBindAddr, sizeof(stBindAddr));
    }
    catch(...)
    {
        throw TC_Socket_Exception("[TC_Socket::bind] bind '" + string(sPathName) + "' error", errno);
    }
}
 
void TC_Socket::bind(struct sockaddr *pstBindAddr, socklen_t iAddrLen)
{
    //如果服务器终止后,服务器可以第二次快速启动而不用等待一段时间
    int iReuseAddr = 1;
 
    //设置
    setSockOpt(SO_REUSEADDR, (const void *)&iReuseAddr, sizeof(int), SOL_SOCKET);
 
    if(::bind(_sock, pstBindAddr, iAddrLen) < 0)
    {
        throw TC_Socket_Exception("[TC_Socket::bind] bind error", errno);
    }
}
 
void TC_Socket::close()
{
    if (_sock != INVALID_SOCKET)
    {
        ::close(_sock);
        _sock = INVALID_SOCKET;
    }
}
 
int TC_Socket::connectNoThrow(const string &sServerAddr, uint16_t port)
{
    assert(_iDomain == AF_INET);
 
    if (sServerAddr == "")
    {
        throw TC_Socket_Exception("[TC_Socket::connect] server address is empty error!");
    }
 
    struct sockaddr_in serverAddr;
    bzero(&serverAddr, sizeof(serverAddr));
 
    serverAddr.sin_family = _iDomain;
    parseAddr(sServerAddr, serverAddr.sin_addr);
    serverAddr.sin_port = htons(port);
 
    return connect((struct sockaddr *)(&serverAddr), sizeof(serverAddr));
}
 
int TC_Socket::connectNoThrow(struct sockaddr* addr)
{
    assert(_iDomain == AF_INET);
 
    return connect(addr, sizeof(struct sockaddr));
}
 
void TC_Socket::connect(const string &sServerAddr, uint16_t port)
{
    int ret = connectNoThrow(sServerAddr, port);
 
    if(ret < 0)
    {
        throw TC_SocketConnect_Exception("[TC_Socket::connect] connect error", errno);
    }
}
 
void TC_Socket::connect(const char *sPathName)
{
    int ret = connectNoThrow(sPathName);
    if(ret < 0)
    {
        throw TC_SocketConnect_Exception("[TC_Socket::connect] connect error", errno);
    }
}
 
int TC_Socket::connectNoThrow(const char *sPathName)
{
    assert(_iDomain == AF_LOCAL);
 
    struct sockaddr_un stServerAddr;
    bzero(&stServerAddr, sizeof(struct sockaddr_un));
    stServerAddr.sun_family = _iDomain;
    strncpy(stServerAddr.sun_path, sPathName, sizeof(stServerAddr.sun_path));
 
    return connect((struct sockaddr *)&stServerAddr, sizeof(stServerAddr));
}
 
int TC_Socket::connect(struct sockaddr *pstServerAddr, socklen_t serverLen)
{
    return ::connect(_sock, pstServerAddr, serverLen);
 
}
 
void TC_Socket::listen(int iConnBackLog)
{
    if (::listen(_sock, iConnBackLog) < 0)
    {
        throw TC_Socket_Exception("[TC_Socket::listen] listen error", errno);
    }
}
 
int TC_Socket::recv(void *pvBuf, size_t iLen, int iFlag)
{
    return ::recv(_sock, pvBuf, iLen, iFlag);
}
 
int TC_Socket::send(const void *pvBuf, size_t iLen, int iFlag)
{
    return ::send(_sock, pvBuf, iLen, iFlag);
}
 
int TC_Socket::recvfrom(void *pvBuf, size_t iLen, string &sFromAddr, uint16_t &iFromPort, int iFlags)
{
    struct sockaddr stFromAddr;
    socklen_t iFromLen = sizeof(struct sockaddr);
    struct sockaddr_in *p = (struct sockaddr_in *)&stFromAddr;
 
    bzero(&stFromAddr, sizeof(struct sockaddr));
 
    int iBytes = recvfrom(pvBuf, iLen, &stFromAddr, iFromLen, iFlags);
    if (iBytes >= 0)
    {
        char sAddr[INET_ADDRSTRLEN] = "\0";
 
        inet_ntop(_iDomain, &p->sin_addr, sAddr, sizeof(sAddr));
 
        sFromAddr = sAddr;
        iFromPort = ntohs(p->sin_port);
    }
 
    return iBytes;
}
 
int TC_Socket::recvfrom(void *pvBuf, size_t iLen, struct sockaddr *pstFromAddr, socklen_t &iFromLen, int iFlags)
{
    return ::recvfrom(_sock, pvBuf, iLen, iFlags, pstFromAddr, &iFromLen);
}
 
int TC_Socket::sendto(const void *pvBuf, size_t iLen, const string &sToAddr, uint16_t port, int iFlags)
{
    struct sockaddr_in toAddr;
 
    bzero(&toAddr, sizeof(struct sockaddr_in));
 
    toAddr.sin_family = _iDomain;
 
    if (sToAddr == "")
    {
        toAddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
    }
    else
    {
        parseAddr(sToAddr, toAddr.sin_addr);
    }
 
    toAddr.sin_port = htons(port);
 
    return sendto(pvBuf, iLen, (struct sockaddr *)(&toAddr), sizeof(toAddr), iFlags);
}
 
int TC_Socket::sendto(const void *pvBuf, size_t iLen, struct sockaddr *pstToAddr, socklen_t iToLen, int iFlags)
{
    return ::sendto(_sock, pvBuf, iLen, iFlags, pstToAddr, iToLen);
}
 
void TC_Socket::shutdown(int iHow)
{
    if (::shutdown(_sock, iHow) < 0)
    {
        throw TC_Socket_Exception("[TC_Socket::shutdown] shutdown error", errno);
    }
}
 
void TC_Socket::setblock(bool bBlock)
{
    assert(_sock != INVALID_SOCKET);
 
    setblock(_sock, bBlock);
}
 
int TC_Socket::setSockOpt(int opt, const void *pvOptVal, socklen_t optLen, int level)
{
    return setsockopt(_sock, level, opt, pvOptVal, optLen);
}
 
int TC_Socket::getSockOpt(int opt, void *pvOptVal, socklen_t &optLen, int level)
{
    return getsockopt(_sock, level, opt, pvOptVal, &optLen);
}
 
void TC_Socket::setNoCloseWait()
{
    linger stLinger;
    stLinger.l_onoff = 1;  //在close socket调用后, 但是还有数据没发送完毕的时候容许逗留
    stLinger.l_linger = 0; //容许逗留的时间为0秒
 
    if(setSockOpt(SO_LINGER, (const void *)&stLinger, sizeof(linger), SOL_SOCKET) == -1)
    {
        throw TC_Socket_Exception("[TC_Socket::setNoCloseWait] error", errno);
    }
}
 
void TC_Socket::setCloseWait(int delay)
{
    linger stLinger;
    stLinger.l_onoff = 1;  //在close socket调用后, 但是还有数据没发送完毕的时候容许逗留
    stLinger.l_linger = delay; //容许逗留的时间为delay秒
 
    if(setSockOpt(SO_LINGER, (const void *)&stLinger, sizeof(linger), SOL_SOCKET) == -1)
    {
        throw TC_Socket_Exception("[TC_Socket::setCloseWait] error", errno);
    }
}
 
void TC_Socket::setCloseWaitDefault()
{
    linger stLinger;
    stLinger.l_onoff  = 0;
    stLinger.l_linger = 0;
 
    if(setSockOpt(SO_LINGER, (const void *)&stLinger, sizeof(linger), SOL_SOCKET) == -1)
    {
        throw TC_Socket_Exception("[TC_Socket::setCloseWaitDefault] error", errno);
    }
}
 
void TC_Socket::setTcpNoDelay()
{
    int flag = 1;
 
    if(setSockOpt(TCP_NODELAY, (char*)&flag, int(sizeof(int)), IPPROTO_TCP) == -1)
    {
        throw TC_Socket_Exception("[TC_Socket::setTcpNoDelay] error", errno);
    }
}
 
void TC_Socket::setKeepAlive()
{
    int flag = 1;
    if(setSockOpt(SO_KEEPALIVE, (char*)&flag, int(sizeof(int)), SOL_SOCKET) == -1)
    {
        throw TC_Socket_Exception("[TC_Socket::setKeepAlive] error", errno);
    }
}
 
void TC_Socket::setSendBufferSize(int sz)
{
    if(setSockOpt(SO_SNDBUF, (char*)&sz, int(sizeof(int)), SOL_SOCKET) == -1)
    {
        throw TC_Socket_Exception("[TC_Socket::setSendBufferSize] error", errno);
    }
}
 
int TC_Socket::getSendBufferSize()
{
    int sz;
    socklen_t len = sizeof(sz);
    if(getSockOpt(SO_SNDBUF, (void*)&sz, len, SOL_SOCKET) == -1 || len != sizeof(sz))
    {
        throw TC_Socket_Exception("[TC_Socket::getSendBufferSize] error", errno);
    }
 
    return sz;
}
 
void TC_Socket::setRecvBufferSize(int sz)
{
    if(setSockOpt(SO_RCVBUF, (char*)&sz, int(sizeof(int)), SOL_SOCKET) == -1)
    {
        throw TC_Socket_Exception("[TC_Socket::setRecvBufferSize] error", errno);
    }
}
 
int TC_Socket::getRecvBufferSize()
{
    int sz;
    socklen_t len = sizeof(sz);
    if(getSockOpt(SO_RCVBUF, (void*)&sz, len, SOL_SOCKET) == -1 || len != sizeof(sz))
    {
        throw TC_Socket_Exception("[TC_Socket::getRecvBufferSize] error", errno);
    }
 
    return sz;
}
 
void TC_Socket::setblock(int fd, bool bBlock)
{
    int val = 0;
 
    if ((val = fcntl(fd, F_GETFL, 0)) == -1)
    {
        throw TC_Socket_Exception("[TC_Socket::setblock] fcntl [F_GETFL] error", errno);
    }
 
    if(!bBlock)
    {
        val |= O_NONBLOCK;
    }
    else
    {
        val &= ~O_NONBLOCK;
    }
 
    if (fcntl(fd, F_SETFL, val) == -1)
    {
        throw TC_Socket_Exception("[TC_Socket::setblock] fcntl [F_SETFL] error", errno);
    }
}
 
void TC_Socket::createPipe(int fds[2], bool bBlock)
{
    if(::pipe(fds) != 0)
    {
        throw TC_Socket_Exception("[TC_Socket::createPipe] error", errno);
    }
 
    try
    {
        setblock(fds[0], bBlock);
        setblock(fds[1], bBlock);
    }
    catch(...)
    {
        ::close(fds[0]);
        ::close(fds[1]);
        throw;
    }
}
 
vector<string> TC_Socket::getLocalHosts()
{
    vector<string> result;
 
    TC_Socket ts;
    ts.createSocket(SOCK_STREAM, AF_INET);
 
    int cmd = SIOCGIFCONF;
 
    struct ifconf ifc;
 
    int numaddrs = 10;
 
    int old_ifc_len = 0;
 
    while(true)
    {
        int bufsize = numaddrs * static_cast<int>(sizeof(struct ifreq));
        ifc.ifc_len = bufsize;
        ifc.ifc_buf = (char*)malloc(bufsize);
        int rs = ioctl(ts.getfd(), cmd, &ifc);
 
        if(rs == -1)
        {
            free(ifc.ifc_buf);
            throw TC_Socket_Exception("[TC_Socket::getLocalHosts] ioctl error", errno);
        }
        else if(ifc.ifc_len == old_ifc_len)
        {
            break;
        }
        else
        {
            old_ifc_len = ifc.ifc_len;
        }
    
        numaddrs += 10;
        free(ifc.ifc_buf);
    }
 
    numaddrs = ifc.ifc_len / static_cast<int>(sizeof(struct ifreq));
    struct ifreq* ifr = ifc.ifc_req;
    for(int i = 0; i < numaddrs; ++i)
    {
        if(ifr[i].ifr_addr.sa_family == AF_INET)
        {
            struct sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*>(&ifr[i].ifr_addr);
            if(addr->sin_addr.s_addr != 0)
            {
                char sAddr[INET_ADDRSTRLEN] = "\0";
                inet_ntop(AF_INET, &(*addr).sin_addr, sAddr, sizeof(sAddr));
                result.push_back(sAddr);
            }
        }
    }
 
    free(ifc.ifc_buf);
 
    return result;
}
 
 
}