rhodes 3.2.0.beta.4 → 3.2.0.beta.5

data/platform/shared/ruby/ext/socket_192/sockport.h

@@ -0,0 +1,84 @@
+/************************************************
+
+  sockport.h -
+
+  $Author: akr $
+  created at: Fri Apr 30 23:19:34 JST 1999
+
+************************************************/
+
+#ifndef SOCKPORT_H
+#define SOCKPORT_H
+
+#ifdef SA_LEN
+#  define SS_LEN(ss) (ss)->ss_len
+#else
+# ifdef HAVE_SA_LEN
+#  define SA_LEN(sa) (sa)->sa_len
+#  define SS_LEN(ss) (ss)->ss_len
+# else
+#  ifdef AF_INET6
+#   define SA_LEN(sa) \
+	(((sa)->sa_family == AF_INET6) ? sizeof(struct sockaddr_in6) \
+				       : sizeof(struct sockaddr))
+#   define SS_LEN(ss) \
+	(((ss)->ss_family == AF_INET6) ? sizeof(struct sockaddr_in6) \
+				       : sizeof(struct sockaddr))
+#  else
+    /* by tradition, sizeof(struct sockaddr) covers most of the sockaddrs */
+#   define SA_LEN(sa)	(sizeof(struct sockaddr))
+#   define SS_LEN(ss)	(sizeof(struct sockaddr))
+#  endif
+# endif
+#endif
+
+#ifdef HAVE_SA_LEN
+# define SET_SA_LEN(sa, len) (void)((sa)->sa_len = (len))
+# define SET_SS_LEN(ss, len) (void)((ss)->ss_len = (len))
+#else
+# define SET_SA_LEN(sa, len) (void)(len)
+# define SET_SS_LEN(ss, len) (void)(len)
+#endif
+
+#ifdef HAVE_SIN_LEN
+# define SIN_LEN(si) (si)->sin_len
+# define SET_SIN_LEN(si,len) (si)->sin_len = (len)
+#else
+# define SIN_LEN(si) sizeof(struct sockaddr_in)
+# define SET_SIN_LEN(si,len)
+#endif
+
+#ifndef IN_MULTICAST
+# define IN_CLASSD(i)	(((long)(i) & 0xf0000000) == 0xe0000000)
+# define IN_MULTICAST(i)	IN_CLASSD(i)
+#endif
+
+#ifndef IN_EXPERIMENTAL
+# define IN_EXPERIMENTAL(i) ((((long)(i)) & 0xe0000000) == 0xe0000000)
+#endif
+
+#ifndef IN_CLASSA_NSHIFT
+# define IN_CLASSA_NSHIFT 24
+#endif
+
+#ifndef IN_LOOPBACKNET
+# define IN_LOOPBACKNET 127
+#endif
+
+#ifndef AF_UNSPEC
+# define AF_UNSPEC 0
+#endif
+
+#ifndef PF_UNSPEC
+# define PF_UNSPEC AF_UNSPEC
+#endif
+
+#ifndef PF_INET
+# define PF_INET AF_INET
+#endif
+
+#if defined(HOST_NOT_FOUND) && !defined(h_errno) && !defined(__CYGWIN__)
+extern int h_errno;
+#endif
+
+#endif

data/platform/shared/ruby/ext/socket_192/sockssocket.c

@@ -0,0 +1,58 @@
+/************************************************
+
+  sockssocket.c -
+
+  created at: Thu Mar 31 12:21:29 JST 1994
+
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+
+************************************************/
+
+#include "rubysocket.h"
+
+#ifdef SOCKS
+static VALUE
+socks_init(VALUE sock, VALUE host, VALUE serv)
+{
+    static int init = 0;
+
+    if (init == 0) {
+	SOCKSinit("ruby");
+	init = 1;
+    }
+
+    return rsock_init_inetsock(sock, host, serv, Qnil, Qnil, INET_SOCKS);
+}
+
+#ifdef SOCKS5
+static VALUE
+socks_s_close(VALUE sock)
+{
+    rb_io_t *fptr;
+
+    if (rb_safe_level() >= 4 && !OBJ_TAINTED(sock)) {
+	rb_raise(rb_eSecurityError, "Insecure: can't close socket");
+    }
+    GetOpenFile(sock, fptr);
+    shutdown(fptr->fd, 2);
+    return rb_io_close(sock);
+}
+#endif
+#endif
+
+/*
+ * Document-class: ::SOCKSSocket < TCPSocket
+ *
+ * SOCKSSocket class
+ */
+void
+rsock_init_sockssocket(void)
+{
+#ifdef SOCKS
+    rb_cSOCKSSocket = rb_define_class("SOCKSSocket", rb_cTCPSocket);
+    rb_define_method(rb_cSOCKSSocket, "initialize", socks_init, 2);
+#ifdef SOCKS5
+    rb_define_method(rb_cSOCKSSocket, "close", socks_s_close, 0);
+#endif
+#endif
+}

