kgio 2.1.1 → 2.2.0

data/ext/kgio/connect.c

@@ -57,20 +57,37 @@ my_connect(VALUE klass, int io_wait, int domain, void *addr, socklen_t addrlen)
 
 static VALUE tcp_connect(VALUE klass, VALUE ip, VALUE port, int io_wait)
 {
-	struct sockaddr_in addr = { 0 };
+	struct addrinfo hints;
+	struct sockaddr_storage addr;
+	int rc;
+	struct addrinfo *res;
+	VALUE sock;
+	const char *ipname = StringValuePtr(ip);
+	char ipport[6];
+	unsigned uport = FIX2UINT(port);
 
-	addr.sin_family = AF_INET;
-	addr.sin_port = htons((unsigned short)NUM2INT(port));
+	rc = snprintf(ipport, sizeof(ipport), "%u", uport);
+	if (rc >= (int)sizeof(ipport) || rc <= 0)
+		rb_raise(rb_eArgError, "invalid TCP port: %u", uport);
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_protocol = IPPROTO_TCP;
+	/* disallow non-deterministic DNS lookups */
+	hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
 
-	switch (inet_pton(AF_INET, StringValuePtr(ip), &addr.sin_addr)) {
-	case 1:
-		return my_connect(klass, io_wait, PF_INET, &addr, sizeof(addr));
-	case -1:
-		rb_sys_fail("inet_pton");
-	}
-	rb_raise(rb_eArgError, "invalid address: %s", StringValuePtr(ip));
+	rc = getaddrinfo(ipname, ipport, &hints, &res);
+	if (rc != 0)
+		rb_raise(rb_eArgError, "getaddrinfo(%s:%s): %s",
+			 ipname, ipport, gai_strerror(rc));
+
+	/* copy needed data and free ASAP to avoid needing rb_ensure */
+	hints.ai_family = res->ai_family;
+	hints.ai_addrlen = res->ai_addrlen;
+	memcpy(&addr, res->ai_addr, res->ai_addrlen);
+	freeaddrinfo(res);
 
-	return Qnil;
+	return my_connect(klass, io_wait, hints.ai_family,
+	                  &addr, hints.ai_addrlen);
 }
 
 /*
@@ -173,12 +190,10 @@ static VALUE stream_connect(VALUE klass, VALUE addr, int io_wait)
 	} else {
 		rb_raise(rb_eTypeError, "invalid address");
 	}
-	switch (((struct sockaddr_in *)(sockaddr))->sin_family) {
+	switch (((struct sockaddr_storage *)(sockaddr))->ss_family) {
 	case AF_UNIX: domain = PF_UNIX; break;
 	case AF_INET: domain = PF_INET; break;
-#ifdef AF_INET6 /* IPv6 support incomplete */
 	case AF_INET6: domain = PF_INET6; break;
-#endif /* AF_INET6 */
 	default:
 		rb_raise(rb_eArgError, "invalid address family");
 	}

data/ext/kgio/extconf.rb

@@ -1,10 +1,18 @@
 require 'mkmf'
 $CPPFLAGS << ' -D_GNU_SOURCE'
+$CPPFLAGS << ' -DPOSIX_C_SOURCE=1'
 
+have_func("getaddrinfo", %w(sys/types.h sys/socket.h netdb.h)) or
+  abort "getaddrinfo required"
+have_func("getnameinfo", %w(sys/socket.h netdb.h)) or
+  abort "getnameinfo required"
+have_type("struct sockaddr_storage", %w(sys/types.h sys/socket.h)) or
+  abort "struct sockaddr_storage required"
 have_func('accept4', %w(sys/socket.h))
 if have_header('ruby/io.h')
-  have_struct_member("rb_io_t", "fd", "ruby/io.h")
-  have_struct_member("rb_io_t", "mode", "ruby/io.h")
+  rubyio = %w(ruby.h ruby/io.h)
+  have_struct_member("rb_io_t", "fd", rubyio)
+  have_struct_member("rb_io_t", "mode", rubyio)
 else
   rubyio = %w(ruby.h rubyio.h)
   rb_io_t = have_type("OpenFile", rubyio) ? "OpenFile" : "rb_io_t"
