kgio 2.3.3 → 2.4.0

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v2.3.3.GIT
+DEF_VER=v2.4.0.GIT
 
 LF='
 '

data/HACKING

@@ -2,10 +2,8 @@
 
 === Documentation
 
-We use RDoc 2.5.x with Darkfish for documentation as much as possible,
-if you're on Ruby 1.8 you want to install the latest "rdoc" gem.  Due to
-the lack of RDoc-to-manpage converters we know about, we're writing
-manpages in Markdown and converting to troff/HTML with Pandoc.
+We use the latest version of {wrongdoc}[http://bogomips.org/wrongdoc] as
+much as possible.
 
 Please wrap documentation at 72 characters-per-line or less (long URLs
 are exempt) so it is comfortably readable from terminals.
@@ -22,7 +20,7 @@ respective C APIs.
 All of our C code should be compatible with all reasonably modern Unices
 and should run on compilers supported by the versions of Ruby we target.
 
-We will NEVER support non-Free platforms under any circumstances.
+We will NEVER directly support non-Free platforms under any circumstances.
 
 Our C code follows K&R indentation style (hard tabs, tabs are always 8
 characters wide) and NOT the indentation style of Matz Ruby.
@@ -63,4 +61,3 @@ Without RubyGems (via setup.rb):
 
 It is not at all recommended to mix a RubyGems installation with an
 installation done without RubyGems, however.
-

data/ext/kgio/accept.c

@@ -16,8 +16,11 @@ static int accept4_flags = SOCK_CLOEXEC | SOCK_NONBLOCK;
 
 struct accept_args {
 	int fd;
+	int flags;
 	struct sockaddr *addr;
 	socklen_t *addrlen;
+	VALUE accept_io;
+	VALUE accepted_class;
 };
 
 /*
@@ -53,15 +56,19 @@ static VALUE get_accepted(VALUE klass)
 	return cClientSocket;
 }
 
+/*
+ * accept() wrapper that'll fall back on accept() if we were built on
+ * a system with accept4() but run on a system without accept4()
+ */
 static VALUE xaccept(void *ptr)
 {
 	struct accept_args *a = ptr;
 	int rv;
 
-	rv = accept_fn(a->fd, a->addr, a->addrlen, accept4_flags);
+	rv = accept_fn(a->fd, a->addr, a->addrlen, a->flags);
 	if (rv == -1 && errno == ENOSYS && accept_fn != my_accept4) {
 		accept_fn = my_accept4;
-		rv = accept_fn(a->fd, a->addr, a->addrlen, accept4_flags);
+		rv = accept_fn(a->fd, a->addr, a->addrlen, a->flags);
 	}
 
 	return (VALUE)rv;
@@ -124,16 +131,56 @@ static int thread_accept(struct accept_args *a, int force_nonblock)
 #define set_blocking_or_block(fd) (void)rb_io_wait_readable(fd)
 #endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */
 
-static VALUE acceptor(int argc, const VALUE *argv)
+static void
+prepare_accept(struct accept_args *a, VALUE self, int argc, const VALUE *argv)
 {
-	if (argc == 0)
-		return cClientSocket; /* default, legacy behavior */
-	else if (argc == 1)
-		return argv[0];
+	a->fd = my_fileno(self);
+	a->accept_io = self;
+
+	switch (argc) {
+	case 2:
+		a->flags = NUM2INT(argv[1]);
+		a->accepted_class = NIL_P(argv[0]) ? cClientSocket : argv[0];
+		return;
+	case 0: /* default, legacy behavior */
+		a->flags = accept4_flags;
+		a->accepted_class = cClientSocket;
+		return;
+	case 1:
+		a->flags = accept4_flags;
+		a->accepted_class = NIL_P(argv[0]) ? cClientSocket : argv[0];
+		return;
+	}
 
 	rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
 }
 
+static VALUE in_addr_set(VALUE io, struct sockaddr_storage *addr, socklen_t len)
+{
+	VALUE host;
+	int host_len, rc;
+	char *host_ptr;
+
+	switch (addr->ss_family) {
+	case AF_INET:
+		host_len = (long)INET_ADDRSTRLEN;
+		break;
+	case AF_INET6:
+		host_len = (long)INET6_ADDRSTRLEN;
+		break;
+	default:
+		rb_raise(rb_eRuntimeError, "unsupported address family");
+	}
+	host = rb_str_new(NULL, host_len);
+	host_ptr = RSTRING_PTR(host);
+	rc = getnameinfo((struct sockaddr *)addr, len,
+			 host_ptr, host_len, NULL, 0, NI_NUMERICHOST);
+	if (rc != 0)
+		rb_raise(rb_eRuntimeError, "getnameinfo: %s", gai_strerror(rc));
+	rb_str_set_len(host, strlen(host_ptr));
+	return rb_ivar_set(io, iv_kgio_addr, host);
+}
+
 #if defined(__linux__)
 #  define post_accept kgio_autopush_accept
 #else
@@ -141,24 +188,21 @@ static VALUE acceptor(int argc, const VALUE *argv)
 #endif
 
 static VALUE
-my_accept(VALUE accept_io, VALUE klass,
-          struct sockaddr *addr, socklen_t *addrlen, int nonblock)
+my_accept(struct accept_args *a, int force_nonblock)
 {
-	int client;
+	int client_fd;
 	VALUE client_io;
-	struct accept_args a;
+	int retried = 0;
 
-	a.fd = my_fileno(accept_io);
-	a.addr = addr;
-	a.addrlen = addrlen;
 retry:
-	client = thread_accept(&a, nonblock);
-	if (client == -1) {
+	client_fd = thread_accept(a, force_nonblock);
+	if (client_fd == -1) {
 		switch (errno) {
 		case EAGAIN:
-			if (nonblock)
+			if (force_nonblock)
 				return Qnil;
-			set_blocking_or_block(a.fd);
+			a->fd = my_fileno(a->accept_io);
+			set_blocking_or_block(a->fd);
 #ifdef ECONNABORTED
 		case ECONNABORTED:
 #endif /* ECONNABORTED */
@@ -166,6 +210,7 @@ retry:
 		case EPROTO:
 #endif /* EPROTO */
 		case EINTR:
+			a->fd = my_fileno(a->accept_io);
 			goto retry;
 		case ENOMEM:
 		case EMFILE:
@@ -173,47 +218,27 @@ retry:
 #ifdef ENOBUFS
 		case ENOBUFS:
 #endif /* ENOBUFS */
-			errno = 0;
-			rb_gc();
-			client = thread_accept(&a, nonblock);
-		}
-		if (client == -1) {
-			if (errno == EINTR)
+			if (!retried) {
+				retried = 1;
+				errno = 0;
+				rb_gc();
 				goto retry;
+			}
+		default:
 			rb_sys_fail("accept");
 		}
 	}
-	client_io = sock_for_fd(klass, client);
-	post_accept(accept_io, client_io);
+	client_io = sock_for_fd(a->accepted_class, client_fd);
+	post_accept(a->accept_io, client_io);
+
+	if (a->addr)
+		in_addr_set(client_io,
+		            (struct sockaddr_storage *)a->addr, *a->addrlen);
+	else
+		rb_ivar_set(client_io, iv_kgio_addr, localhost);
 	return client_io;
 }
 
-static VALUE in_addr_set(VALUE io, struct sockaddr_storage *addr, socklen_t len)
-{
-	VALUE host;
-	int host_len, rc;
-	char *host_ptr;
-
-	switch (addr->ss_family) {
-	case AF_INET:
-		host_len = (long)INET_ADDRSTRLEN;
-		break;
-	case AF_INET6:
-		host_len = (long)INET6_ADDRSTRLEN;
-		break;
-	default:
-		rb_raise(rb_eRuntimeError, "unsupported address family");
-	}
-	host = rb_str_new(NULL, host_len);
-	host_ptr = RSTRING_PTR(host);
-	rc = getnameinfo((struct sockaddr *)addr, len,
-			 host_ptr, host_len, NULL, 0, NI_NUMERICHOST);
-	if (rc != 0)
-		rb_raise(rb_eRuntimeError, "getnameinfo: %s", gai_strerror(rc));
-	rb_str_set_len(host, strlen(host_ptr));
-	return rb_ivar_set(io, iv_kgio_addr, host);
-}
-
 /*
  * call-seq:
  *
@@ -239,6 +264,8 @@ static VALUE addr_bang(VALUE io)
  *
  *	server = Kgio::TCPServer.new('0.0.0.0', 80)
  *	server.kgio_tryaccept -> Kgio::Socket or nil
+ *	server.kgio_tryaccept(klass = MySocket) -> MySocket or nil
+ *	server.kgio_tryaccept(nil, flags) -> Kgio::Socket or nil
  *
  * Initiates a non-blocking accept and returns a generic Kgio::Socket
  * object with the kgio_addr attribute set to the IP address of the
@@ -246,21 +273,26 @@ static VALUE addr_bang(VALUE io)
  *
  * Returns nil on EAGAIN, and raises on other errors.
  *
- * An optional class argument may be specified to override the
- * Kgio::Socket-class return value:
+ * An optional +klass+ argument may be specified to override the
+ * Kgio::Socket-class on a successful return value.
+ *
+ * An optional +flags+ argument may also be specifed to override the
+ * value of +Kgio.accept_cloexec+ and +Kgio.accept_nonblock+.  +flags+
+ * is a bitmask that may contain any combination of:
  *
- *      server.kgio_tryaccept(MySocket) -> MySocket
+ * - Fcntl::FD_CLOEXEC - close-on-exec flag
+ * - IO::NONBLOCK - non-blocking flag
  */
-static VALUE tcp_tryaccept(int argc, VALUE *argv, VALUE io)
+static VALUE tcp_tryaccept(int argc, VALUE *argv, VALUE self)
 {
 	struct sockaddr_storage addr;
 	socklen_t addrlen = sizeof(struct sockaddr_storage);
-	VALUE klass = acceptor(argc, argv);
-	VALUE rv = my_accept(io, klass, (struct sockaddr *)&addr, &addrlen, 1);
+	struct accept_args a;
 
-	if (!NIL_P(rv))
-		in_addr_set(rv, &addr, addrlen);
-	return rv;
+	a.addr = (struct sockaddr *)&addr;
+	a.addrlen = &addrlen;
+	prepare_accept(&a, self, argc, argv);
+	return my_accept(&a, 1);
 }
 
 /*
@@ -268,6 +300,8 @@ static VALUE tcp_tryaccept(int argc, VALUE *argv, VALUE io)
  *
  *	server = Kgio::TCPServer.new('0.0.0.0', 80)
  *	server.kgio_accept -> Kgio::Socket or nil
+ *	server.kgio_tryaccept -> Kgio::Socket or nil
+ *	server.kgio_tryaccept(klass = MySocket) -> MySocket or nil
  *
  * Initiates a blocking accept and returns a generic Kgio::Socket
  * object with the kgio_addr attribute set to the IP address of
@@ -276,20 +310,26 @@ static VALUE tcp_tryaccept(int argc, VALUE *argv, VALUE io)
  * On Ruby implementations using native threads, this can use a blocking
  * accept(2) (or accept4(2)) system call to avoid thundering herds.
  *
- * An optional class argument may be specified to override the
- * Kgio::Socket-class return value:
+ * An optional +klass+ argument may be specified to override the
+ * Kgio::Socket-class on a successful return value.
+ *
+ * An optional +flags+ argument may also be specifed to override the
+ * value of +Kgio.accept_cloexec+ and +Kgio.accept_nonblock+.  +flags+
+ * is a bitmask that may contain any combination of:
  *
- *      server.kgio_accept(MySocket) -> MySocket
+ * - Fcntl::FD_CLOEXEC - close-on-exec flag
+ * - IO::NONBLOCK - non-blocking flag
  */
-static VALUE tcp_accept(int argc, VALUE *argv, VALUE io)
+static VALUE tcp_accept(int argc, VALUE *argv, VALUE self)
 {
 	struct sockaddr_storage addr;
 	socklen_t addrlen = sizeof(struct sockaddr_storage);
-	VALUE klass = acceptor(argc, argv);
-	VALUE rv = my_accept(io, klass, (struct sockaddr *)&addr, &addrlen, 0);
+	struct accept_args a;
 
-	in_addr_set(rv, &addr, addrlen);
-	return rv;
+	a.addr = (struct sockaddr *)&addr;
+	a.addrlen = &addrlen;
+	prepare_accept(&a, self, argc, argv);
+	return my_accept(&a, 0);
 }
 
 /*
@@ -297,26 +337,31 @@ static VALUE tcp_accept(int argc, VALUE *argv, VALUE io)
  *
  *	server = Kgio::UNIXServer.new("/path/to/unix/socket")
  *	server.kgio_tryaccept -> Kgio::Socket or nil
+ *	server.kgio_tryaccept(klass = MySocket) -> MySocket or nil
+ *	server.kgio_tryaccept(nil, flags) -> Kgio::Socket or nil
  *
  * Initiates a non-blocking accept and returns a generic Kgio::Socket
  * object with the kgio_addr attribute set (to the value of
  * Kgio::LOCALHOST) on success.
  *
- * Returns nil on EAGAIN, and raises on other errors.
+ * An optional +klass+ argument may be specified to override the
+ * Kgio::Socket-class on a successful return value.
  *
- * An optional class argument may be specified to override the
- * Kgio::Socket-class return value:
+ * An optional +flags+ argument may also be specifed to override the
+ * value of +Kgio.accept_cloexec+ and +Kgio.accept_nonblock+.  +flags+
+ * is a bitmask that may contain any combination of:
  *
- *      server.kgio_tryaccept(MySocket) -> MySocket
+ * - Fcntl::FD_CLOEXEC - close-on-exec flag
+ * - IO::NONBLOCK - non-blocking flag
  */
-static VALUE unix_tryaccept(int argc, VALUE *argv, VALUE io)
+static VALUE unix_tryaccept(int argc, VALUE *argv, VALUE self)
 {
-	VALUE klass = acceptor(argc, argv);
-	VALUE rv = my_accept(io, klass, NULL, NULL, 1);
+	struct accept_args a;
 
-	if (!NIL_P(rv))
-		rb_ivar_set(rv, iv_kgio_addr, localhost);
-	return rv;
+	a.addr = NULL;
+	a.addrlen = NULL;
+	prepare_accept(&a, self, argc, argv);
+	return my_accept(&a, 1);
 }
 
 /*
@@ -324,6 +369,8 @@ static VALUE unix_tryaccept(int argc, VALUE *argv, VALUE io)
  *
  *	server = Kgio::UNIXServer.new("/path/to/unix/socket")
  *	server.kgio_accept -> Kgio::Socket or nil
+ *	server.kgio_accept(klass = MySocket) -> MySocket or nil
+ *	server.kgio_accept(nil, flags) -> Kgio::Socket or nil
  *
  * Initiates a blocking accept and returns a generic Kgio::Socket
  * object with the kgio_addr attribute set (to the value of
@@ -332,18 +379,24 @@ static VALUE unix_tryaccept(int argc, VALUE *argv, VALUE io)
  * On Ruby implementations using native threads, this can use a blocking
  * accept(2) (or accept4(2)) system call to avoid thundering herds.
  *
- * An optional class argument may be specified to override the
- * Kgio::Socket-class return value:
+ * An optional +klass+ argument may be specified to override the
+ * Kgio::Socket-class on a successful return value.
+ *
+ * An optional +flags+ argument may also be specifed to override the
+ * value of +Kgio.accept_cloexec+ and +Kgio.accept_nonblock+.  +flags+
+ * is a bitmask that may contain any combination of:
  *
- *      server.kgio_accept(MySocket) -> MySocket
+ * - Fcntl::FD_CLOEXEC - close-on-exec flag
+ * - IO::NONBLOCK - non-blocking flag
  */
-static VALUE unix_accept(int argc, VALUE *argv, VALUE io)
+static VALUE unix_accept(int argc, VALUE *argv, VALUE self)
 {
-	VALUE klass = acceptor(argc, argv);
-	VALUE rv = my_accept(io, klass, NULL, NULL, 0);
+	struct accept_args a;
 
-	rb_ivar_set(rv, iv_kgio_addr, localhost);
-	return rv;
+	a.addr = NULL;
+	a.addrlen = NULL;
+	prepare_accept(&a, self, argc, argv);
+	return my_accept(&a, 0);
 }
 
 /*
@@ -384,7 +437,7 @@ static VALUE get_nonblock(VALUE mod)
  * TCPServer#kgio_tryaccept,
  * UNIXServer#kgio_accept,
  * and UNIXServer#kgio_tryaccept
- * are created with the FD_CLOEXEC file descriptor flag.
+ * default to being created with the FD_CLOEXEC file descriptor flag.
  *
  * This is on by default, as there is little reason to deal to enable
  * it for client sockets on a socket server.

data/ext/kgio/autopush.c

@@ -242,6 +242,7 @@ static void push_pending_data(VALUE io)
 		rb_sys_fail("setsockopt(TCP_CORK/TCP_NOPUSH, 1)");
 }
 #else /* !KGIO_NOPUSH */
+void kgio_autopush_recv(VALUE io){}
 void init_kgio_autopush(void)
 {
 }

data/ext/kgio/broken_system_compat.h

@@ -0,0 +1,62 @@
+/*
+ * this header includes functions to support broken systems
+ * without clock_gettime() or CLOCK_MONOTONIC
+ */
+
+#ifndef HAVE_TYPE_CLOCKID_T
+typedef int clockid_t;
+#endif
+
+#ifndef HAVE_CLOCK_GETTIME
+#  ifndef CLOCK_REALTIME
+#    define CLOCK_REALTIME 0 /* whatever */
+#  endif
+static int fake_clock_gettime(clockid_t clk_id, struct timespec *res)
+{
+	struct timeval tv;
+	int r = gettimeofday(&tv, NULL);
+
+	assert(0 == r && "gettimeofday() broke!?");
+	res->tv_sec = tv.tv_sec;
+	res->tv_nsec = tv.tv_usec * 1000;
+
+	return r;
+}
+#  define clock_gettime fake_clock_gettime
+#endif /* broken systems w/o clock_gettime() */
+
+/*
+ * UGH
+ * CLOCK_MONOTONIC is not guaranteed to be a macro, either
+ */
+#ifndef CLOCK_MONOTONIC
+#  if (!defined(_POSIX_MONOTONIC_CLOCK) || !defined(HAVE_CLOCK_MONOTONIC))
+#    define CLOCK_MONOTONIC CLOCK_REALTIME
+#  endif
+#endif
+
+/*
+ * Availability of a monotonic clock needs to be detected at runtime
+ * since we could've been built on a different system than we're run
+ * under.
+ */
+static clockid_t hopefully_CLOCK_MONOTONIC;
+
+static int check_clock(void)
+{
+	struct timespec now;
+
+	hopefully_CLOCK_MONOTONIC = CLOCK_MONOTONIC;
+
+	/* we can't check this reliably at compile time */
+	if (clock_gettime(CLOCK_MONOTONIC, &now) == 0)
+		return 1;
+
+	if (clock_gettime(CLOCK_REALTIME, &now) == 0) {
+		hopefully_CLOCK_MONOTONIC = CLOCK_REALTIME;
+		rb_warn("CLOCK_MONOTONIC not available, "
+			"falling back to CLOCK_REALTIME");
+		return 2;
+	}
+	return -1;
+}

data/ext/kgio/connect.c

@@ -69,6 +69,7 @@ static VALUE tcp_connect(VALUE klass, VALUE ip, VALUE port, int io_wait)
 	rc = snprintf(ipport, sizeof(ipport), "%u", uport);
 	if (rc >= (int)sizeof(ipport) || rc <= 0)
 		rb_raise(rb_eArgError, "invalid TCP port: %u", uport);
+	memset(&hints, 0, sizeof(hints));
 	hints.ai_family = AF_UNSPEC;
 	hints.ai_socktype = SOCK_STREAM;
 	hints.ai_protocol = IPPROTO_TCP;

data/ext/kgio/extconf.rb

@@ -1,7 +1,12 @@
 require 'mkmf'
 $CPPFLAGS << ' -D_GNU_SOURCE'
 $CPPFLAGS << ' -DPOSIX_C_SOURCE=1'
-
+$CPPFLAGS += '-D_POSIX_C_SOURCE=200112L'
+unless have_macro('CLOCK_MONOTONIC', 'time.h')
+  have_func('CLOCK_MONOTONIC', 'time.h')
+end
+have_type('clockid_t', 'time.h')
+have_library('rt', 'clock_gettime', 'time.h')
 have_func("poll", "poll.h")
 have_func("getaddrinfo", %w(sys/types.h sys/socket.h netdb.h)) or
   abort "getaddrinfo required"
@@ -30,5 +35,4 @@ have_func('rb_thread_blocking_region')
 have_func('rb_thread_io_blocking_region')
 have_func('rb_str_set_len')
 
-dir_config('kgio')
 create_makefile('kgio_ext')

data/ext/kgio/poll.c

@@ -1,6 +1,9 @@
 #include "kgio.h"
 #if defined(USE_KGIO_POLL)
+#include <time.h>
+#include "broken_system_compat.h"
 #include <poll.h>
+#include <errno.h>
 #ifdef HAVE_RUBY_ST_H
 #  include <ruby/st.h>
 #else
@@ -16,8 +19,43 @@ struct poll_args {
 	int timeout;
 	VALUE ios;
 	st_table *fd_to_io;
+	struct timespec start;
 };
 
+static int interrupted(void)
+{
+	switch (errno) {
+	case EINTR:
+#ifdef ERESTART
+	case ERESTART:
+#endif
+		return 1;
+	}
+	return 0;
+}
+
+static int retryable(struct poll_args *a)
+{
+	struct timespec ts;
+
+	if (a->timeout < 0)
+		return 1;
+	if (a->timeout == 0)
+		return 0;
+
+	clock_gettime(hopefully_CLOCK_MONOTONIC, &ts);
+
+	ts.tv_sec -= a->start.tv_sec;
+	ts.tv_nsec -= a->start.tv_nsec;
+	if (ts.tv_nsec < 0) {
+		ts.tv_sec--;
+		ts.tv_nsec += 1000000000;
+	}
+	a->timeout -= ts.tv_sec * 1000;
+	a->timeout -= ts.tv_nsec / 1000000;
+	return (a->timeout >= 0);
+}
+
 static int num2timeout(VALUE timeout)
 {
 	switch (TYPE(timeout)) {
@@ -62,6 +100,7 @@ static int io_to_pollfd_i(VALUE key, VALUE value, VALUE args)
 
 static void hash2pollfds(struct poll_args *a)
 {
+	a->nfds = 0;
 	a->fds = xmalloc(sizeof(struct pollfd) * RHASH_SIZE(a->ios));
 	a->fd_to_io = st_init_numtable();
 	rb_hash_foreach(a->ios, io_to_pollfd_i, (VALUE)a);
@@ -70,6 +109,10 @@ static void hash2pollfds(struct poll_args *a)
 static VALUE nogvl_poll(void *ptr)
 {
 	struct poll_args *a = ptr;
+
+	if (a->timeout > 0)
+		clock_gettime(hopefully_CLOCK_MONOTONIC, &a->start);
+
 	return (VALUE)poll(a->fds, a->nfds, a->timeout);
 }
 
@@ -98,10 +141,20 @@ static VALUE do_poll(VALUE args)
 	int nr;
 
 	Check_Type(a->ios, T_HASH);
-	hash2pollfds(a);
 
+retry:
+	hash2pollfds(a);
 	nr = (int)rb_thread_blocking_region(nogvl_poll, a, RUBY_UBF_IO, NULL);
-	if (nr < 0) rb_sys_fail("poll");
+	if (nr < 0) {
+		if (interrupted()) {
+			if (retryable(a)) {
+				poll_free(args);
+				goto retry;
+			}
+			return Qnil;
+		}
+		rb_sys_fail("poll");
+	}
 	if (nr == 0) return Qnil;
 
 	return poll_result(nr, a);
@@ -146,7 +199,6 @@ static VALUE s_poll(int argc, VALUE *argv, VALUE self)
 
 	rb_scan_args(argc, argv, "11", &a.ios, &timeout);
 	a.timeout = num2timeout(timeout);
-	a.nfds = 0;
 	a.fds = NULL;
 	a.fd_to_io = NULL;
 
@@ -156,6 +208,9 @@ static VALUE s_poll(int argc, VALUE *argv, VALUE self)
 void init_kgio_poll(void)
 {
 	VALUE mKgio = rb_define_module("Kgio");
+
+	if (check_clock() < 0)
+		return;
 	rb_define_singleton_method(mKgio, "poll", s_poll, -1);
 
 	sym_wait_readable = ID2SYM(rb_intern("wait_readable"));

data/ext/kgio/read_write.c

@@ -68,6 +68,7 @@ static void prepare_read(struct io_args *a, int argc, VALUE *argv, VALUE io)
 		a->buf = rb_str_new(NULL, a->len);
 	} else {
 		StringValue(a->buf);
+		rb_str_modify(a->buf);
 		rb_str_resize(a->buf, a->len);
 	}
 	a->ptr = RSTRING_PTR(a->buf);
@@ -76,14 +77,17 @@ static void prepare_read(struct io_args *a, int argc, VALUE *argv, VALUE io)
 static int read_check(struct io_args *a, long n, const char *msg, int io_wait)
 {
 	if (n == -1) {
-		if (errno == EINTR)
+		if (errno == EINTR) {
+			a->fd = my_fileno(a->io);
 			return -1;
+		}
 		rb_str_set_len(a->buf, 0);
 		if (errno == EAGAIN) {
 			if (io_wait) {
 				(void)kgio_call_wait_readable(a->io);
 
 				/* buf may be modified in other thread/fiber */
+				rb_str_modify(a->buf);
 				rb_str_resize(a->buf, a->len);
 				a->ptr = RSTRING_PTR(a->buf);
 				return -1;
@@ -307,8 +311,10 @@ static int write_check(struct io_args *a, long n, const char *msg, int io_wait)
 done:
 		a->buf = Qnil;
 	} else if (n == -1) {
-		if (errno == EINTR)
+		if (errno == EINTR) {
+			a->fd = my_fileno(a->io);
 			return -1;
+		}
 		if (errno == EAGAIN) {
 			long written = RSTRING_LEN(a->buf) - a->len;
 
@@ -370,7 +376,7 @@ static VALUE kgio_write(VALUE io, VALUE str)
 /*
  * call-seq:
  *
- *	io.kgio_trywrite(str)	-> nil or :wait_writable
+ *	io.kgio_trywrite(str)	-> nil, String or :wait_writable
  *
  * Returns nil if the write was completed in full.
  *
@@ -451,7 +457,7 @@ static VALUE s_tryread(int argc, VALUE *argv, VALUE mod)
 /*
  * call-seq:
  *
- *	Kgio.trywrite(io, str)    -> nil or :wait_writable
+ *	Kgio.trywrite(io, str)    -> nil, String or :wait_writable
  *
  * Returns nil if the write was completed in full.
  *

data/kgio.gemspec

@@ -15,13 +15,12 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = extra_rdoc_files(manifest)
   s.files = manifest
   s.rdoc_options = rdoc_options
-  s.require_paths = %w(lib ext)
   s.rubyforge_project = %q{rainbows}
   s.summary = summary
   s.test_files = Dir['test/test_*.rb']
   s.extensions = %w(ext/kgio/extconf.rb)
 
-  s.add_development_dependency('wrongdoc', '~> 1.4')
+  s.add_development_dependency('wrongdoc', '~> 1.5')
   s.add_development_dependency('strace_me', '~> 1.0')
 
   # s.license = %w(LGPL) # disabled for compatibility with older RubyGems

data/test/lib_read_write.rb

@@ -30,6 +30,24 @@ module LibReadWriteTest
     assert_equal "", buf
   end
 
+  def test_read_shared
+    a = "." * 0x1000
+    b = a.dup
+    @wr.syswrite "a"
+    assert_equal "a", @rd.kgio_read(0x1000, a)
+    assert_equal "a", a
+    assert_equal "." * 0x1000, b
+  end
+
+  def test_read_shared_2
+    a = "." * 0x1000
+    b = a.dup
+    @wr.syswrite "a"
+    assert_equal "a", @rd.kgio_read(0x1000, b)
+    assert_equal "a", b
+    assert_equal "." * 0x1000, a
+  end
+
   def test_tryread_zero
     assert_equal "", @rd.kgio_tryread(0)
     buf = "foo"
@@ -37,6 +55,24 @@ module LibReadWriteTest
     assert_equal "", buf
   end
 
+  def test_tryread_shared
+    a = "." * 0x1000
+    b = a.dup
+    @wr.syswrite("a")
+    assert_equal "a", @rd.kgio_tryread(0x1000, b)
+    assert_equal "a", b
+    assert_equal "." * 0x1000, a
+  end
+
+  def test_tryread_shared_2
+    a = "." * 0x1000
+    b = a.dup
+    @wr.syswrite("a")
+    assert_equal "a", @rd.kgio_tryread(0x1000, a)
+    assert_equal "a", a
+    assert_equal "." * 0x1000, b
+  end
+
   def test_read_eof
     @wr.close
     assert_nil @rd.kgio_read(5)

data/test/lib_server_accept.rb

@@ -1,4 +1,5 @@
 require 'test/unit'
+require 'fcntl'
 require 'io/nonblock'
 $-w = true
 require 'kgio'
@@ -19,6 +20,24 @@ module LibServerAccept
     assert_equal @host, b.kgio_addr
   end
 
+  def test_tryaccept_flags
+    a = client_connect
+    IO.select([@srv])
+    b = @srv.kgio_tryaccept nil, 0
+    assert_kind_of Kgio::Socket, b
+    assert_equal false, b.nonblock?
+    assert_equal 0, b.fcntl(Fcntl::F_GETFD)
+  end
+
+  def test_blocking_accept_flags
+    a = client_connect
+    IO.select([@srv])
+    b = @srv.kgio_accept nil, 0
+    assert_kind_of Kgio::Socket, b
+    assert_equal false, b.nonblock?
+    assert_equal 0, b.fcntl(Fcntl::F_GETFD)
+  end
+
   def test_tryaccept_fail
     assert_equal nil, @srv.kgio_tryaccept
   end

data/test/test_autopush.rb

@@ -94,7 +94,7 @@ class TestAutopush < Test::Unit::TestCase
     @rd.kgio_write "HI\n"
     @wr.kgio_read(3, rbuf)
     diff = Time.now - t0
-    assert(diff >= 0.200, "nopush broken? diff=#{diff} > 200ms")
+    assert(diff >= 0.190, "nopush broken? diff=#{diff} > 200ms")
     assert_equal "HI\n", rbuf
   end
 

data/test/test_cross_thread_close.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+$-w = true
+require 'kgio'
+
+class TestCrossThreadClose < Test::Unit::TestCase
+
+  def test_cross_thread_close
+    host = ENV["TEST_HOST"] || '127.0.0.1'
+    srv = Kgio::TCPServer.new(host, 0)
+    thr = Thread.new do
+      begin
+        srv.kgio_accept
+      rescue => e
+        e
+      end
+    end
+    sleep(0.1) until thr.stop?
+    srv.close
+    unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" &&
+           RUBY_VERSION == "1.9.3"
+      thr.run rescue nil
+    end
+    thr.join
+    assert_kind_of IOError, thr.value
+  end
+end if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby"

data/test/test_poll.rb

@@ -42,27 +42,52 @@ class TestPoll < Test::Unit::TestCase
     assert_nil res
   end
 
-  def test_poll_interrupt
+  def test_poll_close
     foo = nil
-    oldquit = trap(:QUIT) { foo = :bar }
-    thr = Thread.new { sleep 0.100; Process.kill(:QUIT, $$) }
+    thr = Thread.new { sleep 0.100; @wr.close }
     t0 = Time.now
-    assert_raises(Errno::EINTR) { Kgio.poll({}) }
+    res = Kgio.poll({@rd => Kgio::POLLIN})
     diff = Time.now - t0
     thr.join
+    assert_equal([ @rd ], res.keys)
     assert diff >= 0.010, "diff=#{diff}"
+  end
+
+  def test_poll_EINTR
+    ok = false
+    orig = trap(:USR1) { ok = true }
+    thr = Thread.new do
+      sleep 0.100
+      Process.kill(:USR1, $$)
+    end
+    t0 = Time.now
+    res = Kgio.poll({@rd => Kgio::POLLIN}, 1000)
+    diff = Time.now - t0
+    thr.join
+    assert_nil res
+    assert diff >= 1.0, "diff=#{diff}"
+    assert ok
     ensure
-      trap(:QUIT, "DEFAULT")
+      trap(:USR1, orig)
   end
 
-  def test_poll_close
-    foo = nil
-    thr = Thread.new { sleep 0.100; @wr.close }
+  def test_poll_EINTR_changed
+    ok = false
+    orig = trap(:USR1) { ok = true }
+    pollset = { @rd => Kgio::POLLIN }
+    thr = Thread.new do
+      sleep 0.100
+      pollset[@wr] = Kgio::POLLOUT
+      Process.kill(:USR1, $$)
+    end
     t0 = Time.now
-    res = Kgio.poll({@rd => Kgio::POLLIN})
+    res = Kgio.poll(pollset, 1000)
     diff = Time.now - t0
     thr.join
-    assert_equal([ @rd ], res.keys)
-    assert diff >= 0.010, "diff=#{diff}"
+    assert_equal({@wr => Kgio::POLLOUT}, res)
+    assert diff < 1.0, "diff=#{diff}"
+    assert ok
+    ensure
+      trap(:USR1, orig)
   end
 end if Kgio.respond_to?(:poll)

data/test/test_tcp_connect.rb

@@ -66,7 +66,7 @@ class TestKgioTcpConnect < Test::Unit::TestCase
 
   def test_wait_writable_set
     sock = SubSocket.new(@addr)
-    assert_equal "waited", sock.foo
+    assert_equal "waited", sock.foo if RUBY_PLATFORM =~ /linux/
     assert_equal nil, sock.kgio_write("HELLO")
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kgio
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 31
   prerelease: 
   segments: 
   - 2
-  - 3
-  - 3
-  version: 2.3.3
+  - 4
+  - 0
+  version: 2.4.0
 platform: ruby
 authors: 
 - kgio hackers
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-15 00:00:00 +00:00
-default_executable: 
+date: 2011-05-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: wrongdoc
@@ -26,11 +25,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 5
         segments: 
         - 1
-        - 4
-        version: "1.4"
+        - 5
+        version: "1.5"
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -97,6 +96,7 @@ files:
 - ext/kgio/ancient_ruby.h
 - ext/kgio/autopush.c
 - ext/kgio/blocking_io_region.h
+- ext/kgio/broken_system_compat.h
 - ext/kgio/connect.c
 - ext/kgio/extconf.rb
 - ext/kgio/kgio.h
@@ -117,6 +117,7 @@ files:
 - test/test_accept_class.rb
 - test/test_autopush.rb
 - test/test_connect_fd_leak.rb
+- test/test_cross_thread_close.rb
 - test/test_default_wait.rb
 - test/test_kgio_addr.rb
 - test/test_no_dns_on_tcp_connect.rb
@@ -135,7 +136,6 @@ files:
 - test/test_unix_connect.rb
 - test/test_unix_server.rb
 - test/test_unix_server_read_client_write.rb
-has_rdoc: true
 homepage: http://bogomips.org/kgio/
 licenses: []
 
@@ -147,7 +147,6 @@ rdoc_options:
 - http://bogomips.org/kgio.git/tree/%s
 require_paths: 
 - lib
-- ext
 required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
@@ -169,7 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rainbows
-rubygems_version: 1.6.1
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: kinder, gentler I/O for Ruby
@@ -184,6 +183,7 @@ test_files:
 - test/test_socketpair_read_write.rb
 - test/test_tcp_server.rb
 - test/test_unix_server_read_client_write.rb
+- test/test_cross_thread_close.rb
 - test/test_tcp_connect.rb
 - test/test_autopush.rb
 - test/test_connect_fd_leak.rb