data/platform/shared/ruby/ext/socket_192/tcpserver.c

@@ -0,0 +1,145 @@
+/************************************************
+
+  tcpserver.c -
+
+  created at: Thu Mar 31 12:21:29 JST 1994
+
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+
+************************************************/
+
+#include "rubysocket.h"
+
+/*
+ * call-seq:
+ *   TCPServer.new([hostname,] port)                    => tcpserver
+ *
+ * Creates a new server socket bound to _port_.
+ *
+ * If _hostname_ is given, the socket is bound to it.
+ *
+ *   serv = TCPServer.new("127.0.0.1", 28561)
+ *   s = serv.accept
+ *   s.puts Time.now
+ *   s.close
+ */
+static VALUE
+tcp_svr_init(int argc, VALUE *argv, VALUE sock)
+{
+    VALUE hostname, port;
+
+    rb_scan_args(argc, argv, "011", &hostname, &port);
+    return rsock_init_inetsock(sock, hostname, port, Qnil, Qnil, INET_SERVER);
+}
+
+/*
+ * call-seq:
+ *   tcpserver.accept => tcpsocket
+ *
+ *   TCPServer.open("127.0.0.1", 14641) {|serv|
+ *     s = serv.accept
+ *     s.puts Time.now
+ *     s.close
+ *   }
+ *
+ */
+static VALUE
+tcp_accept(VALUE sock)
+{
+    rb_io_t *fptr;
+    struct sockaddr_storage from;
+    socklen_t fromlen;
+
+    GetOpenFile(sock, fptr);
+    fromlen = (socklen_t)sizeof(from);
+    return rsock_s_accept(rb_cTCPSocket, fptr->fd,
+		          (struct sockaddr*)&from, &fromlen);
+}
+
+/*
+ * call-seq:
+ * 	tcpserver.accept_nonblock => tcpsocket
+ *
+ * Accepts an incoming connection using accept(2) after
+ * O_NONBLOCK is set for the underlying file descriptor.
+ * It returns an accepted TCPSocket for the incoming connection.
+ *
+ * === Example
+ * 	require 'socket'
+ * 	serv = TCPServer.new(2202)
+ * 	begin # emulate blocking accept
+ * 	  sock = serv.accept_nonblock
+ * 	rescue IO::WaitReadable, Errno::EINTR
+ * 	  IO.select([serv])
+ * 	  retry
+ * 	end
+ * 	# sock is an accepted socket.
+ *
+ * Refer to Socket#accept for the exceptions that may be thrown if the call
+ * to TCPServer#accept_nonblock fails.
+ *
+ * TCPServer#accept_nonblock may raise any error corresponding to accept(2) failure,
+ * including Errno::EWOULDBLOCK.
+ *
+ * If the exception is Errno::EWOULDBLOCK, Errno::AGAIN, Errno::ECONNABORTED, Errno::EPROTO,
+ * it is extended by IO::WaitReadable.
+ * So IO::WaitReadable can be used to rescue the exceptions for retrying accept_nonblock.
+ *
+ * === See
+ * * TCPServer#accept
+ * * Socket#accept
+ */
+static VALUE
+tcp_accept_nonblock(VALUE sock)
+{
+    rb_io_t *fptr;
+    struct sockaddr_storage from;
+    socklen_t fromlen;
+
+    GetOpenFile(sock, fptr);
+    fromlen = (socklen_t)sizeof(from);
+    return rsock_s_accept_nonblock(rb_cTCPSocket, fptr,
+			           (struct sockaddr *)&from, &fromlen);
+}
+
+/*
+ * call-seq:
+ *   tcpserver.sysaccept => file_descriptor
+ *
+ * Returns a file descriptor of a accepted connection.
+ *
+ *   TCPServer.open("127.0.0.1", 28561) {|serv|
+ *     fd = serv.sysaccept
+ *     s = IO.for_fd(fd)
+ *     s.puts Time.now
+ *     s.close
+ *   }
+ *
+ */
+static VALUE
+tcp_sysaccept(VALUE sock)
+{
+    rb_io_t *fptr;
+    struct sockaddr_storage from;
+    socklen_t fromlen;
+
+    GetOpenFile(sock, fptr);
+    fromlen = (socklen_t)sizeof(from);
+    return rsock_s_accept(0, fptr->fd, (struct sockaddr*)&from, &fromlen);
+}
+
+/*
+ * Document-class: ::TCPServer < TCPSocket
+ *
+ * TCPServer represents a TCP/IP server socket.
+ */
+void
+rsock_init_tcpserver(void)
+{
+    rb_cTCPServer = rb_define_class("TCPServer", rb_cTCPSocket);
+    rb_define_method(rb_cTCPServer, "accept", tcp_accept, 0);
+    rb_define_method(rb_cTCPServer, "accept_nonblock", tcp_accept_nonblock, 0);
+    rb_define_method(rb_cTCPServer, "sysaccept", tcp_sysaccept, 0);
+    rb_define_method(rb_cTCPServer, "initialize", tcp_svr_init, -1);
+    rb_define_method(rb_cTCPServer, "listen", rsock_sock_listen, 1); /* in socket.c */
+}

