root/lang/cplusplus/llv8call/branches/unixsocket/ext/socket/socket.cc @ 21244

// The MIT License
// 
// Copyright (c) 2008 Tokuhiro Matsuno
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

#include <v8.h>
#include <cstdio>
#include <cstdlib>
#include <memory.h>
#include <errno.h>
#include "v8ext.h"
#include <llv8-macros.h>
#ifndef _WIN32
#  include <sys/socket.h>
#  include <sys/types.h>
#  include <netinet/in.h>
#  include <arpa/inet.h>
#  include <sys/un.h>
#  include <unistd.h>
#  include <sys/param.h>
#  include <netdb.h>
#endif

typedef union sock_addr {
    struct sockaddr_in in;
#ifdef AF_UNIX
    struct sockaddr_un un;
#endif
} sock_addr_t;

/** DESCRIPTION:
 *
 * low level socket class.
 *
 * Design of this class is inspired from python's socket class.
 *
 */

#define EXTERNAL_SOCKET() int sock = (int) args.This()->GetInternalField(0)->Int32Value()

using namespace v8;

static inline Handle<Value> throw_stderr(const char *msg) {
    std::string buf(msg);
    buf += " error: ";
    buf += strerror(errno);
    return ThrowException(String::New(buf.c_str()));
}

static inline v8::Handle<v8::Object> socket_namespace() {
        return v8::Context::GetCurrent()->Global()
                      ->Get(v8::String::New("org"))->ToObject()
                      ->Get(v8::String::New("coderepos"))->ToObject()
                      ->Get(v8::String::New("socket"))->ToObject();
}

// TODO: support AF_UNIX
static inline Handle<Array> _makeaddr(sockaddr & addr) {
    Handle<Array> ret = Array::New(2);
    switch (addr.sa_family) {
#if defined(AF_UNIX)
    case AF_UNIX:
        {
            sockaddr_un * addr_un = (sockaddr_un*)&addr;
            ret->Set(Int32::New(0), String::New(addr_un->sun_path));
        }
        break;
#endif
    case AF_INET:
        {
            char buf[NI_MAXHOST];
            if (getnameinfo(&addr, sizeof(sockaddr_in), buf, sizeof(buf), NULL, 0, NI_NUMERICHOST)) {
                throw_stderr(__func__);
                return ret;
            }
            sockaddr_in * addr_in = (sockaddr_in*)&addr;
            ret->Set(Int32::New(0), String::New(buf));
            ret->Set(Int32::New(1), Int32::New(ntohs(addr_in->sin_port)));
        }
        break;
    default:
        ThrowException(String::New("This family does not supported yet"));
        return ret;
    }
    return ret;
}

// TODO: support unix domain socket
// TODO: support inet6
static inline void _gen_sockaddr(Handle<Array> &args, int family, sock_addr_t* addr_ret, socklen_t * len) {
    switch (family) {
#if defined(AF_UNIX)
    case AF_UNIX:
        {
            if (args->Length() != 1) {
                ThrowException(String::New("invalid args: AF_UNIX => (socket file)"));
                return;
            }
            struct sockaddr_un *addr = (struct sockaddr_un*)addr_ret;
            memset(addr, 0, sizeof(sockaddr_un)); // clear

            String::Utf8Value path(args->Get(Int32::New(0)));
            if ((unsigned int)path.length() >= sizeof(addr->sun_path)) {
                ThrowException(String::New("path too long"));
                return;
            }
            addr->sun_family = AF_UNIX;
            memcpy(addr->sun_path, *path, path.length());
            addr->sun_path[path.length()] = '\0';
            *len = path.length() + (sizeof(*addr) - sizeof(addr->sun_path));
        }
        break;
#endif
    case AF_INET:
        {
            if (args->Length() != 2) {
                ThrowException(String::New("invalid args: AF_INET => (host, port)"));
                return;
            }
            String::Utf8Value host(args->Get(Int32::New(0)));
            int32_t port = args->Get(Int32::New(1))->Int32Value();

            struct sockaddr_in *addr = (struct sockaddr_in*)addr_ret;
            memset(addr, 0, sizeof(*addr)); // clear
            addr->sin_family = AF_INET;
            in_addr_t hostinfo = inet_addr(*host);
            if (hostinfo == INADDR_NONE) {
                ThrowException(String::New("invalid ip"));
                return;
            }
            addr->sin_addr.s_addr = hostinfo;
            addr->sin_port = htons((short)port);
            *len = sizeof(*addr);
        }
        break;
    default:
        fprintf(stderr, "unknown family");
        abort();
    }
}