@@ -13,6 +21,9 @@ else
   have_struct_member(rb_io_t, "mode", rubyio)
   have_func('rb_fdopen')
 end
+have_type("struct RFile", rubyio) and check_sizeof("struct RFile", rubyio)
+have_type("struct RObject") and check_sizeof("struct RObject")
+check_sizeof("int")
 have_func('rb_io_ascii8bit_binmode')
 have_func('rb_thread_blocking_region')
 have_func('rb_str_set_len')

data/ext/kgio/kgio.h

@@ -16,8 +16,9 @@
 #include <unistd.h>
 #include <arpa/inet.h>
 #include <assert.h>
+#include <netdb.h>
 
-#include "missing/ancient_ruby.h"
+#include "ancient_ruby.h"
 #include "nonblock.h"
 #include "my_fileno.h"
 
@@ -33,6 +34,11 @@ void init_kgio_wait(void);
 void init_kgio_read_write(void);
 void init_kgio_accept(void);
 void init_kgio_connect(void);
+void init_kgio_autopush(void);
+
+void kgio_autopush_accept(VALUE, VALUE);
+void kgio_autopush_recv(VALUE);
+void kgio_autopush_send(VALUE);
 
 VALUE kgio_call_wait_writable(VALUE io);
 VALUE kgio_call_wait_readable(VALUE io);

data/ext/kgio/kgio_ext.c

@@ -6,4 +6,5 @@ void Init_kgio_ext(void)
 	init_kgio_read_write();
 	init_kgio_connect();
 	init_kgio_accept();
+	init_kgio_autopush();
 }

data/ext/kgio/read_write.c

@@ -1,6 +1,7 @@
 #include "kgio.h"
 static VALUE sym_wait_readable, sym_wait_writable;
 static VALUE eErrno_EPIPE, eErrno_ECONNRESET;
+static ID id_set_backtrace;
 
 /*
  * we know MSG_DONTWAIT works properly on all stream sockets under Linux
@@ -14,13 +15,14 @@ static VALUE eErrno_EPIPE, eErrno_ECONNRESET;
 NORETURN(static void raise_empty_bt(VALUE, const char *));
 NORETURN(static void my_eof_error(void));
 NORETURN(static void wr_sys_fail(const char *));
+NORETURN(static void rd_sys_fail(const char *));
 
 static void raise_empty_bt(VALUE err, const char *msg)
 {
 	VALUE exc = rb_exc_new2(err, msg);
 	VALUE bt = rb_ary_new();
 
-	rb_funcall(exc, rb_intern("set_backtrace"), 1, bt);
+	rb_funcall(exc, id_set_backtrace, 1, bt);
 	rb_exc_raise(exc);
 }
 
@@ -42,6 +44,15 @@ static void wr_sys_fail(const char *msg)
 	rb_sys_fail(msg);
 }
 
+static void rd_sys_fail(const char *msg)
+{
+	if (errno == ECONNRESET) {
+		errno = 0;
+		raise_empty_bt(eErrno_ECONNRESET, msg);
+	}
+	rb_sys_fail(msg);
+}
+
 static void prepare_read(struct io_args *a, int argc, VALUE *argv, VALUE io)
 {
 	VALUE length;
@@ -78,7 +89,7 @@ static int read_check(struct io_args *a, long n, const char *msg, int io_wait)
 				return 0;
 			}
 		}
-		rb_sys_fail(msg);
+		rd_sys_fail(msg);
 	}
 	rb_str_set_len(a->buf, n);
 	if (n == 0)
@@ -164,6 +175,7 @@ static VALUE my_recv(int io_wait, int argc, VALUE *argv, VALUE io)
 	long n;
 
 	prepare_read(&a, argc, argv, io);
+	kgio_autopush_recv(io);
 
 	if (a.len > 0) {
 retry:
@@ -320,6 +332,8 @@ retry:
 	n = (long)send(a.fd, a.ptr, a.len, MSG_DONTWAIT);
 	if (write_check(&a, n, "send", io_wait) != 0)
 		goto retry;
+	if (TYPE(a.buf) != T_SYMBOL)
+		kgio_autopush_send(io);
 	return a.buf;
 }
 
@@ -347,6 +361,44 @@ static VALUE kgio_trysend(VALUE io, VALUE str)
 #  define kgio_trysend kgio_trywrite
 #endif /* ! USE_MSG_DONTWAIT */
 