data/platform/shared/ruby/ext/socket_192/tcpsocket.c

@@ -0,0 +1,69 @@
+/************************************************
+
+  tcpsocket.c -
+
+  created at: Thu Mar 31 12:21:29 JST 1994
+
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+
+************************************************/
+
+#include "rubysocket.h"
+
+/*
+ * call-seq:
+ *    TCPSocket.new(remote_host, remote_port, local_host=nil, local_port=nil)
+ *
+ * Opens a TCP connection to +remote_host+ on +remote_port+.  If +local_host+
+ * and +local_port+ are specified, then those parameters are used on the local
+ * end to establish the connection.
+ */
+static VALUE
+tcp_init(int argc, VALUE *argv, VALUE sock)
+{
+    VALUE remote_host, remote_serv;
+    VALUE local_host, local_serv;
+
+    rb_scan_args(argc, argv, "22", &remote_host, &remote_serv,
+			&local_host, &local_serv);
+
+    return rsock_init_inetsock(sock, remote_host, remote_serv,
+			       local_host, local_serv, INET_CLIENT);
+}
+
+static VALUE
+tcp_sockaddr(struct sockaddr *addr, size_t len)
+{
+    return rsock_make_ipaddr(addr);
+}
+
+/*
+ * call-seq:
+ *   TCPSocket.gethostbyname(hostname) => [official_hostname, alias_hostnames, address_family, *address_list]
+ *
+ * Lookups host information by _hostname_.
+ *
+ *   TCPSocket.gethostbyname("localhost")
+ *   #=> ["localhost", ["hal"], 2, "127.0.0.1"]
+ *
+ */
+static VALUE
+tcp_s_gethostbyname(VALUE obj, VALUE host)
+{
+    rb_secure(3);
+    return rsock_make_hostent(host, rsock_addrinfo(host, Qnil, SOCK_STREAM, AI_CANONNAME),
+			tcp_sockaddr);
+}
+
+/*
+ * Document-class: ::TCPSocket < IPSocket
+ *
+ * TCPSocket represents a TCP/IP client socket.
+ */
+void
+rsock_init_tcpsocket(void)
+{
+    rb_cTCPSocket = rb_define_class("TCPSocket", rb_cIPSocket);
+    rb_define_singleton_method(rb_cTCPSocket, "gethostbyname", tcp_s_gethostbyname, 1);
+    rb_define_method(rb_cTCPSocket, "initialize", tcp_init, -1);
+}

data/platform/shared/ruby/ext/socket_192/udpsocket.c