FUNCTION(_open)
    // USAGE: new Socket(Socket.AF_INET, Socket.SOCK_STREAM)
    if (args.Length() == 2 && args[0]->IsExternal()) {
        args.This()->SetInternalField(0, args[1]);
        args.This()->Set(String::New("family"), args[2]);
        args.This()->Set(String::New("type"),   args[3]);
        args.This()->Set(String::New("proto"),  args[4]);
        return args.This();
    } else {
        ARG_BETWEEN(0, 3);
        ARG_int(family, 0);
        ARG_int(type,   1);
        ARG_int(protocol,  2);

        if (args.Length() < 1) {
            family = AF_INET;
        }
        if (args.Length() < 2) {
            type = SOCK_STREAM;
        }
        if (args.Length() < 3) {
            protocol = 0;
        }

        int desc = socket(family, type, protocol);
        if (desc != -1) {
            args.This()->SetInternalField(0, Int32::New(desc));
            args.This()->Set(String::New("family"), Int32::New(family));
            args.This()->Set(String::New("type"),   Int32::New(type));
            args.This()->Set(String::New("proto"),  Int32::New(protocol));
            return args.This();
        } else {
            return ThrowException(String::New("cannot open socket"));
        }
    }
END

FUNCTION(_bind)
    EXTERNAL_SOCKET();
    sock_addr_t addr;
    socklen_t len;
    int family = args.This()->Get(String::New("family"))->Int32Value();
    ARG_array(addrsrc, 0);
    _gen_sockaddr(addrsrc, family, &addr, &len);
    if (bind(sock, (sockaddr*)&addr, len) == 0) {
        return Undefined();
    } else {
        return throw_stderr("bind error: ");
    }
END

FUNCTION(_listen)
    EXTERNAL_SOCKET();
    ARG_COUNT(1);
    ARG_int(backlog, 0);
    if (listen(sock, backlog) == 0) {
        return Undefined();
    } else {
        return throw_stderr("listen error: ");
    }
END

FUNCTION(_gethostname)
    ARG_COUNT(0);
    char * buf = new char [_POSIX_HOST_NAME_MAX+1];
    if (gethostname(buf, _POSIX_HOST_NAME_MAX) == 0) {
        Handle<String> str = String::New(buf);
        delete [] buf;
        return str;
    } else {
        delete [] buf;
        return throw_stderr("gethostname error: ");
    }
END

FUNCTION(_accept)
    EXTERNAL_SOCKET();
    ARG_COUNT(0);
    struct sockaddr addr;
    socklen_t len = sizeof(addr);
    int newsock = accept(sock, &addr, &len);
    if (newsock >= 0) {
        Handle<Value> argv[2];
        argv[0] = External::New(&len);
        argv[1] = Int32::New(newsock);
        argv[2] = args.This()->Get(String::New("family"));
        argv[3] = args.This()->Get(String::New("type"));
        argv[4] = args.This()->Get(String::New("proto"));
        return Handle<Function>::Cast( socket_namespace()->Get(String::New("Socket")) )->NewInstance(2, argv);
    } else {
        return throw_stderr("accept error: ");
    }
END

FUNCTION(_connect)
    EXTERNAL_SOCKET();
    sock_addr_t addr;
    socklen_t len;
    int family = args.This()->Get(String::New("family"))->Int32Value();
    ARG_array(addrsrc, 0);
    _gen_sockaddr(addrsrc, family, &addr, &len);
    if (connect(sock, (sockaddr*)&addr, len) == 0) {
        return Undefined();
    } else {
        return throw_stderr("connect error: ");
    }
END

FUNCTION(_recv)
    EXTERNAL_SOCKET();
    ARG_BETWEEN(1, 2);
    ARG_int(len, 0);
    int _flags = 0;
    if (args.Length() == 2) {
        ARG_int(flags, 1);
        _flags = flags;
    }
    char * buf = new char [len+1];
    assert(sock);
    ssize_t size = recv(sock, buf, len, _flags);
    if (size >= 0) {
        Handle<String> res = String::New(buf, size);
        delete [] buf;
        return res;
    } else {
        delete [] buf;
        return throw_stderr("recv error: ");
    }
END

FUNCTION(_recvfrom)
    EXTERNAL_SOCKET();
    ARG_BETWEEN(1, 2);
    ARG_int(buflen, 0);
    int _flags = 0;
    if (args.Length() == 2) {
        ARG_int(flags, 1);
        _flags = flags;
    }
    char * buf = new char [buflen];
    struct sockaddr addr;
    socklen_t addrlen = sizeof(sockaddr);
    ssize_t size = recvfrom(sock, buf, buflen, _flags, &addr, &addrlen);
    if (size >= 0) {
        Handle<Array> ret = Array::New(2);
        ret->Set(Int32::New(0), String::New(buf, size));
        ret->Set(Int32::New(1), _makeaddr(addr));
        delete [] buf;
        return ret;
    } else {
        delete [] buf;
        return throw_stderr("recvfrom error: ");
    }
END

FUNCTION(_send)
    // @ret Returns the number of bytes sent.
    EXTERNAL_SOCKET();
    ARG_BETWEEN(1, 2);
    ARG_str(str, 0);
    int _flags = 0;
    if (args.Length() == 2) {
        ARG_int(flags, 1);
        _flags = flags;
    }
    ssize_t size = send(sock, *str, str.length(), _flags);
    if (size >= 0) {
        return Int32::New(size);
    } else {
        return throw_stderr("send error: ");
    }