+/*
+ * call-seq:
+ *
+ *	Kgio.tryread(io, maxlen)           ->  buffer
+ *	Kgio.tryread(io, maxlen, buffer)   ->  buffer
+ *
+ * Returns nil on EOF.
+ * Returns :wait_readable if EAGAIN is encountered.
+ *
+ * Maybe used in place of PipeMethods#kgio_tryread for non-Kgio objects
+ */
+static VALUE s_tryread(int argc, VALUE *argv, VALUE mod)
+{
+	if (argc <= 1)
+		rb_raise(rb_eArgError, "wrong number of arguments");
+	return my_read(0, argc - 1, &argv[1], argv[0]);
+}
+
+/*
+ * call-seq:
+ *
+ *	Kgio.trywrite(io, str)    -> nil or :wait_writable
+ *
+ * Returns nil if the write was completed in full.
+ *
+ * Returns a String containing the unwritten portion if EAGAIN
+ * was encountered, but some portion was successfully written.
+ *
+ * Returns :wait_writable if EAGAIN is encountered and nothing
+ * was written.
+ *
+ * Maybe used in place of PipeMethods#kgio_trywrite for non-Kgio objects
+ */
+static VALUE s_trywrite(VALUE mod, VALUE io, VALUE str)
+{
+	return my_write(io, str, 0);
+}
+
 void init_kgio_read_write(void)
 {
 	VALUE mPipeMethods, mSocketMethods;
@@ -356,6 +408,9 @@ void init_kgio_read_write(void)
 	sym_wait_readable = ID2SYM(rb_intern("wait_readable"));
 	sym_wait_writable = ID2SYM(rb_intern("wait_writable"));
 
+	rb_define_singleton_method(mKgio, "tryread", s_tryread, -1);
+	rb_define_singleton_method(mKgio, "trywrite", s_trywrite, 2);
+
 	/*
 	 * Document-module: Kgio::PipeMethods
 	 *
@@ -390,7 +445,7 @@ void init_kgio_read_write(void)
 	 * Kgio::LOCALHOST constant for UNIX domain sockets.
 	 */
 	rb_define_attr(mSocketMethods, "kgio_addr", 1, 1);
-
+	id_set_backtrace = rb_intern("set_backtrace");
 	eErrno_EPIPE = rb_const_get(rb_mErrno, rb_intern("EPIPE"));
 	eErrno_ECONNRESET = rb_const_get(rb_mErrno, rb_intern("ECONNRESET"));
 	rb_include_module(mPipeMethods, mWaiters);

data/kgio.gemspec

@@ -21,7 +21,8 @@ Gem::Specification.new do |s|
   s.test_files = Dir['test/test_*.rb']
   s.extensions = %w(ext/kgio/extconf.rb)
 
-  s.add_development_dependency('wrongdoc', '~> 1.0.1')
+  s.add_development_dependency('wrongdoc', '~> 1.4')
+  s.add_development_dependency('strace_me', '~> 1.0')
 
   # s.license = %w(LGPL) # disabled for compatibility with older RubyGems
 end

data/pkg.mk

@@ -0,0 +1,168 @@
+RUBY = ruby
+RAKE = rake
+RSYNC = rsync
+WRONGDOC = wrongdoc
+
+GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
+	@./GIT-VERSION-GEN
+-include GIT-VERSION-FILE
+-include local.mk
+DLEXT := $(shell $(RUBY) -rrbconfig -e 'puts Config::CONFIG["DLEXT"]')
+RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
+RUBY_ENGINE := $(shell $(RUBY) -e 'puts((RUBY_ENGINE rescue "ruby"))')
+lib := lib
+
+ifeq ($(shell test -f script/isolate_for_tests && echo t),t)
+isolate_libs := tmp/isolate/$(RUBY_ENGINE)-$(RUBY_VERSION)/isolate.mk
+$(isolate_libs): script/isolate_for_tests
+	@$(RUBY) script/isolate_for_tests
+-include $(isolate_libs)
+lib := $(lib):$(ISOLATE_LIBS)
+endif
+
+ext := $(firstword $(wildcard ext/*))
+ifneq ($(ext),)
+ext_pfx := tmp/ext/$(RUBY_ENGINE)-$(RUBY_VERSION)
+ext_h := $(wildcard $(ext)/*/*.h $(ext)/*.h)
+ext_src := $(wildcard $(ext)/*.c $(ext_h))
+ext_pfx_src := $(addprefix $(ext_pfx)/,$(ext_src))
+ext_d := $(ext_pfx)/$(ext)/.d
+$(ext)/extconf.rb: $(wildcard $(ext)/*.h)
+	@>> $@
+$(ext_d):
+	@mkdir -p $(@D)
+	@> $@
+$(ext_pfx)/$(ext)/%: $(ext)/% $(ext_d)
+	install -m 644 $< $@
+$(ext_pfx)/$(ext)/Makefile: $(ext)/extconf.rb $(ext_d) $(ext_h)
+	$(RM) -f $(@D)/*.o
+	cd $(@D) && $(RUBY) $(CURDIR)/$(ext)/extconf.rb
+ext_sfx := _ext.$(DLEXT)
+ext_dl := $(ext_pfx)/$(ext)/$(notdir $(ext)_ext.$(DLEXT))
+$(ext_dl): $(ext_src) $(ext_pfx_src) $(ext_pfx)/$(ext)/Makefile
+	@echo $^ == $@
+	$(MAKE) -C $(@D)
+lib := $(lib):$(ext_pfx)/$(ext)
+build: $(ext_dl)
+endif
+
+pkg_extra := GIT-VERSION-FILE NEWS ChangeLog LATEST
+ChangeLog: GIT-VERSION-FILE .wrongdoc.yml
+	$(WRONGDOC) prepare
+
+manifest:
+	$(RM) .manifest
+	$(MAKE) .manifest
+
+.manifest: ChangeLog
+	(git ls-files && for i in $@ $(pkg_extra); do echo $$i; done) | \
+		LC_ALL=C sort > $@+
+	cmp $@+ $@ || mv $@+ $@
+	$(RM) $@+
+
+doc:: .document .wrongdoc.yml
+	find lib -type f -name '*.rbc' -exec rm -f '{}' ';'
+	-find ext -type f -name '*.rbc' -exec rm -f '{}' ';'
+	$(RM) -r doc
+	$(WRONGDOC) all
+	install -m644 COPYING doc/COPYING
+	install -m644 $(shell grep '^[A-Z]' .document) doc/
+
+ifneq ($(VERSION),)
+pkggem := pkg/$(rfpackage)-$(VERSION).gem
+pkgtgz := pkg/$(rfpackage)-$(VERSION).tgz
+release_notes := release_notes-$(VERSION)
+release_changes := release_changes-$(VERSION)
+
+release-notes: $(release_notes)
+release-changes: $(release_changes)
+$(release_changes):
+	$(WRONGDOC) release_changes > $@+
+	$(VISUAL) $@+ && test -s $@+ && mv $@+ $@
+$(release_notes):
+	$(WRONGDOC) release_notes > $@+
+	$(VISUAL) $@+ && test -s $@+ && mv $@+ $@
+
+# ensures we're actually on the tagged $(VERSION), only used for release
+verify:
+	test x"$(shell umask)" = x0022
+	git rev-parse --verify refs/tags/v$(VERSION)^{}
+	git diff-index --quiet HEAD^0
+	test $$(git rev-parse --verify HEAD^0) = \
+	     $$(git rev-parse --verify refs/tags/v$(VERSION)^{})
+
+fix-perms:
+	-git ls-tree -r HEAD | awk '/^100644 / {print $$NF}' | xargs chmod 644
+	-git ls-tree -r HEAD | awk '/^100755 / {print $$NF}' | xargs chmod 755
+
+gem: $(pkggem)
+
+install-gem: $(pkggem)
+	gem install $(CURDIR)/$<
+
+$(pkggem): manifest fix-perms
+	gem build $(rfpackage).gemspec
+	mkdir -p pkg
+	mv $(@F) $@
+
+$(pkgtgz): distdir = $(basename $@)
+$(pkgtgz): HEAD = v$(VERSION)
+$(pkgtgz): manifest fix-perms
+	@test -n "$(distdir)"
+	$(RM) -r $(distdir)
+	mkdir -p $(distdir)
+	tar cf - $$(cat .manifest) | (cd $(distdir) && tar xf -)
+	cd pkg && tar cf - $(basename $(@F)) | gzip -9 > $(@F)+
+	mv $@+ $@
+
+package: $(pkgtgz) $(pkggem)
+
+test-release:: verify package $(release_notes) $(release_changes)
+	# make tgz release on RubyForge
+	@echo rubyforge add_release -f \
+	  -n $(release_notes) -a $(release_changes) \
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkgtgz)
+	@echo gem push $(pkggem)
+	@echo rubyforge add_file \
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkggem)
+release:: verify package $(release_notes) $(release_changes)
+	# make tgz release on RubyForge
+	rubyforge add_release -f -n $(release_notes) -a $(release_changes) \
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkgtgz)
+	# push gem to RubyGems.org
+	gem push $(pkggem)
+	# in case of gem downloads from RubyForge releases page
+	rubyforge add_file \
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkggem)
+else
+gem install-gem: GIT-VERSION-FILE
+	$(MAKE) $@ VERSION=$(GIT_VERSION)
+endif
+
+all:: test
+test_units := $(wildcard test/test_*.rb)
+test: test-unit
+test-unit: $(test_units)
+$(test_units): build
+	$(RUBY) -I $(lib) $@
+
+# this requires GNU coreutils variants
+ifneq ($(RSYNC_DEST),)
+publish_doc:
+	-git set-file-times
+	$(MAKE) doc
+	find doc/images -type f | \
+		TZ=UTC xargs touch -d '1970-01-01 00:00:06' doc/rdoc.css
+	$(MAKE) doc_gz
+	$(RSYNC) -av doc/ $(RSYNC_DEST)/
+	git ls-files | xargs touch
+endif
+
+# Create gzip variants of the same timestamp as the original so nginx
+# "gzip_static on" can serve the gzipped versions directly.
+doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.\(gif\|jpg\|png\|gz\)$$')
+doc_gz:
+	for i in $(docs); do \
+	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
+
+.PHONY: all .FORCE-GIT-VERSION-FILE doc test $(test_units) manifest

data/test/lib_read_write.rb

@@ -10,11 +10,19 @@ module LibReadWriteTest
 
   def teardown
     assert_nothing_raised do
-      @rd.close unless @rd.closed?
-      @wr.close unless @wr.closed?
+      @rd.close if defined?(@rd) && ! @rd.closed?
+      @wr.close if defined?(@wr) && ! @wr.closed?
     end
   end
 
+  def test_write_empty
+    assert_nil @wr.kgio_write("")
+  end
+
+  def test_trywrite_empty
+    assert_nil @wr.kgio_trywrite("")
+  end
+
   def test_read_zero
     assert_equal "", @rd.kgio_read(0)
     buf = "foo"

data/test/test_autopush.rb

@@ -0,0 +1,165 @@
+require 'tempfile'
+require 'test/unit'
+RUBY_PLATFORM =~ /linux/ and require 'strace'
+$-w = true
+require 'kgio'
+
+class TestAutopush < Test::Unit::TestCase
+  TCP_CORK = 3
+  TCP_NOPUSH = 4
+
+  def setup
+    Kgio.autopush = false
+    assert_equal false, Kgio.autopush?
+
+    @host = ENV["TEST_HOST"] || '127.0.0.1'
+    @srv = Kgio::TCPServer.new(@host, 0)
+    assert_nothing_raised {
+      @srv.setsockopt(Socket::IPPROTO_TCP, TCP_CORK, 1)
+    } if RUBY_PLATFORM =~ /linux/
+    assert_nothing_raised {
+      @srv.setsockopt(Socket::IPPROTO_TCP, TCP_NOPUSH, 1)
+    } if RUBY_PLATFORM =~ /freebsd/
+    @port = @srv.addr[1]
+  end
+
+  def test_autopush_accessors
+    Kgio.autopush = true
+    opt = RUBY_PLATFORM =~ /freebsd/ ? TCP_NOPUSH : TCP_CORK
+    s = Kgio::TCPSocket.new(@host, @port)
+    assert_equal 0, s.getsockopt(Socket::IPPROTO_TCP, opt).unpack('i')[0]
+    assert ! s.kgio_autopush?
+    s.kgio_autopush = true
+    assert s.kgio_autopush?
+    assert_nothing_raised { s.kgio_write 'asdf' }
+    assert_equal :wait_readable, s.kgio_tryread(1)
+    assert s.kgio_autopush?
+    assert_equal 1, s.getsockopt(Socket::IPPROTO_TCP, opt).unpack('i')[0]
+  end
+
+  def test_autopush_true_unix
+    Kgio.autopush = true
+    tmp = Tempfile.new('kgio_unix')
+    @path = tmp.path
+    File.unlink(@path)
+    tmp.close rescue nil
+    @srv = Kgio::UNIXServer.new(@path)
+    @rd = Kgio::UNIXSocket.new(@path)
+    t0 = nil
+    if defined?(Strace)
+      io, err = Strace.me { @wr = @srv.kgio_accept }
+      assert_nil err
+      rc = nil
+      io, err = Strace.me {
+        t0 = Time.now
+        @wr.kgio_write "HI\n"
+        rc = @wr.kgio_tryread 666
+      }
+      assert_nil err
+      lines = io.readlines
+      assert lines.grep(/TCP_CORK/).empty?, lines.inspect
+    else
+      assert_nothing_raised do
+        @wr = @srv.kgio_accept
+        t0 = Time.now
+        @wr.kgio_write "HI\n"
+        rc = @wr.kgio_tryread 666
+      end
+    end
+    assert_equal "HI\n", @rd.kgio_read(3)
+    diff = Time.now - t0
+    assert(diff < 0.200, "nopush on UNIX sockets? diff=#{diff} > 200ms")
+    assert_equal :wait_readable, rc
+  ensure
+    File.unlink(@path) rescue nil
+  end
+
+  def test_autopush_false
+    Kgio.autopush = nil
+    assert_equal false, Kgio.autopush?
+
+    @wr = Kgio::TCPSocket.new(@host, @port)
+    if defined?(Strace)
+      io, err = Strace.me { @rd = @srv.kgio_accept }
+      assert_nil err
+      lines = io.readlines
+      assert lines.grep(/TCP_CORK/).empty?, lines.inspect
+      assert_equal 1, @rd.getsockopt(Socket::SOL_TCP, TCP_CORK).unpack("i")[0]
+    else
+      @rd = @srv.kgio_accept
+    end
+
+    rbuf = "..."
+    t0 = Time.now
+    @rd.kgio_write "HI\n"
+    @wr.kgio_read(3, rbuf)
+    diff = Time.now - t0
+    assert(diff >= 0.200, "nopush broken? diff=#{diff} > 200ms")
+    assert_equal "HI\n", rbuf
+  end
+
+  def test_autopush_true
+    Kgio.autopush = true
+    assert_equal true, Kgio.autopush?
+    @wr = Kgio::TCPSocket.new(@host, @port)
+
+    if defined?(Strace)
+      io, err = Strace.me { @rd = @srv.kgio_accept }
+      assert_nil err
+      lines = io.readlines
+      assert_equal 1, lines.grep(/TCP_CORK/).size, lines.inspect
+      assert_equal 1, @rd.getsockopt(Socket::SOL_TCP, TCP_CORK).unpack("i")[0]
+    else
+      @rd = @srv.kgio_accept
+    end
+
+    @wr.write "HI\n"
+    rbuf = ""
+    if defined?(Strace)
+      io, err = Strace.me { @rd.kgio_read(3, rbuf) }
+      assert_nil err
+      lines = io.readlines
+      assert lines.grep(/TCP_CORK/).empty?, lines.inspect
+      assert_equal "HI\n", rbuf
+    else
+      assert_equal "HI\n", @rd.kgio_read(3, rbuf)
+    end
+
+    t0 = Time.now
+    @rd.kgio_write "HI2U2\n"
+    @rd.kgio_write "HOW\n"
+    rc = false
+
+    if defined?(Strace)
+      io, err = Strace.me { rc = @rd.kgio_tryread(666) }
+    else
+      rc = @rd.kgio_tryread(666)
+    end
+
+    @wr.readpartial(666, rbuf)
+    rbuf == "HI2U2\nHOW\n" or warn "rbuf=#{rbuf.inspect} looking bad?"
+    diff = Time.now - t0
+    assert(diff < 0.200, "time diff=#{diff} >= 200ms")
+    assert_equal :wait_readable, rc
+    if defined?(Strace)
+      assert_nil err
+      lines = io.readlines
+      assert_equal 2, lines.grep(/TCP_CORK/).size, lines.inspect
+    end
+    assert_nothing_raised { @wr.close }
+    assert_nothing_raised { @rd.close }
+
+    @wr = Kgio::TCPSocket.new(@host, @port)
+    if defined?(Strace)
+      io, err = Strace.me { @rd = @srv.kgio_accept }
+      assert_nil err
+      lines = io.readlines
+      assert lines.grep(/TCP_CORK/).empty?,"optimization fail: #{lines.inspect}"
+      assert_equal 1, @rd.getsockopt(Socket::SOL_TCP, TCP_CORK).unpack("i")[0]
+    end
+  end
+
+  def teardown
+    Kgio.autopush = false
+  end
+end if RUBY_PLATFORM =~ /linux|freebsd/

data/test/test_kgio_addr.rb

@@ -0,0 +1,19 @@
+# -*- encoding: binary -*-
+require 'test/unit'
+$-w = true
+require 'kgio'
+
+class TestKgioAddr < Test::Unit::TestCase
+  def test_tcp
+    addr = ENV["TEST_HOST"] || '127.0.0.1'
+    tcp = TCPServer.new(addr, 0)
+    port = tcp.addr[1]
+    client = Kgio::TCPSocket.new(addr, port)
+    accepted = tcp.accept
+    assert ! accepted.instance_eval { defined?(@kgio_addr) }
+    accepted.extend Kgio::SocketMethods
+    s = accepted.kgio_addr!
+    assert_equal addr, s
+    assert_equal addr, accepted.instance_variable_get(:@kgio_addr)
+  end
+end

data/test/test_no_dns_on_tcp_connect.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+$-w = true
+require 'kgio'
+
+class TestNoDnsOnTcpConnect < Test::Unit::TestCase
+  def test_connect_remote
+    assert_raises(ArgumentError) { Kgio::TCPSocket.new("example.com", 666) }
+  end
+
+  def test_connect_localhost
+    assert_raises(ArgumentError) { Kgio::TCPSocket.new("localhost", 666) }
+  end
+end

data/test/test_singleton_read_write.rb

@@ -0,0 +1,21 @@
+require 'test/unit'
+$-w = true
+require 'kgio'
+
+class TestSingletonReadWrite < Test::Unit::TestCase
+
+  def test_unix_socketpair
+    a, b = UNIXSocket.pair
+    assert_nothing_raised { Kgio.trywrite(a, "HELLO") }
+    buf = ""
+    assert_equal "HELLO", Kgio.tryread(b, 5, buf)
+    assert_equal "HELLO", buf
+    assert_equal :wait_readable, Kgio.tryread(b, 5)
+  end
+
+  def test_arg_error
+    assert_raises(ArgumentError) { Kgio.tryread }
+    assert_raises(ArgumentError) { Kgio.tryread($stdin) }
+    assert_raises(ArgumentError) { Kgio.trywrite($stdout) }
+  end
+end