@@ -0,0 +1,264 @@
+/************************************************
+
+  udpsocket.c -
+
+  created at: Thu Mar 31 12:21:29 JST 1994
+
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+
+************************************************/
+
+#include "rubysocket.h"
+
+/*
+ * call-seq:
+ *   UDPSocket.new([address_family]) => socket
+ *
+ * Creates a new UDPSocket object.
+ *
+ * _address_family_ should be an integer, a string or a symbol:
+ * Socket::AF_INET, "AF_INET", :INET, etc.
+ *
+ *   UDPSocket.new                   #=> #<UDPSocket:fd 3>
+ *   UDPSocket.new(Socket::AF_INET6) #=> #<UDPSocket:fd 4>
+ *
+ */
+static VALUE
+udp_init(int argc, VALUE *argv, VALUE sock)
+{
+    VALUE arg;
+    int family = AF_INET;
+    int fd;
+
+    rb_secure(3);
+    if (rb_scan_args(argc, argv, "01", &arg) == 1) {
+	family = rsock_family_arg(arg);
+    }
+    fd = rsock_socket(family, SOCK_DGRAM, 0);
+    if (fd < 0) {
+	rb_sys_fail("socket(2) - udp");
+    }
+
+    return rsock_init_sock(sock, fd);
+}
+
+struct udp_arg
+{
+    struct addrinfo *res;
+    int fd;
+};
+
+static VALUE
+udp_connect_internal(struct udp_arg *arg)
+{
+    int fd = arg->fd;
+    struct addrinfo *res;
+
+    for (res = arg->res; res; res = res->ai_next) {
+	if (rsock_connect(fd, res->ai_addr, res->ai_addrlen, 0) >= 0) {
+	    return Qtrue;
+	}
+    }
+    return Qfalse;
+}
+
+VALUE rsock_freeaddrinfo(struct addrinfo *addr);
+
+/*
+ * call-seq:
+ *   udpsocket.connect(host, port) => 0
+ *
+ * Connects _udpsocket_ to _host_:_port_.
+ *
+ * This makes possible to send without destination address.
+ *
+ *   u1 = UDPSocket.new
+ *   u1.bind("127.0.0.1", 4913)
+ *   u2 = UDPSocket.new
+ *   u2.connect("127.0.0.1", 4913)
+ *   u2.send "uuuu", 0
+ *   p u1.recvfrom(10) #=> ["uuuu", ["AF_INET", 33230, "localhost", "127.0.0.1"]]
+ *
+ */
+static VALUE
+udp_connect(VALUE sock, VALUE host, VALUE port)
+{
+    rb_io_t *fptr;
+    struct udp_arg arg;
+    VALUE ret;
+
+    rb_secure(3);
+    arg.res = rsock_addrinfo(host, port, SOCK_DGRAM, 0);
+    GetOpenFile(sock, fptr);
+    arg.fd = fptr->fd;
+    ret = rb_ensure(udp_connect_internal, (VALUE)&arg,
+		    rsock_freeaddrinfo, (VALUE)arg.res);
+    if (!ret) rb_sys_fail("connect(2)");
+    return INT2FIX(0);
+}
+
+/*
+ * call-seq:
+ *   udpsocket.bind(host, port) #=> 0
+ *
+ * Binds _udpsocket_ to _host_:_port_.
+ *
+ *   u1 = UDPSocket.new
+ *   u1.bind("127.0.0.1", 4913)
+ *   u1.send "message-to-self", 0, "127.0.0.1", 4913
+ *   p u1.recvfrom(10) #=> ["message-to", ["AF_INET", 4913, "localhost", "127.0.0.1"]]
+ *
+ */
+static VALUE
+udp_bind(VALUE sock, VALUE host, VALUE port)
+{
+    rb_io_t *fptr;
+    struct addrinfo *res0, *res;
+
+    rb_secure(3);
+    res0 = rsock_addrinfo(host, port, SOCK_DGRAM, 0);
+    GetOpenFile(sock, fptr);
+    for (res = res0; res; res = res->ai_next) {
+	if (bind(fptr->fd, res->ai_addr, res->ai_addrlen) < 0) {
+	    continue;
+	}
+	freeaddrinfo(res0);
+	return INT2FIX(0);
+    }
+    freeaddrinfo(res0);
+    rb_sys_fail("bind(2)");
+    return INT2FIX(0);
+}
+
+/*
+ * call-seq:
+ *   udpsocket.send(mesg, flags, host, port)  => numbytes_sent
+ *   udpsocket.send(mesg, flags, sockaddr_to) => numbytes_sent
+ *   udpsocket.send(mesg, flags)              => numbytes_sent
+ *
+ * Sends _mesg_ via _udpsocket_.
+ *
+ * _flags_ should be a bitwise OR of Socket::MSG_* constants.
+ *
+ *   u1 = UDPSocket.new
+ *   u1.bind("127.0.0.1", 4913)
+ *
+ *   u2 = UDPSocket.new
+ *   u2.send "hi", 0, "127.0.0.1", 4913
+ *
+ *   mesg, addr = u1.recvfrom(10)
+ *   u1.send mesg, 0, addr[3], addr[1]
+ *
+ *   p u2.recv(100) #=> "hi"
+ *
+ */
+static VALUE
+udp_send(int argc, VALUE *argv, VALUE sock)
+{
+    VALUE flags, host, port;
+    rb_io_t *fptr;
+    int n;
+    struct addrinfo *res0, *res;
+    struct rsock_send_arg arg;
+
+    if (argc == 2 || argc == 3) {
+	return rsock_bsock_send(argc, argv, sock);
+    }
+    rb_secure(4);
+    rb_scan_args(argc, argv, "4", &arg.mesg, &flags, &host, &port);
+
+    StringValue(arg.mesg);
+    res0 = rsock_addrinfo(host, port, SOCK_DGRAM, 0);
+    GetOpenFile(sock, fptr);
+    arg.fd = fptr->fd;
+    arg.flags = NUM2INT(flags);
+    for (res = res0; res; res = res->ai_next) {
+      retry:
+	arg.to = res->ai_addr;
+	arg.tolen = res->ai_addrlen;
+	rb_thread_fd_writable(arg.fd);
+	n = (int)BLOCKING_REGION(rsock_sendto_blocking, &arg);
+	if (n >= 0) {
+	    freeaddrinfo(res0);
+	    return INT2FIX(n);
+	}
+	if (rb_io_wait_writable(fptr->fd)) {
+	    goto retry;
+	}
+    }
+    freeaddrinfo(res0);
+    rb_sys_fail("sendto(2)");
+    return INT2FIX(n);
+}
+
+/*
+ * call-seq:
+ * 	udpsocket.recvfrom_nonblock(maxlen) => [mesg, sender_inet_addr]
+ * 	udpsocket.recvfrom_nonblock(maxlen, flags) => [mesg, sender_inet_addr]
+ *
+ * Receives up to _maxlen_ bytes from +udpsocket+ using recvfrom(2) after
+ * O_NONBLOCK is set for the underlying file descriptor.
+ * If _maxlen_ is omitted, its default value is 65536.
+ * _flags_ is zero or more of the +MSG_+ options.
+ * The first element of the results, _mesg_, is the data received.
+ * The second element, _sender_inet_addr_, is an array to represent the sender address.
+ *
+ * When recvfrom(2) returns 0,
+ * Socket#recvfrom_nonblock returns an empty string as data.
+ * It means an empty packet.
+ *
+ * === Parameters
+ * * +maxlen+ - the number of bytes to receive from the socket
+ * * +flags+ - zero or more of the +MSG_+ options
+ *
+ * === Example
+ * 	require 'socket'
+ * 	s1 = UDPSocket.new
+ * 	s1.bind("127.0.0.1", 0)
+ * 	s2 = UDPSocket.new
+ * 	s2.bind("127.0.0.1", 0)
+ * 	s2.connect(*s1.addr.values_at(3,1))
+ * 	s1.connect(*s2.addr.values_at(3,1))
+ * 	s1.send "aaa", 0
+ * 	begin # emulate blocking recvfrom
+ * 	  p s2.recvfrom_nonblock(10)  #=> ["aaa", ["AF_INET", 33302, "localhost.localdomain", "127.0.0.1"]]
+ * 	rescue IO::WaitReadable
+ * 	  IO.select([s2])
+ * 	  retry
+ * 	end
+ *
+ * Refer to Socket#recvfrom for the exceptions that may be thrown if the call
+ * to _recvfrom_nonblock_ fails.
+ *
+ * UDPSocket#recvfrom_nonblock may raise any error corresponding to recvfrom(2) failure,
+ * including Errno::EWOULDBLOCK.
+ *
+ * If the exception is Errno::EWOULDBLOCK or Errno::AGAIN,
+ * it is extended by IO::WaitReadable.
+ * So IO::WaitReadable can be used to rescue the exceptions for retrying recvfrom_nonblock.
+ *
+ * === See
+ * * Socket#recvfrom
+ */
+static VALUE
+udp_recvfrom_nonblock(int argc, VALUE *argv, VALUE sock)
+{
+    return rsock_s_recvfrom_nonblock(sock, argc, argv, RECV_IP);
+}
+
+/*
+ * Document-class: ::UDPSocket < IPSocket
+ *
+ * UDPSocket represents a UDP/IP socket.
+ */
+void
+rsock_init_udpsocket(void)
+{
+    rb_cUDPSocket = rb_define_class("UDPSocket", rb_cIPSocket);
+    rb_define_method(rb_cUDPSocket, "initialize", udp_init, -1);
+    rb_define_method(rb_cUDPSocket, "connect", udp_connect, 2);
+    rb_define_method(rb_cUDPSocket, "bind", udp_bind, 2);
+    rb_define_method(rb_cUDPSocket, "send", udp_send, -1);
+    rb_define_method(rb_cUDPSocket, "recvfrom_nonblock", udp_recvfrom_nonblock, -1);
+}
+