Commit 49e53bca authored by Tomoyuki Sahara's avatar Tomoyuki Sahara

Socket library for mruby.

parents
MRuby::Gem::Specification.new('mruby-socket') do |spec|
spec.license = 'MIT'
spec.authors = 'Internet Initiative Japan'
end
class Addrinfo
def initialize(sockaddr, family=Socket::PF_UNSPEC, socktype=0, protocol=0)
@hostname = nil
if sockaddr.is_a? Array
sary = sockaddr
if sary[0] == 'AF_INET' || sary[0] == 'AF_INET6'
@sockaddr = Socket.sockaddr_in(sary[1], sary[3])
@hostname = sary[2]
elsif sary[0] == 'AF_UNIX'
@sockaddr = Socket.sockaddr_un(sary[1])
end
else
@sockaddr = sockaddr.dup
end
if family == Socket::PF_UNSPEC or family == nil
@family = Socket._sockaddr_family(@sockaddr)
else
@family = family
end
@socktype = socktype
@protocol = protocol
@canonname = nil
end
def self.foreach(nodename, service, family=nil, socktype=nil, protocol=nil, flags=0, &block)
a = self.getaddrinfo(nodename, service, family, socktype, protocol, flags)
a.each { |ai| block.call(ai) }
a
end
def self.ip(host)
Addrinfo.new(Socket.sockaddr_in(0, host))
end
def self.tcp(host, port)
Addrinfo.new(Socket.sockaddr_in(port, host), nil, Socket::SOCK_STREAM, Socket::IPPROTO_TCP)
end
def self.udp(host, port)
Addrinfo.new(Socket.sockaddr_in(port, host), nil, Socket::SOCK_DGRAM, Socket::IPPROTO_UDP)
end
def self.unix(path, socktype=Socket::SOCK_STREAM)
Addrinfo.new(Socket.sockaddr_un(path), Socket::AF_UNIX, socktype)
end
def afamily
@family
end
#def bind
attr_reader :canonname
#def connect
#def connect_from
#def connect_to
#def family_addrinfo(host, port=nil)
#def getnameinfo(flags=0)
# Socket.getnameinfo
#end
def inspect
if ipv4? or ipv6?
if @protocol == Socket::IPPROTO_TCP
proto = 'TCP'
elsif @protocol == Socket::IPPROTO_UDP
proto = 'UDP'
else
proto = '???'
end
# how can we get the last part?
"#<Addrinfo: #{inspect_sockaddr} #{proto}>"
else
"#<Addrinfo: #{self.unix_path} SOCK_STREAM>"
end
end
def inspect_sockaddr
if ipv4?
a, p = ip_unpack
"#{a}:#{p}"
elsif ipv6?
a, p = ip_unpack
"[#{a}]:#{p}"
elsif unix?
unix_path
else
'???'
end
end
def ip?
ipv4? or ipv6?
end
def ip_address
ip_unpack[0]
end
def ip_port
ip_unpack[1]
end
def ip_unpack
h, p = getnameinfo(Socket::NI_NUMERICHOST|Socket::NI_NUMERICSERV)
[ h, p.to_i ]
end
def ipv4?
@family == Socket::AF_INET
end
#def ipv4_loopback?
#def ipv4_multicast?
#def ipv4_private?
def ipv6?
@family == Socket::AF_INET6
end
#def ipv6_loopback?
#def ipv6_mc_global?
#def ipv6_mc_linklocal?
#def ipv6_mc_nodelocal?
#def ipv6_mc_orilocal?
#def ipv6_mc_sitelocal?
#def ipv6_multicast?
#def ipv6_to_ipv4
#def ipv6_unspecified
#def ipv6_v4compat?
#def ipv6_v4mapped?
#def listen(backlog=5)
def pfamily
@family
end
attr_reader :protocol
attr_reader :socktype
def to_sockaddr
@sockaddr
end
alias to_s to_sockaddr
def unix?
@family == Socket::AF_UNIX
end
end
class BasicSocket
@@do_not_reverse_lookup = true
def self.do_not_reverse_lookup
@@do_not_reverse_lookup
end
def self.do_not_reverse_lookup=(val)
@@do_not_reverse_lookup = val ? true : false
end
def initialize(*args)
super(*args)
@do_not_reverse_lookup = @@do_not_reverse_lookup
end
#def connect_address
def local_address
Addrinfo.new self.getsockname
end
def recv_nonblock(maxlen, flags=0)
begin
_setnonblock(true)
recv(maxlen, flags)
ensure
_setnonblock(false)
end
end
def remote_address
Addrinfo.new self.getpeername
end
attr_accessor :do_not_reverse_lookup
end
class IPSocket
def self.getddress(host)
Addrinfo.ip(host).ip_address
end
def _ai_to_array(ai)
case ai.afamily
when Socket::AF_INET
s = "AF_INET"
when Socket::AF_INET6
s = "AF_INET6"
when Socket::AF_UNIX
s = "AF_UNIX"
else
s = "(unknown AF)"
end
[ s, ai.ip_port, ai.ip_address, ai.ip_address ]
end
def addr
_ai_to_array(Addrinfo.new(self.getsockname))
end
def peeraddr
_ai_to_array(Addrinfo.new(self.getpeername))
end
def recvfrom(maxlen, flags=0)
msg, sa = _recvfrom(maxlen, flags)
[ msg, _ai_to_array(Addrinfo.new(sa)) ]
end
end
class TCPSocket
def initialize(host, service, local_host=nil, local_service=nil)
self._bless
if self.is_a? TCPServer
super(host, service)
else
ai = Addrinfo.getaddrinfo(host, service)[0]
super(Socket._socket(ai.afamily, Socket::SOCK_STREAM, 0), "r+")
# XXX: bind(2)
Socket._connect(self.fileno, ai.to_sockaddr)
self
end
end
#def self.gethostbyname(host)
end
class TCPServer
def initialize(host=nil, service)
self._bless
ai = Addrinfo.getaddrinfo(host, service, nil, nil, nil, Socket::AI_PASSIVE)[0]
super(Socket._socket(ai.afamily, Socket::SOCK_STREAM, 0), "r+")
Socket._bind(self.fileno, ai.to_sockaddr)
listen(5)
self
end
def accept
TCPSocket.for_fd(self.sysaccept)
end
def accept_nonblock
begin
self._setnonblock(true)
self.accept
ensure
self._setnonblock(false)
end
end
def listen(backlog)
Socket._listen(self.fileno, backlog)
0
end
def sysaccept
Socket._accept(self.fileno)[0]
end
end
class UDPSocket
def initialize(af=Socket::AF_INET)
self._bless
super(Socket._socket(af, Socket::SOCK_DGRAM, 0), "r+")
self
end
def bind(host, port)
Socket._bind(self.fileno, Socket.sockaddr_in(port, host))
0
end
def connect(host, port)
Socket._connect(self.fileno, Socket.sockaddr_in(port, host))
0
end
def recvfrom_nonblock(*args)
s = self
begin
self._setnonblock(true)
self.recvfrom(*args)
ensure
# XXX: self is a SystemcallException here! (should be bug)
s._setnonblock(false)
end
end
def send(mesg, flags, host=nil, port=nil)
if port
super(mesg, flags, Socket.sockaddr_in(port, host))
elsif host
super(mesg, flags, host)
else
super(mesg, flags)
end
end
end
class Socket
def initialize(domain, type, protocol=0)
self._bless
super(Socket._socket(domain, type, protocol), "r+")
end
#def self.accept_loop
# def self.getaddrinfo
# by Addrinfo.getaddrinfo
#end
#def self.getnameinfo
#def self.ip_address_list
def self.open(*args)
new(args)
end
def self.sockaddr_in(port, host)
ai = Addrinfo.getaddrinfo(host, port)[0]
ai.to_sockaddr
end
#def self.tcp
#def self.tcp_server_loop
#def self.tcp_server_sockets
#def self.udp_server_loop
#def self.udp_server_loop_on
#def self.udp_server_recv
#def self.udp_server_sockets
#def self.unix(path)
#def self.unix_server_loop
#def self.unix_server_socket
def self.unpack_sockaddr_in(sa)
Addrinfo.new(sa).ip_unpack.reverse
end
def self.unpack_sockaddr_un(sa)
Addrinfo.new(sa).unix_path
end
class << self
alias pack_sockaddr_in sockaddr_in
alias pack_sockaddr_un sockaddr_un
alias pair socketpair
end
def accept
fd, addr = self.sysaccept
[ Socket.for_fd(fd), addr ]
end
def accept_nonblock
begin
self._setnonblock(true)
self.accept
ensure
self._setnonblock(false)
end
end
def bind(sockaddr)
sockaddr = sockaddr.to_sockaddr if sockaddr.is_a? Addrinfo
Socket._bind(self.fileno, sockaddr)
0
end
def connect(sockaddr)
sockaddr = sockaddr.to_sockaddr if sockaddr.is_a? Addrinfo
Socket._bind(self.fileno, sockaddr)
0
end
def connect_nonblock(sockaddr)
begin
self._setnonblock(true)
self.connect(sockaddr)
ensure
self._setnonblock(false)
end
end
#def ipv6only!
def listen(backlog)
Socket._listen(self.fileno, backlog)
0
end
def recvfrom(maxlen, flags=0)
msg, sa = _recvfrom(maxlen, flags)
[ msg, _ai_to_array(Addrinfo.new(sa)) ]
end
def recvfrom_nonblock(*args)
begin
self._setnonblock(true)
self._recvfrom(*args)
ensure
self._setnonblock(false)
end
end
def sysaccept
Socket._accept(self.fileno)[0]
end
end
class UNIXSocket
def initialize(path, &block)
self._bless
super(Socket._socket(AF_UNIX, SOCK_STREAM, 0), "r+")
Socket._connect(self.fileno, Socket.sockaddr_un(path))
if block
block.call(self)
else
self
end
end
def self.socketpair(type=Socket::SOCK_STREAM, protocol=0)
a = Socket.socketpair(Socket::AF_UNIX, type, protocol)
[ UNIXSocket.for_fd(a[0]), UNIXSocket.for_fd(a[1]) ]
end
class << self
alias pair socketpair
end
def addr
[ "AF_UNIX", path ]
end
def path
Addrinfo.new(self.getsockname).unix_path
end
def peeraddr
[ "AF_UNIX", Addrinfo.new(self.getpeername).unix_path ]
end
#def recv_io
def recvfrom(maxlen, flags=0)
msg, sa = _recvfrom(maxlen, flags)
[ msg, [ "AF_UNIX", Addrinfo.new(sa).unix_path ] ]
end
#def send_io
end
class UNIXServer
def initialize(path, &block)
self._bless
super(Socket._socket(Socket::AF_UNIX, Socket::SOCK_STREAM, 0), "r")
Socket._bind(self.fileno, Socket.pack_sockaddr_un(path))
listen(5)
self
end
def accept
fd, addr = self.sysaccept
[ UNIXSocket.for_fd(fd), addr ]
end
def accept_nonblock
begin
self._setnonblock(true)
self.accept
ensure
self._setnonblock(false)
end
end
def listen(backlog)
Socket._listen(self.fileno, backlog)
0
end
def sysaccept
Socket._accept(self.fileno)[0]
end
end
class Socket
include Constants
end
class Socket
class Option
def initialize(family, level, optname, data)
@family = family
@level = level
@optname = optname
@data = data
end
def self.bool(family, level, optname, bool)
self.new(family, level, optname, [(bool ? 1 : 0)].pack('i'))
end
def self.int(family, level, optname, integer)
self.new(family, level, optname, [integer].pack('i'))
end
#def self.linger(family, level, optname, integer)
#end
attr_reader :data, :family, :level, :optname
def bool
@data.unpack('i')[0] != 0
end
def inspect
# notyet
end
def int
@data.unpack('i')[0]
end
def linger
raise NotImplementedError.new
end
def unpack(template)
raise NotImplementedError.new
end
end
end
class SocketError < StandardError; end
#ifdef AF_INET
define_const(AF_INET);
#endif
#ifdef PF_INET
define_const(PF_INET);
#endif
#ifdef AF_INET6
define_const(AF_INET6);
#endif
#ifdef PF_INET6
define_const(PF_INET6);
#endif
#ifdef AF_LINK
define_const(AF_LINK);
#endif
#ifdef PF_LINK
define_const(PF_LINK);
#endif
#ifdef AF_LOCAL
define_const(AF_LOCAL);
#endif
#ifdef PF_LOCAL
define_const(PF_LOCAL);
#endif
#ifdef AF_UNIX
define_const(AF_UNIX);
#endif
#ifdef PF_UNIX
define_const(PF_UNIX);
#endif
#ifdef AF_MAX
define_const(AF_MAX);
#endif
#ifdef AF_UNSPEC
define_const(AF_UNSPEC);
#endif
#ifdef PF_UNSPEC
define_const(PF_UNSPEC);
#endif
#ifdef AF_ROUTE
define_const(AF_ROUTE);
#endif
#ifdef PF_ROUTE
define_const(PF_ROUTE);
#endif
#ifdef AI_CANONNAME
define_const(AI_CANONNAME);
#endif
#ifdef AI_FQDN
define_const(AI_FQDN);
#endif
#ifdef AI_NUMERICHOST
define_const(AI_NUMERICHOST);
#endif
#ifdef AI_NUMERICSERV
define_const(AI_NUMERICSERV);
#endif
#ifdef AI_PASSIVE
define_const(AI_PASSIVE);
#endif
#ifdef IPPROTO_ICMP
define_const(IPPROTO_ICMP);
#endif
#ifdef IPPROTO_IP
define_const(IPPROTO_IP);
#endif
#ifdef IPPROTO_IPV6
define_const(IPPROTO_IPV6);
#endif
#ifdef IPPROTO_RAW
define_const(IPPROTO_RAW);
#endif
#ifdef IPPROTO_TCP
define_const(IPPROTO_TCP);
#endif
#ifdef IPPROTO_UDP
define_const(IPPROTO_UDP);
#endif
#ifdef MSG_BCAST
define_const(MSG_BCAST);
#endif
#ifdef MSG_CTRUNC
define_const(MSG_CTRUNC);
#endif
#ifdef MSG_DONTROUTE
define_const(MSG_DONTROUTE);
#endif
#ifdef MSG_DONTWAIT
define_const(MSG_DONTWAIT);
#endif
#ifdef MSG_EOR
define_const(MSG_EOR);
#endif
#ifdef MSG_MCAST
define_const(MSG_MCAST);
#endif
#ifdef MSG_NOSIGNAL
define_const(MSG_NOSIGNAL);
#endif
#ifdef MSG_OOB
define_const(MSG_OOB);
#endif
#ifdef MSG_PEEK
define_const(MSG_PEEK);
#endif
#ifdef MSG_TRUNC
define_const(MSG_TRUNC);
#endif
#ifdef MSG_WAITALL
define_const(MSG_WAITALL);
#endif
#ifdef NI_DGRAM
define_const(NI_DGRAM);
#endif
#ifdef NI_MAXHOST
define_const(NI_MAXHOST);
#endif
#ifdef NI_MAXSERV
define_const(NI_MAXSERV);
#endif
#ifdef NI_NAMEREQD
define_const(NI_NAMEREQD);
#endif
#ifdef NI_NOFQDN
define_const(NI_NOFQDN);
#endif
#ifdef NI_NUMERICHOST
define_const(NI_NUMERICHOST);
#endif
#ifdef NI_NUMERICSERV
define_const(NI_NUMERICSERV);
#endif
#ifdef SHUT_RD
define_const(SHUT_RD);
#endif
#ifdef SHUT_WR
define_const(SHUT_WR);
#endif
#ifdef SHUT_RDWR
define_const(SHUT_RDWR);
#endif
#ifdef SO_BINDANY
define_const(SO_BINDANY);
#endif
#ifdef SO_BROADCAST
define_const(SO_BROADCAST);
#endif
#ifdef SO_DEBUG
define_const(SO_DEBUG);
#endif
#ifdef SO_DONTROUTE
define_const(SO_DONTROUTE);
#endif
#ifdef SO_ERROR
define_const(SO_ERROR);
#endif
#ifdef SO_KEEPALIVE
define_const(SO_KEEPALIVE);
#endif
#ifdef SO_LINGER
define_const(SO_LINGER);
#endif
#ifdef SO_OOBINLINE
define_const(SO_OOBINLINE);
#endif
#ifdef SO_PEERCRED
define_const(SO_PEERCRED);
#endif
#ifdef SO_RCVBUF
define_const(SO_RCVBUF);
#endif
#ifdef SO_RCVLOWAT
define_const(SO_RCVLOWAT);
#endif
#ifdef SO_RCVTIMEO
define_const(SO_RCVTIMEO);
#endif
#ifdef SO_REUSEADDR
define_const(SO_REUSEADDR);
#endif
#ifdef SO_REUSEPORT
define_const(SO_REUSEPORT);
#endif
#ifdef SO_RTABLE
define_const(SO_RTABLE);
#endif
#ifdef SO_SNDBUF
define_const(SO_SNDBUF);
#endif
#ifdef SO_SNDLOWAT
define_const(SO_SNDLOWAT);
#endif
#ifdef SO_SNDTIMEO
define_const(SO_SNDTIMEO);
#endif
#ifdef SO_SPLICE
define_const(SO_SPLICE);
#endif
#ifdef SO_TIMESTAMP
define_const(SO_TIMESTAMP);
#endif
#ifdef SO_TYPE
define_const(SO_TYPE);
#endif
#ifdef SOCK_DGRAM
define_const(SOCK_DGRAM);
#endif
#ifdef SOCK_RAW
define_const(SOCK_RAW);
#endif
#ifdef SOCK_SEQPACKET
define_const(SOCK_SEQPACKET);
#endif
#ifdef SOCK_STREAM
define_const(SOCK_STREAM);
#endif
#ifdef SOL_SOCKET
define_const(SOL_SOCKET);
#endif
AF_INET
PF_INET
AF_INET6
PF_INET6
AF_LINK
PF_LINK
AF_LOCAL
PF_LOCAL
AF_UNIX
PF_UNIX
AF_MAX
AF_UNSPEC
PF_UNSPEC
AF_ROUTE
PF_ROUTE
AI_CANONNAME
AI_FQDN
AI_NUMERICHOST
AI_NUMERICSERV
AI_PASSIVE
IPPROTO_ICMP
IPPROTO_IP
IPPROTO_IPV6
IPPROTO_RAW
IPPROTO_TCP
IPPROTO_UDP
MSG_BCAST
MSG_CTRUNC
MSG_DONTROUTE
MSG_DONTWAIT
MSG_EOR
MSG_MCAST
MSG_NOSIGNAL
MSG_OOB
MSG_PEEK
MSG_TRUNC
MSG_WAITALL
NI_DGRAM
NI_MAXHOST
NI_MAXSERV
NI_NAMEREQD
NI_NOFQDN
NI_NUMERICHOST
NI_NUMERICSERV
SHUT_RD
SHUT_WR
SHUT_RDWR
SO_BINDANY
SO_BROADCAST
SO_DEBUG
SO_DONTROUTE
SO_ERROR
SO_KEEPALIVE
SO_LINGER
SO_OOBINLINE
SO_PEERCRED
SO_RCVBUF
SO_RCVLOWAT
SO_RCVTIMEO
SO_REUSEADDR
SO_REUSEPORT
SO_RTABLE
SO_SNDBUF
SO_SNDLOWAT
SO_SNDTIMEO
SO_SPLICE
SO_TIMESTAMP
SO_TYPE
SOCK_DGRAM
SOCK_RAW
SOCK_SEQPACKET
SOCK_STREAM
SOL_SOCKET
#!/usr/bin/env ruby
Dir.chdir(File.dirname($0))
f = File.open("const.cstub", "w")
IO.readlines("const.def").each { |name|
name.sub(/^#.*/, "")
name.strip!
next if name.empty?
f.write <<CODE
#ifdef #{name}
define_const(#{name});
#endif
CODE
}
/*
** socket.c - Socket module
**
** See Copyright Notice in mruby.h
*/
#include "mruby.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <netdb.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
#include "mruby/array.h"
#include "mruby/class.h"
#include "mruby/data.h"
#include "mruby/string.h"
#include "mruby/variable.h"
#include "mruby/ext/io.h"
#define E_SOCKET_ERROR (mrb_class_get(mrb, "SocketError"))
static mrb_value
mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass)
{
struct addrinfo hints, *res0, *res;
struct sockaddr_un sun;
mrb_value ai, ary, family, lastai, nodename, protocol, s, sa, service, socktype;
mrb_int flags;
int arena_idx, error;
const char *hostname = NULL, *servname = NULL;
ary = mrb_ary_new(mrb);
arena_idx = mrb_gc_arena_save(mrb); /* ary must be on arena! */
s = mrb_str_new(mrb, (void *)&sun, sizeof(sun));
family = socktype = protocol = mrb_nil_value();
flags = 0;
mrb_get_args(mrb, "oo|oooi", &nodename, &service, &family, &socktype, &protocol, &flags);
if (mrb_string_p(nodename)) {
hostname = mrb_str_to_cstr(mrb, nodename);
} else if (mrb_nil_p(nodename)) {
hostname = NULL;
} else {
mrb_raise(mrb, E_TYPE_ERROR, "nodename must be String or nil");
}
if (mrb_string_p(service)) {
servname = mrb_str_to_cstr(mrb, service);
} else if (mrb_fixnum_p(service)) {
servname = mrb_str_to_cstr(mrb, mrb_funcall(mrb, service, "to_s", 0));
} else if (mrb_nil_p(nodename)) {
servname = NULL;
} else {
mrb_raise(mrb, E_TYPE_ERROR, "service must be String, Fixnum, or nil");
}
memset(&hints, 0, sizeof(hints));
hints.ai_flags = flags;
if (mrb_fixnum_p(family)) {
hints.ai_family = mrb_fixnum(family);
}
if (mrb_fixnum_p(socktype)) {
hints.ai_socktype = mrb_fixnum(socktype);
}
lastai = mrb_cv_get(mrb, klass, mrb_intern_cstr(mrb, "_lastai"));
if (mrb_voidp_p(ai)) {
freeaddrinfo(mrb_voidp(ai));
mrb_cv_set(mrb, klass, mrb_intern_cstr(mrb, "_lastai"), mrb_nil_value());
}
error = getaddrinfo(hostname, servname, &hints, &res0);
if (error) {
mrb_raisef(mrb, E_SOCKET_ERROR, "getaddrinfo: %S", mrb_str_new_cstr(mrb, gai_strerror(error)));
}
mrb_cv_set(mrb, klass, mrb_intern_cstr(mrb, "_lastai"), mrb_voidp_value(res0));
for (res = res0; res != NULL; res = res->ai_next) {
sa = mrb_str_new(mrb, (void *)res->ai_addr, res->ai_addrlen);
ai = mrb_funcall(mrb, klass, "new", 4, sa, mrb_fixnum_value(res->ai_family), mrb_fixnum_value(res->ai_socktype), mrb_fixnum_value(res->ai_protocol));
mrb_ary_push(mrb, ary, ai);
mrb_gc_arena_restore(mrb, arena_idx);
}
freeaddrinfo(res0);
mrb_cv_set(mrb, klass, mrb_intern_cstr(mrb, "_lastai"), mrb_nil_value());
return ary;
}
static mrb_value
mrb_addrinfo_getnameinfo(mrb_state *mrb, mrb_value self)
{
mrb_int flags;
mrb_value ary, host, sastr, serv;
int error;
flags = 0;
mrb_get_args(mrb, "|i", &flags);
host = mrb_str_buf_new(mrb, NI_MAXHOST);
serv = mrb_str_buf_new(mrb, NI_MAXSERV);
sastr = mrb_iv_get(mrb, self, mrb_intern(mrb, "@sockaddr"));
if (!mrb_string_p(sastr)) {
mrb_raise(mrb, E_SOCKET_ERROR, "invalid sockaddr");
}
error = getnameinfo((struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr), RSTRING_PTR(host), NI_MAXHOST, RSTRING_PTR(serv), NI_MAXSERV, flags);
if (error != 0) {
mrb_raisef(mrb, E_SOCKET_ERROR, "getnameinfo: %s", gai_strerror(error));
}
ary = mrb_ary_new_capa(mrb, 2);
mrb_str_resize(mrb, host, strlen(RSTRING_PTR(host)));
mrb_ary_push(mrb, ary, host);
mrb_str_resize(mrb, serv, strlen(RSTRING_PTR(serv)));
mrb_ary_push(mrb, ary, serv);
return ary;
}
static mrb_value
mrb_addrinfo_unix_path(mrb_state *mrb, mrb_value self)
{
mrb_value sastr;
sastr = mrb_iv_get(mrb, self, mrb_intern(mrb, "@sockaddr"));
if (((struct sockaddr *)RSTRING_PTR(sastr))->sa_family != AF_UNIX)
mrb_raise(mrb, E_SOCKET_ERROR, "need AF_UNIX address");
return mrb_str_new_cstr(mrb, ((struct sockaddr_un *)RSTRING_PTR(sastr))->sun_path);
}
static mrb_value
sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen)
{
mrb_value ary, host;
unsigned short port;
const char *afstr;
switch (sa->sa_family) {
case AF_INET:
afstr = "AF_INET";
port = ((struct sockaddr_in *)sa)->sin_port;
break;
case AF_INET6:
afstr = "AF_INET6";
port = ((struct sockaddr_in6 *)sa)->sin6_port;
break;
default:
mrb_raise(mrb, E_ARGUMENT_ERROR, "bad af");
return mrb_nil_value();
}
port = ntohs(port);
host = mrb_str_buf_new(mrb, NI_MAXHOST);
if (getnameinfo(sa, salen, RSTRING_PTR(host), NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == -1)
mrb_sys_fail(mrb, "getnameinfo");
mrb_str_resize(mrb, host, strlen(RSTRING_PTR(host)));
ary = mrb_ary_new_capa(mrb, 4);
mrb_ary_push(mrb, ary, mrb_str_new_cstr(mrb, afstr));
mrb_ary_push(mrb, ary, mrb_fixnum_value(port));
mrb_ary_push(mrb, ary, host);
mrb_ary_push(mrb, ary, host);
return ary;
}
static int
socket_fd(mrb_state *mrb, mrb_value sock)
{
return mrb_fixnum(mrb_funcall(mrb, sock, "fileno", 0));
}
static int
socket_family(int s)
{
struct sockaddr_storage ss;
socklen_t salen;
salen = sizeof(ss);
if (getsockname(s, (struct sockaddr *)&ss, &salen) == -1)
return AF_UNSPEC;
return ss.ss_family;
}
static mrb_value
mrb_basicsocket_getpeereid(mrb_state *mrb, mrb_value self)
{
mrb_value ary;
gid_t egid;
uid_t euid;
int s;
s = socket_fd(mrb, self);
if (getpeereid(s, &euid, &egid) != 0)
mrb_sys_fail(mrb, "getpeereid");
ary = mrb_ary_new_capa(mrb, 2);
mrb_ary_push(mrb, ary, mrb_fixnum_value((mrb_int)euid));
mrb_ary_push(mrb, ary, mrb_fixnum_value((mrb_int)egid));
return ary;
}
static mrb_value
mrb_basicsocket_getpeername(mrb_state *mrb, mrb_value self)
{
struct sockaddr_storage ss;
socklen_t salen;
salen = sizeof(ss);
if (getpeername(socket_fd(mrb, self), (struct sockaddr *)&ss, &salen) != 0)
mrb_sys_fail(mrb, "getpeername");
return mrb_str_new(mrb, (void *)&ss, salen);
}
static mrb_value
mrb_basicsocket_getsockname(mrb_state *mrb, mrb_value self)
{
struct sockaddr_storage ss;
socklen_t salen;
salen = sizeof(ss);
if (getsockname(socket_fd(mrb, self), (struct sockaddr *)&ss, &salen) != 0)
mrb_sys_fail(mrb, "getsockname");
return mrb_str_new(mrb, (void *)&ss, salen);
}
static mrb_value
mrb_basicsocket_getsockopt(mrb_state *mrb, mrb_value self)
{
int opt, s;
mrb_int family, level, optname;
mrb_value c, data;
socklen_t optlen;
mrb_get_args(mrb, "ii", &level, &optname);
s = socket_fd(mrb, self);
optlen = sizeof(opt);
if (getsockopt(s, level, optname, &opt, &optlen) == -1)
mrb_sys_fail(mrb, "getsockopt");
c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get(mrb, "Socket")), mrb_intern(mrb, "Option"));
family = socket_family(s);
data = mrb_str_new(mrb, (char *)&opt, sizeof(int));
return mrb_funcall(mrb, c, "new", 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data);
}
static mrb_value
mrb_basicsocket_recv(mrb_state *mrb, mrb_value self)
{
int n;
mrb_int maxlen, flags = 0;
mrb_value buf;
mrb_get_args(mrb, "i|i", &maxlen, &flags);
buf = mrb_str_buf_new(mrb, maxlen);
n = recv(socket_fd(mrb, self), RSTRING_PTR(buf), maxlen, flags);
if (n == -1)
mrb_sys_fail(mrb, "recv");
mrb_str_resize(mrb, buf, n);
return buf;
}
static mrb_value
mrb_basicsocket_recvfrom(mrb_state *mrb, mrb_value self)
{
int n;
mrb_int maxlen, flags = 0;
mrb_value ary, buf, sa;
socklen_t socklen;
mrb_get_args(mrb, "i|i", &maxlen, &flags);
buf = mrb_str_buf_new(mrb, maxlen);
socklen = sizeof(struct sockaddr_storage);
sa = mrb_str_buf_new(mrb, socklen);
n = recvfrom(socket_fd(mrb, self), RSTRING_PTR(buf), maxlen, flags, (struct sockaddr *)RSTRING_PTR(sa), &socklen);
if (n == -1)
mrb_sys_fail(mrb, "recvfrom");
mrb_str_resize(mrb, buf, n);
mrb_str_resize(mrb, sa, socklen);
ary = mrb_ary_new_capa(mrb, 2);
mrb_ary_push(mrb, ary, buf);
mrb_ary_push(mrb, ary, sa);
return ary;
}
static mrb_value
mrb_basicsocket_send(mrb_state *mrb, mrb_value self)
{
int n;
mrb_int flags;
mrb_value dest, mesg;
dest = mrb_nil_value();
mrb_get_args(mrb, "Si|S", &mesg, &flags, &dest);
if (mrb_nil_p(dest)) {
n = send(socket_fd(mrb, self), RSTRING_PTR(mesg), RSTRING_LEN(mesg), flags);
} else {
// XXX: length check
n = sendto(socket_fd(mrb, self), RSTRING_PTR(mesg), RSTRING_LEN(mesg), flags, (const void *)RSTRING_PTR(dest), RSTRING_LEN(dest));
}
if (n == -1)
mrb_sys_fail(mrb, "send");
return mrb_fixnum_value(n);
}
static mrb_value
mrb_basicsocket_setnonblock(mrb_state *mrb, mrb_value self)
{
int fd, flags;
mrb_value bool;
mrb_get_args(mrb, "o", &bool);
fd = socket_fd(mrb, self);
flags = fcntl(fd, F_GETFL, 0);
if (flags == 1)
mrb_sys_fail(mrb, "fcntl");
if (mrb_test(bool))
flags |= O_NONBLOCK;
else
flags &= ~O_NONBLOCK;
if (fcntl(fd, F_SETFL, flags) == -1)
mrb_sys_fail(mrb, "fcntl");
return mrb_nil_value();
}
static mrb_value
mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
{
int argc, s;
mrb_int level = 0, optname;
mrb_value optval, so;
argc = mrb_get_args(mrb, "o|io", &so, &optname, &optval);
if (argc == 3) {
if (!mrb_fixnum_p(so)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "level is not an integer");
}
level = mrb_fixnum(so);
if (mrb_string_p(optval)) {
/* that's good */
} else if (mrb_type(optval) == MRB_TT_TRUE || mrb_type(optval) == MRB_TT_FALSE) {
mrb_int i = mrb_test(optval) ? 1 : 0;
optval = mrb_str_new(mrb, (char *)&i, sizeof(i));
} else if (mrb_fixnum_p(optval)) {
mrb_int i = mrb_fixnum(optval);
optval = mrb_str_new(mrb, (char *)&i, sizeof(i));
} else {
mrb_raise(mrb, E_ARGUMENT_ERROR, "optval should be true, false, an integer, or a string");
}
} else if (argc == 1) {
if (strcmp(mrb_obj_classname(mrb, so), "Socket::Option") != 0)
mrb_raisef(mrb, E_ARGUMENT_ERROR, "not an instance of Socket::Option");
level = mrb_fixnum(mrb_funcall(mrb, so, "level", 0));
optname = mrb_fixnum(mrb_funcall(mrb, so, "optname", 0));
optval = mrb_funcall(mrb, so, "data", 0);
} else {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 3)", argc);
}
s = socket_fd(mrb, self);
if (setsockopt(s, level, optname, RSTRING_PTR(optval), RSTRING_LEN(optval)) == -1)
mrb_sys_fail(mrb, "setsockopt");
return mrb_fixnum_value(0);
}
static mrb_value
mrb_basicsocket_shutdown(mrb_state *mrb, mrb_value self)
{
mrb_int how = SHUT_RDWR;
mrb_get_args(mrb, "|i", &how);
if (shutdown(socket_fd(mrb, self), how) != 0)
mrb_sys_fail(mrb, "shutdown");
return mrb_fixnum_value(0);
}
static mrb_value
mrb_ipsocket_ntop(mrb_state *mrb, mrb_value klass)
{
mrb_int af, n;
char *addr, buf[50];
mrb_get_args(mrb, "is", &af, &addr, &n);
if ((af == AF_INET && n != 4) || (af == AF_INET6 && n != 16))
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid address");
if (inet_ntop(af, addr, buf, sizeof(buf)) == NULL)
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid address");
return mrb_str_new_cstr(mrb, buf);
}
static mrb_value
mrb_ipsocket_pton(mrb_state *mrb, mrb_value klass)
{
mrb_int af, n;
char *bp, buf[50];
mrb_get_args(mrb, "is", &af, &bp, &n);
if (n > sizeof(buf) - 1)
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid address");
memcpy(buf, bp, n);
buf[n] = '\0';
if (af == AF_INET) {
struct in_addr in;
if (inet_pton(AF_INET, buf, (void *)&in.s_addr) != 1)
goto invalid;
return mrb_str_new(mrb, (char *)&in.s_addr, 4);
} else if (af == AF_INET6) {
struct in6_addr in6;
if (inet_pton(AF_INET6, buf, (void *)&in6.s6_addr) != 1)
goto invalid;
return mrb_str_new(mrb, (char *)&in6.s6_addr, 16);
} else
mrb_raise(mrb, E_ARGUMENT_ERROR, "unsupported address family");
invalid:
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid address");
return mrb_nil_value(); /* dummy */
}
static mrb_value
mrb_ipsocket_recvfrom(mrb_state *mrb, mrb_value self)
{
struct sockaddr_storage ss;
socklen_t socklen;
mrb_value a, buf, pair;
mrb_int flags, maxlen, n;
int fd;
fd = socket_fd(mrb, self);
flags = 0;
mrb_get_args(mrb, "i|i", &maxlen, &flags);
buf = mrb_str_buf_new(mrb, maxlen);
socklen = sizeof(ss);
n = recvfrom(fd, RSTRING_PTR(buf), maxlen, flags,
(struct sockaddr *)&ss, &socklen);
if (n == -1) {
mrb_sys_fail(mrb, "recvfrom");
}
mrb_str_resize(mrb, buf, n);
a = sa2addrlist(mrb, (struct sockaddr *)&ss, socklen);
pair = mrb_ary_new_capa(mrb, 2);
mrb_ary_push(mrb, pair, buf);
mrb_ary_push(mrb, pair, a);
return pair;
}
static mrb_value
mrb_udpsocket_bind(mrb_state *mrb, mrb_value self)
{
struct addrinfo hints, *res;
mrb_int n, port;
int error, s;
char *host, hostbuf[256], portbuf[6];
s = socket_fd(mrb, self);
mrb_get_args(mrb, "si", &host, &n, &port);
if (n > sizeof(hostbuf) - 1) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "host is too long");
}
memcpy(hostbuf, host, n);
hostbuf[n] = '\0';
memset(&hints, 0, sizeof(hints));
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = AI_NUMERICSERV|AI_PASSIVE;
snprintf(portbuf, sizeof(portbuf), "%d", port);
error = getaddrinfo(hostbuf, portbuf, &hints, &res);
if (error != 0)
mrb_raise(mrb, E_RUNTIME_ERROR, "getaddrinfo(2) failed");
if (bind(s, res->ai_addr, res->ai_addrlen) == -1) {
freeaddrinfo(res);
mrb_raise(mrb, E_RUNTIME_ERROR, "bind(2) failed");
}
freeaddrinfo(res);
return mrb_fixnum_value(0);
}
static mrb_value
mrb_udpsocket_connect(mrb_state *mrb, mrb_value self)
{
struct addrinfo hints, *res;
mrb_int n, port;
int error, s;
char *host, hostbuf[256], portbuf[6];
mrb_get_args(mrb, "si", &host, &n, &port);
s = socket_fd(mrb, self);
if (n > sizeof(hostbuf) - 1) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "host is too long");
}
memcpy(hostbuf, host, n);
hostbuf[n] = '\0';
memset(&hints, 0, sizeof(hints));
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = AI_NUMERICSERV;
snprintf(portbuf, sizeof(portbuf), "%d", port);
error = getaddrinfo(hostbuf, portbuf, &hints, &res);
if (error != 0)
mrb_raise(mrb, E_RUNTIME_ERROR, "getaddrinfo(2) failed");
if (connect(s, res->ai_addr, res->ai_addrlen) == -1) {
freeaddrinfo(res);
mrb_raise(mrb, E_RUNTIME_ERROR, "connect(2) failed");
}
freeaddrinfo(res);
return mrb_fixnum_value(0);
}
static mrb_value
mrb_udpsocket_send(mrb_state *mrb, mrb_value self)
{
struct addrinfo hints, *res;
mrb_int n, flags;
mrb_value host, port;
int argc, hlen, s;
char hostbuf[256], *msg, portbuf[6];
argc = mrb_get_args(mrb, "si|oo", &msg, &hlen, &flags, &host, &port);
s = socket_fd(mrb, self);
n = -1;
if (argc == 2) {
n = send(s, msg, hlen, flags);
} else if (argc == 4) {
memset(&hints, 0, sizeof(hints));
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
hints.ai_flags = AI_NUMERICHOST|AI_NUMERICSERV;
memcpy(hostbuf, RSTRING_PTR(host), RSTRING_LEN(host));
hostbuf[RSTRING_LEN(host)] = '\0';
snprintf(portbuf, sizeof(portbuf), "%u", mrb_fixnum(port));
if (getaddrinfo(hostbuf, portbuf, &hints, &res) != 0)
mrb_sys_fail(mrb, "getaddrinfo");
// XXX: try all addresses?
n = sendto(s, msg, hlen, flags, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
}
if (n == -1)
mrb_sys_fail(mrb, "send");
return mrb_fixnum_value(n);
}
static mrb_value
mrb_socket_gethostname(mrb_state *mrb, mrb_value cls)
{
mrb_value buf;
#ifdef HOST_NAME_MAX
buf = mrb_str_buf_new(mrb, HOST_NAME_MAX+1);
#else
buf = mrb_str_buf_new(mrb, 256);
#endif
if (gethostname(RSTRING_PTR(buf), RSTRING_LEN(buf)) != 0)
mrb_sys_fail(mrb, "gethostname");
return buf;
}
static mrb_value
mrb_socket_accept(mrb_state *mrb, mrb_value klass)
{
mrb_value ary, sastr;
int s1;
mrb_int s0;
socklen_t socklen;
mrb_get_args(mrb, "i", &s0);
socklen = sizeof(struct sockaddr_storage);
sastr = mrb_str_buf_new(mrb, socklen);
s1 = accept(s0, (struct sockaddr *)RSTRING_PTR(sastr), &socklen);
if (s1 == -1) {
mrb_sys_fail(mrb, "accept");
}
// XXX: possible descriptor leakage here!
mrb_str_resize(mrb, sastr, socklen);
ary = mrb_ary_new_capa(mrb, 2);
mrb_ary_push(mrb, ary, mrb_fixnum_value(s1));
mrb_ary_push(mrb, ary, sastr);
return ary;
}
static mrb_value
mrb_socket_bind(mrb_state *mrb, mrb_value klass)
{
mrb_value sastr;
int s;
mrb_get_args(mrb, "iS", &s, &sastr);
if (bind(s, (struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
mrb_sys_fail(mrb, "bind");
}
return mrb_nil_value();
}
static mrb_value
mrb_socket_connect(mrb_state *mrb, mrb_value klass)
{
mrb_value sastr;
int s;
mrb_get_args(mrb, "iS", &s, &sastr);
if (connect(s, (struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
mrb_sys_fail(mrb, "connect");
}
return mrb_nil_value();
}
static mrb_value
mrb_socket_listen(mrb_state *mrb, mrb_value klass)
{
int backlog, s;
mrb_get_args(mrb, "ii", &s, &backlog);
if (listen(s, backlog) == -1) {
mrb_sys_fail(mrb, "listen");
}
return mrb_nil_value();
}
static mrb_value
mrb_socket_sockaddr_family(mrb_state *mrb, mrb_value klass)
{
mrb_value sa;
mrb_get_args(mrb, "S", &sa);
if (RSTRING_LEN(sa) < sizeof(struct sockaddr)) {
mrb_raisef(mrb, E_SOCKET_ERROR, "invalid sockaddr (too short)");
}
return mrb_fixnum_value(((struct sockaddr *)RSTRING_PTR(sa))->sa_family);
}
static mrb_value
mrb_socket_sockaddr_un(mrb_state *mrb, mrb_value klass)
{
struct sockaddr_un *sunp;
mrb_value path, s;
mrb_get_args(mrb, "S", &path);
if (RSTRING_LEN(path) > sizeof(sunp->sun_path) - 1) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "too long unix socket path (max: %ubytes)", (unsigned int)sizeof(sunp->sun_path) - 1);
}
s = mrb_str_buf_new(mrb, sizeof(struct sockaddr_un));
sunp = (struct sockaddr_un *)RSTRING_PTR(s);
sunp->sun_family = AF_UNIX;
memcpy(sunp->sun_path, RSTRING_PTR(path), RSTRING_LEN(path));
sunp->sun_path[RSTRING_LEN(path)] = '\0';
mrb_str_resize(mrb, s, sizeof(struct sockaddr_un));
return s;
}
static mrb_value
mrb_socket_socketpair(mrb_state *mrb, mrb_value klass)
{
mrb_value ary;
mrb_int domain, type, protocol;
int sv[2];
mrb_get_args(mrb, "iii", &domain, &type, &protocol);
if (socketpair(domain, type, protocol, sv) == -1) {
mrb_sys_fail(mrb, "socketpair");
}
// XXX: possible descriptor leakage here!
ary = mrb_ary_new_capa(mrb, 2);
mrb_ary_push(mrb, ary, mrb_fixnum_value(sv[0]));
mrb_ary_push(mrb, ary, mrb_fixnum_value(sv[1]));
return ary;
}
static mrb_value
mrb_socket_socket(mrb_state *mrb, mrb_value klass)
{
mrb_int domain, type, protocol;
int s;
mrb_get_args(mrb, "iii", &domain, &type, &protocol);
s = socket(domain, type, protocol);
if (s == -1)
mrb_sys_fail(mrb, "socket");
return mrb_fixnum_value(s);
}
void
mrb_mruby_socket_gem_init(mrb_state* mrb)
{
struct RClass *io, *ai, *sock, *bsock, *ipsock, *tcpsock, *udpsock, *usock;
struct RClass *constants;
ai = mrb_define_class(mrb, "Addrinfo", mrb->object_class);
mrb_mod_cv_set(mrb, ai, mrb_intern_cstr(mrb, "_lastai"), mrb_nil_value());
mrb_define_class_method(mrb, ai, "getaddrinfo", mrb_addrinfo_getaddrinfo, ARGS_REQ(2)|ARGS_OPT(4));
mrb_define_method(mrb, ai, "getnameinfo", mrb_addrinfo_getnameinfo, ARGS_OPT(1));
mrb_define_method(mrb, ai, "unix_path", mrb_addrinfo_unix_path, ARGS_NONE());
io = mrb_class_get(mrb, "IO");
bsock = mrb_define_class(mrb, "BasicSocket", io);
mrb_define_method(mrb, bsock, "_recvfrom", mrb_basicsocket_recvfrom, ARGS_REQ(1)|ARGS_OPT(1));
mrb_define_method(mrb, bsock, "_setnonblock", mrb_basicsocket_setnonblock, ARGS_REQ(1));
mrb_define_method(mrb, bsock, "getpeereid", mrb_basicsocket_getpeereid, ARGS_NONE());
mrb_define_method(mrb, bsock, "getpeername", mrb_basicsocket_getpeername, ARGS_NONE());
mrb_define_method(mrb, bsock, "getsockname", mrb_basicsocket_getsockname, ARGS_NONE());
mrb_define_method(mrb, bsock, "getsockopt", mrb_basicsocket_getsockopt, ARGS_REQ(2));
mrb_define_method(mrb, bsock, "recv", mrb_basicsocket_recv, ARGS_REQ(1)|ARGS_OPT(1));
// #recvmsg(maxlen, flags=0)
mrb_define_method(mrb, bsock, "send", mrb_basicsocket_send, ARGS_REQ(2)|ARGS_OPT(1));
// #sendmsg
// #sendmsg_nonblock
mrb_define_method(mrb, bsock, "setsockopt", mrb_basicsocket_setsockopt, ARGS_REQ(1)|ARGS_OPT(2));
mrb_define_method(mrb, bsock, "shutdown", mrb_basicsocket_shutdown, ARGS_OPT(1));
ipsock = mrb_define_class(mrb, "IPSocket", bsock);
mrb_define_class_method(mrb, ipsock, "ntop", mrb_ipsocket_ntop, ARGS_REQ(1));
mrb_define_class_method(mrb, ipsock, "pton", mrb_ipsocket_pton, ARGS_REQ(2));
mrb_define_method(mrb, ipsock, "recvfrom", mrb_ipsocket_recvfrom, ARGS_REQ(1)|ARGS_OPT(1));
tcpsock = mrb_define_class(mrb, "TCPSocket", ipsock);
//mrb_define_class_method(mrb, tcpsock, "open", mrb_tcpsocket_open, ARGS_REQ(2)|ARGS_OPT(2));
//mrb_define_class_method(mrb, tcpsock, "new", mrb_tcpsocket_open, ARGS_REQ(2)|ARGS_OPT(2));
mrb_define_class(mrb, "TCPServer", tcpsock);
udpsock = mrb_define_class(mrb, "UDPSocket", ipsock);
//#recvfrom_nonblock
sock = mrb_define_class(mrb, "Socket", bsock);
mrb_define_class_method(mrb, sock, "_accept", mrb_socket_accept, ARGS_REQ(1));
mrb_define_class_method(mrb, sock, "_bind", mrb_socket_bind, ARGS_REQ(3));
mrb_define_class_method(mrb, sock, "_connect", mrb_socket_connect, ARGS_REQ(3));
mrb_define_class_method(mrb, sock, "_listen", mrb_socket_listen, ARGS_REQ(2));
mrb_define_class_method(mrb, sock, "_sockaddr_family", mrb_socket_sockaddr_family, ARGS_REQ(1));
mrb_define_class_method(mrb, sock, "_socket", mrb_socket_socket, ARGS_REQ(3));
//mrb_define_class_method(mrb, sock, "gethostbyaddr", mrb_socket_gethostbyaddr, ARGS_REQ(1)|ARGS_OPT(1));
//mrb_define_class_method(mrb, sock, "gethostbyname", mrb_socket_gethostbyname, ARGS_REQ(1)|ARGS_OPT(1));
mrb_define_class_method(mrb, sock, "gethostname", mrb_socket_gethostname, ARGS_NONE());
//mrb_define_class_method(mrb, sock, "getservbyname", mrb_socket_getservbyname, ARGS_REQ(1)|ARGS_OPT(1));
//mrb_define_class_method(mrb, sock, "getservbyport", mrb_socket_getservbyport, ARGS_REQ(1)|ARGS_OPT(1));
mrb_define_class_method(mrb, sock, "sockaddr_un", mrb_socket_sockaddr_un, ARGS_REQ(1));
mrb_define_class_method(mrb, sock, "socketpair", mrb_socket_socketpair, ARGS_REQ(3));
//mrb_define_method(mrb, sock, "sysaccept", mrb_socket_accept, ARGS_NONE());
usock = mrb_define_class(mrb, "UNIXSocket", io);
//mrb_define_class_method(mrb, usock, "pair", mrb_unixsocket_open, ARGS_OPT(2));
//mrb_define_class_method(mrb, usock, "socketpair", mrb_unixsocket_open, ARGS_OPT(2));
//mrb_define_method(mrb, usock, "recv_io", mrb_unixsocket_peeraddr, ARGS_NONE());
//mrb_define_method(mrb, usock, "recvfrom", mrb_unixsocket_peeraddr, ARGS_NONE());
//mrb_define_method(mrb, usock, "send_io", mrb_unixsocket_peeraddr, ARGS_NONE());
constants = mrb_define_module_under(mrb, sock, "Constants");
#define define_const(SYM) \
do { \
mrb_define_const(mrb, constants, #SYM, mrb_fixnum_value(SYM)); \
} while (0)
#include "const.cstub"
}
void
mrb_mruby_socket_gem_final(mrb_state* mrb)
{
mrb_value ai;
ai = mrb_mod_cv_get(mrb, mrb_class_get(mrb, "Addrinfo"), mrb_intern_cstr(mrb, "_lastai"));
if (mrb_voidp_p(ai)) {
freeaddrinfo(mrb_voidp(ai));
}
}
assert('Addrinfo') do
assert_equal(Class, Addrinfo.class)
end
assert('super class of Addrinfo') do
assert_equal(Object, Addrinfo.superclass)
end
assert('Addrinfo.getadrinfo') do
ary = Addrinfo.getaddrinfo("localhost", "domain", Socket::AF_INET, Socket::SOCK_STREAM)
assert_equal(ary.size, 1)
ai = ary[0]
assert_equal(ai.afamily, Socket::AF_INET)
assert_equal(ai.pfamily, Socket::PF_INET)
assert_equal(ai.socktype, Socket::SOCK_STREAM)
assert_equal(ai.ip_address, '127.0.0.1')
assert_equal(ai.ip_port, 53)
end
assert('Addrinfo.foreach') do
# assume Addrinfo.getaddrinfo works well
b = []
a = Addrinfo.foreach("localhost", "domain") { |ai|
assert_include([Socket::AF_INET, Socket::AF_INET6], ai.afamily)
if ai.afamily == Socket::AF_INET
assert_equal(ai.ip_address, '127.0.0.1')
else
assert_equal(ai.ip_address, '::1')
end
assert_equal(ai.ip_port, 53)
assert_include([Socket::SOCK_STREAM, Socket::SOCK_DGRAM], ai.socktype)
b << ai
}
assert_equal(a.size, b.size)
end
assert('Addrinfo.ip') do
ai = Addrinfo.ip('127.0.0.1')
assert_equal('127.0.0.1', ai.ip_address)
assert_equal(Socket::AF_INET, ai.afamily)
assert_equal(0, ai.ip_port)
assert_equal(0, ai.socktype)
assert_equal(0, ai.protocol)
end
assert('Addrinfo.tcp') do
ai = Addrinfo.tcp('127.0.0.1', 'smtp')
assert_equal('127.0.0.1', ai.ip_address)
assert_equal(Socket::AF_INET, ai.afamily)
assert_equal(25, ai.ip_port)
assert_equal(Socket::SOCK_STREAM, ai.socktype)
assert_equal(Socket::IPPROTO_TCP, ai.protocol)
end
assert('Addrinfo.udp') do
ai = Addrinfo.udp('127.0.0.1', 'domain')
assert_equal('127.0.0.1', ai.ip_address)
assert_equal(Socket::AF_INET, ai.afamily)
assert_equal(53, ai.ip_port)
assert_equal(Socket::SOCK_DGRAM, ai.socktype)
assert_equal(Socket::IPPROTO_UDP, ai.protocol)
end
assert('Addrinfo.unix') do
a1 = Addrinfo.unix('/tmp/sock')
assert_true(a1.unix?)
assert_equal('/tmp/sock', a1.unix_path)
assert_equal(Socket::SOCK_STREAM, a1.socktype)
a2 = Addrinfo.unix('/tmp/sock', Socket::SOCK_DGRAM)
assert_equal(Socket::SOCK_DGRAM, a2.socktype)
end
assert('Addrinfo#afamily') do
ai4 = Addrinfo.new(Socket.sockaddr_in(1, '127.0.0.1'))
ai6 = Addrinfo.new(Socket.sockaddr_in(1, '::1'))
aiu = Addrinfo.new(Socket.sockaddr_un('/tmp/sock'))
assert_equal(Socket::AF_INET, ai4.afamily)
assert_equal(Socket::AF_INET6, ai6.afamily)
assert_equal(Socket::AF_UNIX, aiu.afamily)
end
# assert('Addrinfo#canonname') do
# #getnameinfo
# assert('Addrinfo#inspect') do
# assert('Addrinfo#inspect_socket') do
# assert('Addrinfo#ip?') do
# assert('Addrinfo#ip_address') do
# assert('Addrinfo#ip_port') do
# assert('Addrinfo#ip_unpack') do
# assert('Addrinfo#ipv4?') do
# assert('Addrinfo#ipv6?') do
# assert('Addrinfo#pfamily') do
# assert('Addrinfo#protocol') do
# assert('Addrinfo#socktype') do
# assert('Addrinfo#to_sockaddr') do
# assert('Addrinfo#unix?') do
# #unix_path
assert('BasicSocket') do
assert_equal(Class, BasicSocket.class)
end
assert('super class of BasicSocket') do
assert_equal(IO, BasicSocket.superclass)
end
assert('BasicSocket.do_not_reverse_lookup') do
assert_equal(BasicSocket.do_not_reverse_lookup, true)
end
assert('BasicSocket.do_not_reverse_lookup=') do
BasicSocket.do_not_reverse_lookup = false
assert_equal(BasicSocket.do_not_reverse_lookup, false)
BasicSocket.do_not_reverse_lookup = true
end
assert('UDPSocket.new') do
s = UDPSocket.new
assert_true(s.is_a? UDPSocket)
s.close
s = UDPSocket.new(Socket::AF_INET6)
assert_true(s.is_a? UDPSocket)
s.close
true
end
#assert('UDPSocket#connect') do
#assert('UDPSocket#send') do
#assert('UDPSocket#recv') do
#assert('UDPSocket#bind') do
#assert('UDPSocket#recvfrom_nonblock') do
#assert('TCPSocket.gethostbyname') do
#assert('TCPSocket.new') do
#assert('TCPSocket#close') do
#assert('TCPSocket#write') do
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment