diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/const.cstub | 219 | ||||
| -rw-r--r-- | src/const.def | 81 | ||||
| -rwxr-xr-x | src/gen.rb | 17 | ||||
| -rw-r--r-- | src/socket.c | 775 |
4 files changed, 1092 insertions, 0 deletions
diff --git a/src/const.cstub b/src/const.cstub new file mode 100644 index 000000000..3ddac21dd --- /dev/null +++ b/src/const.cstub @@ -0,0 +1,219 @@ +#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 diff --git a/src/const.def b/src/const.def new file mode 100644 index 000000000..7290a17fb --- /dev/null +++ b/src/const.def @@ -0,0 +1,81 @@ +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 diff --git a/src/gen.rb b/src/gen.rb new file mode 100755 index 000000000..8423dc442 --- /dev/null +++ b/src/gen.rb @@ -0,0 +1,17 @@ +#!/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 +} diff --git a/src/socket.c b/src/socket.c new file mode 100644 index 000000000..ec52e302f --- /dev/null +++ b/src/socket.c @@ -0,0 +1,775 @@ +/* +** 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)); + } +} |