Socket.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <string.h>             // memset
 
#if __DCL_WINDOWS
    #include <winsock2.h>
#else
    #include <errno.h>
    #include <sys/types.h>
    #include <sys/ioctl.h>      // ioctl
    #include <sys/socket.h>     // send, recv
    #include <netdb.h>          // gethostbyname
    #include <unistd.h>         // close
    #include <stdlib.h>         // alloca
#endif
 
#include <dcl/Charset.h>
#include <dcl/Numeric.h>
#include <dcl/Socket.h>
 
#if !__DCL_WINDOWS
    #include "__strumbs.h"
#endif
 
#if __DCL_DEBUG
    #undef __THIS_FILE__
    static const char_t __THIS_FILE__[] = __T("dcl/Socket.cpp");
#endif
 
#undef INVALID_SOCKET
#if __DCL_WINDOWS
    #define SOCKET_TYPE                 UINT_PTR
    #define INVALID_SOCKET              (UINT_PTR) -1
    #define __ERRNO                     WSAGetLastError()
#else
    #define SOCKET_TYPE                 int
    #define INVALID_HANDLE_VALUE        -1
    #define INVALID_SOCKET              -1
    #define closesocket(s)              close(s)
    #define ioctlsocket(s, cmd, argp)   ioctl(s, cmd, argp)
    #define __ERRNO                     errno
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(Socket, PollAble)
 
String Socket::toString() const
{
    StringBuilder r = className();
    if (__handle == INVALID_HANDLE_VALUE)
        r += __T(" closed");
    else {
        if (!__path.isEmpty()) {
            r += __T(" local ");
            r += __path;
        }
 
        Addr addr;
        socklen_t n = sizeof(addr);
        if (!::getpeername((SOCKET_TYPE) __handle, (struct sockaddr*) &addr, &n)) {
            String foreign = addr.toString();
            if (!foreign.isEmpty()) {
                if (!__path.isEmpty())
                    r += __T(",");
                r +=  __T(" foreign ") + foreign;
            }
        }
    }
 
    return r;
}
 
void Socket::open(const String& _addr, uint16_t _port)
            __DCL_THROWS1(IOException*)
{
    if (__handle != INVALID_HANDLE_VALUE)
        close();
 
    Addr addr(_addr, _port);
    connect(addr);
}
 
size_t Socket::available() const
        __DCL_THROWS1(IOException*)
{
    u_long n = 0;
    if (ioctlsocket((SOCKET_TYPE) __handle, FIONREAD, &n))
        throw new IOException(toString(), __ERRNO);
    
    return (size_t)n;
}
 
size_t Socket::read(void* _buf, size_t _n)
        __DCL_THROWS1(IOException*)
{
    return recv(_buf, _n, 0);
}
 
size_t Socket::write(const void* _buf, size_t _n)
        __DCL_THROWS1(IOException*)
{
    return send(_buf, _n, 0);
}
 
Socket::Addr::Addr()
{
    memset((void*) this, 0, sizeof(Addr));
}
 
static void __init_inet_addr(Socket::Addr* _dest, const char* _addr, uint16_t _port)
        __DCL_THROWS1(IOException*)
{
    if (*_addr != '\0') {
        if (strchr(_addr, ':') &&
                inet_pton(AF_INET6, _addr, &(_dest->sa_in6.sin6_addr)) > 0) {
            _dest->sa_family = AF_INET6;
            _dest->sa_in6.sin6_port = htons(_port);
            return;
        }
        else if(inet_pton(AF_INET, _addr, &(_dest->sa_in.sin_addr)) > 0) {
            _dest->sa_family = AF_INET;
            _dest->sa_in.sin_port = htons(_port);
            return;
        }
    }
 
    struct hostent* ent = gethostbyname(_addr);
    if (ent) {
#if 0
        __DCL_TRACE4(__T("name[%hs], aliases[%hs], type[%d], length[%d]\n"),
            ent->h_name ? ent->h_name : "(null)",
            ent->h_aliases ? ent->h_aliases[0] : "(null)",
            ent->h_addrtype, ent->h_length
            );
#endif
        _dest->sa_family = ent->h_addrtype;
        switch (_dest->sa_family) {
            case AF_INET: {
#if 0
                {
                    char** list = ent->h_addr_list;
                    for (int i = 0; list[i] != NULL; i++) {
                        printf("[%d] [", i);
                        for (int j = 0; j < ent->h_length; j++) {
                            if (j > 0)
                                printf(".");
                            printf("%u", (unsigned char) list[i][j]);
                        }
                        printf("]\n");
                    }
                }
#endif
                _dest->sa_in.sin_addr.s_addr = *(u_long*) ent->h_addr_list[0];
                _dest->sa_in.sin_port = htons(_port);
                break;
            }
            case AF_INET6: {
                memcpy(&(_dest->sa_in6), ent->h_addr_list[0], ent->h_length);
                _dest->sa_in6.sin6_port = htons(_port);
                break;
            }
            default: {
                __DCL_ASSERT(false);
            }
        }
        return;
    }
 
    AsciiDecoder dec;
    String s = dec.decode(_addr);
    throw new IOException(s,
#if __DCL_WINDOWS
            WSAEAFNOSUPPORT
#else
            EAFNOSUPPORT
#endif
        );
}
 
Socket::Addr::Addr(const char *_addr, uint16_t _port)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(_addr != NULL);
    memset((void*) this, 0, sizeof(Addr));
 
    __init_inet_addr(this, _addr, _port);
}
 
Socket::Addr::Addr(const String& _addr, uint16_t _port)
        __DCL_THROWS1(IOException*)
{
    memset((void*) this, 0, sizeof(Addr));
 
    AsciiEncoder enc;
    ByteString addr;
    try {
        addr = enc.encode(_addr);
    }
    catch (CharsetConvertException* cause) {
        throw new IOException(_addr, cause);
    }
 
    __init_inet_addr(this, addr, _port);
}
 
#if !__DCL_WINDOWS
Socket::Addr::Addr(const char* _path)
        __DCL_THROWS1(IOException*)
{
    memset((void*) this, 0, sizeof(Addr));
 
    __DCL_ASSERT(_path != NULL);
    size_t n = ByteString::length(_path);
    if (n > sizeof(sa_un.sun_path))
    {
 
        throw new IOException(AsciiDecoder::decode(_path, n), ENAMETOOLONG);
    }
 
    sa_un.sun_family = AF_UNIX;
    strncpy(sa_un.sun_path, _path, n);
}
 
Socket::Addr::Addr(const String& _path)
        __DCL_THROWS1(IOException*)
{
    memset((void*) this, 0, sizeof(Addr));
 
    __DCL_ASSERT(!_path.isEmpty());
    STRTOMBS(_path, mbs)
    else
        throw new IOException(_path, EILSEQ);
 
    if (nmbs > sizeof(sa_un.sun_path))
        throw new IOException(_path, ENAMETOOLONG);
 
    sa_un.sun_family = AF_UNIX;
    strncpy(sa_un.sun_path, mbs, nmbs);
}
#endif
 
String Socket::Addr::toString() const
{
    char buf[512];
 
    switch (sa_family) {
#if !__DCL_WINDOWS
        case AF_UNIX: {
            strncpy(buf, sa_un.sun_path, __countof(sa_un.sun_path, char));
            AsciiDecoder dec;
            return dec.decode(buf);
            break;
        }
#endif
        case AF_INET: {
            if (inet_ntop(AF_INET, (void*) &(sa_in.sin_addr), buf, sizeof(buf))) {
                AsciiDecoder dec;
                StringBuilder r = dec.decode(buf);
                r += __T(":");
                r += UInteger::toString(ntohs(sa_in.sin_port), 10);
                return r;
            }
            break;
        }
        case AF_INET6: {
            if (inet_ntop(AF_INET6, (void*) &(sa_in6.sin6_addr), buf, sizeof(buf))) {
                AsciiDecoder dec;
                StringBuilder r =  dec.decode(buf);
                if (sa_in6.sin6_flowinfo) {
                    r += __T("%");
                    r += UInteger::toString(sa_in6.sin6_flowinfo, 10);
                }
                r += __T(":");
                r += UInteger::toString(ntohs(sa_in6.sin6_port), 10);
                return r;
            }
            break;
        }
        default : {
            __DCL_ASSERT(false);
        }
    }
 
    return String(__T("Invalid !!"));
}
 
void Socket::bind(const Addr& _addr, int _type, int _protocol, bool _reuse)
        __DCL_THROWS1(IOException*)
{
    if (__handle == INVALID_HANDLE_VALUE)
        create(_addr.sa_family, _type, _protocol);
 
    socklen_t n = sizeof(_addr);
    switch (_addr.sa_family) {
#if !__DCL_WINDOWS
        case AF_UNIX: {
            n = sizeof(_addr.sa_un);
            break;
        }
#endif
        case AF_INET: {
            n = sizeof(_addr.sa_in);
            break;
        }
        case AF_INET6: {
            n = sizeof(_addr.sa_in6);
            break;
        }
        default: {
            __DCL_ASSERT(false);
        }
    }
 
    if (_reuse) {
#if __DCL_WINDOWS
        BOOL reuse = TRUE;
        if (::setsockopt((SOCKET_TYPE) __handle,
            SOL_SOCKET, SO_REUSEADDR, (const char*) &reuse, sizeof(reuse)
            ))
            throw new IOException(__path, WSAGetLastError());
#else
        int reuse = 1;
        if (::setsockopt((SOCKET_TYPE) __handle,
                SOL_SOCKET, SO_REUSEADDR, (const void*) &reuse, sizeof(reuse)))
            throw new IOException(__path, errno);
#endif
    }
 
    bind((const sockaddr*) &_addr, n);
}
 
void Socket::accept(Socket& _r)
        __DCL_THROWS1(IOException*)
{
    Addr addr;
    socklen_t n = sizeof(addr);
    accept(_r, (struct sockaddr*) &addr, &n);
}
 
void Socket::connect(const Addr& _addr)
        __DCL_THROWS1(IOException*)
{
    if (__handle == INVALID_HANDLE_VALUE)
        create(_addr.sa_family, SOCK_STREAM, IPPROTO_TCP);
 
    socklen_t n = sizeof(_addr);
    switch (_addr.sa_family) {
#if !__DCL_WINDOWS
        case AF_UNIX: {
            n = sizeof(_addr.sa_un);
            break;
        }
#endif
        case AF_INET: {
            n = sizeof(_addr.sa_in);
            break;
        }
        case AF_INET6: {
            n = sizeof(_addr.sa_in6);
            break;
        }
        default: {
            __DCL_ASSERT(false);
        }
    }
 
    connect((const sockaddr*) &_addr, n);
}
 
socklen_t Socket::getsockname(Addr& _addr)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(__handle != INVALID_HANDLE_VALUE);
    socklen_t n  = sizeof(_addr);
    if (::getsockname((SOCKET_TYPE) __handle, (struct sockaddr*) &_addr, &n) == -1)
        throw new IOException(toString(), __ERRNO);
    return n;
}
 
socklen_t Socket::getpeername(Addr& _addr)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(__handle != INVALID_HANDLE_VALUE);
    socklen_t n  = sizeof(_addr);
    if (::getpeername((SOCKET_TYPE) __handle, (struct sockaddr*) &_addr, &n) == -1)
        throw new IOException(toString(), __ERRNO);
    return n;
}
 
Socket::Socket()
{
//  File::__handle = INVALID_HANDLE_VALUE;
#if __DCL_WINDOWS
    __waitEvent = WSA_INVALID_EVENT;
#endif
}
 
Socket::Socket(const String& _addr, uint16_t _port)
            __DCL_THROWS1(IOException*)
{
//  File::__handle = INVALID_HANDLE_VALUE;
#if __DCL_WINDOWS
    __waitEvent = WSA_INVALID_EVENT;
#endif
    open(_addr, _port);
}
 
 
Socket::~Socket()
{
    if (__handle != INVALID_HANDLE_VALUE) {
        try {
            close();
        }
        catch (IOException* cause) {
            __DCL_TRACE1(__T("Error! Socket::~Socket %ls\n"), cause->toString().data());
            cause->destroy();
        }
    }
#if __DCL_WINDOWS
    if (__waitEvent != WSA_INVALID_EVENT) {
        WSACloseEvent(__waitEvent);
        __waitEvent = WSA_INVALID_EVENT;
    }
#endif
}
 
void Socket::close()
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
 
    SOCKET_TYPE handle = (SOCKET_TYPE) __handle;
    String path = __path;
    __handle = INVALID_HANDLE_VALUE;
    __path.clear();
 
    if (::closesocket(handle))
        throw new IOException(__path, __ERRNO);
}
 
#if defined(_MSC_VER) && !defined(__DCL_CORE_EXPORTS)
    #pragma optimize ( "", off )
    #pragma warning ( push )
    #pragma warning ( disable : 4748 )
#endif
 