END

FUNCTION(_sendto)
    // @prototype sock.sendto(str, [flags, ] addr);
    // @ret Returns the number of bytes sent.
    EXTERNAL_SOCKET();
    ARG_BETWEEN(2, 3);
    ARG_str(str, 0);
    int _flags = 0;
    Handle<Array> addrsrc;
    if (args.Length() == 3) {
        ARG_int(flags, 1);
        _flags = flags;
        addrsrc = Handle<Array>::Cast(args[2]);
    } else {
        addrsrc = Handle<Array>::Cast(args[1]);
    }
    sock_addr_t addr;
    socklen_t len;
    int family = args.This()->Get(String::New("family"))->Int32Value();
    _gen_sockaddr(addrsrc, family, &addr, &len);
    ssize_t size = sendto(sock, *str, str.length(), _flags, (sockaddr*)&addr, len);
    if (size >= 0) {
        return Int32::New(size);
    } else {
        return throw_stderr("send error: ");
    }
END

FUNCTION(_getsockname)
    EXTERNAL_SOCKET();
    ARG_COUNT(0);
    sockaddr addr;
    socklen_t len = sizeof(sockaddr);
    if (getsockname(sock, &addr, &len) == 0) {
        return _makeaddr(addr);
    } else {
        return throw_stderr("getsockname");
    }
END

FUNCTION(_getpeername)
    EXTERNAL_SOCKET();
    ARG_COUNT(0);
    sockaddr addr;
    socklen_t len = sizeof(sockaddr);
    if (getpeername(sock, &addr, &len) == 0) {
        return _makeaddr(addr);
    } else {
        return throw_stderr("getpeername");
    }
END

FUNCTION(_fileno)
    EXTERNAL_SOCKET();
    ARG_COUNT(0);
    return Uint32::New(sock);
END

FUNCTION(_close)
    EXTERNAL_SOCKET();
    ARG_COUNT(0);
    if (close(sock) >= 0) {
        return Undefined();
    } else {
        return throw_stderr("close error: ");
    }
END

FUNCTION(_inet_aton)
    ARG_COUNT(1);
    ARG_str(ip, 0);
    in_addr addr;
    if (inet_aton(*ip, &addr) == 1) {
        return Uint32::New(addr.s_addr);
    } else {
        return throw_stderr("inet_aton");
    }
END

FUNCTION(_inet_ntoa)
    ARG_COUNT(1);
    ARG_uint(ip, 0);
    in_addr addr;
    addr.s_addr = ip;
    char * buf = inet_ntoa(addr);
    if (buf) {
        return String::New(buf);
    } else {
        return throw_stderr("inet_ntoa");
    }
END

MODULE()
    {
        CLASS_WITH_CONSTRUCTOR(_open);

        BIND_CI("SOCK_STREAM",    SOCK_STREAM);
        BIND_CI("SOCK_DGRAM",     SOCK_DGRAM);
        BIND_CI("SOCK_RAW",       SOCK_RAW);
        BIND_CI("SOCK_RDM",       SOCK_RDM);
        BIND_CI("SOCK_SEQPACKET", SOCK_SEQPACKET);

#if defined(AF_UNIX)
        BIND_CI("AF_UNIX",        AF_UNIX);
#endif
        BIND_CI("AF_INET",        AF_INET);
        BIND_CI("AF_INET6",       AF_INET6);

        BIND_CM("gethostname",    _gethostname);
        BIND_CM("inet_aton",      _inet_aton);
        BIND_CM("inet_ntoa",      _inet_ntoa);

        BIND_IM("bind",           _bind);
        BIND_IM("listen",         _listen);
        BIND_IM("accept",         _accept);
        BIND_IM("connect",        _connect);
        BIND_IM("recv",           _recv);
        BIND_IM("recvfrom",       _recvfrom);
        BIND_IM("send",           _send);
        BIND_IM("sendto",         _sendto);
        BIND_IM("getsockname",    _getsockname);
        BIND_IM("getpeername",    _getpeername);
        BIND_IM("fileno",         _fileno);
        BIND_IM("close",          _close);
        // rest function is: 29
        // getaddrinfo
        // getfqdn
        // gethostbyname
        // gethostbyaddr
        // getnameinfo
        // getprotobyname
        // getservbyname
        // getservbyport
        // socketpair
        // fromfd
        // ntohl
        // ntohs
        // htonl
        // htons
        // inet_pton
        // inet_ntop
        // getdefaulttimeout
        // setdefaulttimeout
        // getsockopt
        // ioctl
        // makefile
        // recvfrom_into
        // recv_into
        // sendall
        // setblocking
        // settimeout
        // gettimeout
        // setsockopt
        // shutdown

        INTERNALCOUNT(1);

        EXPORT_CLASS("Socket");
    }
ENDMODULE