void Socket::create(int _domain, int _type, int _protocol)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle == INVALID_HANDLE_VALUE);
 
    SOCKET_TYPE handle = ::socket(_domain, _type, _protocol);
    if (handle == INVALID_SOCKET)
        throw new IOException(toString(), __ERRNO);
    __handle = (HandleType) handle;
}
 
void Socket::setNonblock()
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
 
    unsigned long u = 1;
    if (::ioctlsocket((SOCKET_TYPE) __handle, FIONBIO, &u))
        throw new IOException(toString(), __ERRNO);
}
 
void Socket::bind(const struct sockaddr* _my_addr, socklen_t _addrlen)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
    
    if (::bind((SOCKET_TYPE) __handle, _my_addr, _addrlen))
        throw new IOException(toString(), __ERRNO);
 
    Addr raddr;
    getsockname(raddr);
    __path = raddr.toString();
}
 
void Socket::listen(unsigned _backlog)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
 
    if (::listen((SOCKET_TYPE) __handle, _backlog))
        throw new IOException(toString(), __ERRNO);
}
 
void Socket::accept(Socket& r, struct sockaddr* _addr, socklen_t* _addrlen)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
    __DCL_ASSERT_HANDLE(r.__handle == INVALID_HANDLE_VALUE);
    __DCL_ASSERT_PARAM(_addr != NULL && _addrlen != NULL);
 
    SOCKET_TYPE handle = ::accept((SOCKET_TYPE) __handle, _addr, _addrlen);
    if (handle == INVALID_SOCKET)
        throw new IOException(toString(), __ERRNO);
 
    r.__handle = (HandleType) handle;
    Addr raddr;
    r.getsockname(raddr);
    r.__path = raddr.toString();
}
 
void Socket::connect(const sockaddr* _serv_addr, socklen_t _addrlen)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
    
    if (::connect((SOCKET_TYPE) __handle, _serv_addr, _addrlen))
        throw new IOException(toString(), __ERRNO);
 
    Addr raddr;
    getsockname(raddr);
    __path = raddr.toString();
}
 
size_t Socket::send(const void* _buf, size_t _n, int _flags)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
    __DCL_ASSERT_PARAM(_buf != NULL);
 
#if __DCL_WINDOWS
    int n = ::send((SOCKET_TYPE) __handle, (const char*) _buf, _n, _flags);
    if (n == SOCKET_ERROR)
    {
        // 소켓이 nonblocking으로 표시되었고 오퍼레이션이 블록되었다.
        if (WSAGetLastError() == WSAEWOULDBLOCK)
            return 0;
        else
            throw new IOException(toString(), WSAGetLastError());
    }
 
#else
    int n = ::send((SOCKET_TYPE) __handle, _buf, _n, _flags);
    if (n == -1)
    {
        // 소켓이 nonblocking으로 표시되었고 오퍼레이션이 블록되었다.
        if (errno == EAGAIN || errno == EWOULDBLOCK)
            return 0;
        else
            throw new IOException(toString(), errno);
    }
 
#endif
    return (size_t) n;
}
 
size_t Socket::recv(void* _buf, size_t _n, int _flags)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
    __DCL_ASSERT_PARAM(_buf != NULL);
 
#if __DCL_WINDOWS
    int n = ::recv((SOCKET_TYPE) __handle, (char*) _buf, _n, _flags);
    if (n == SOCKET_ERROR)
    {
        // 소켓이 nonblocking으로 표시되었고 오퍼레이션이 블록되었다.
        if (WSAGetLastError() == WSAEWOULDBLOCK)
            return 0;
        else
            throw new IOException(toString(), WSAGetLastError());
    }
 
#else
    int n = ::recv((SOCKET_TYPE) __handle, _buf, _n, _flags);
    if (n == -1)
    {
        // 소켓이 nonblocking으로 표시되었고 오퍼레이션이 블록되었다.
        if (errno == EAGAIN || errno == EWOULDBLOCK)
            return 0;
        else
            throw new IOException(toString(), errno);
    }
 
#endif
    return (size_t) n;
}
 
#if defined(_MSC_VER) && !defined(__DCL_CORE_EXPORTS)
    #pragma warning ( pop )
    #pragma optimize ( "", on )
#endif
 
bool Socket::onEvent(short _revents, PollThread* _pPollThread)
        __DCL_THROWS1(IOException*)
{
    // Nothing
    return true;
}
 
__DCL_END_NAMESPACE