kgio 2.1.1 → 2.2.0

data/GIT-VERSION-FILE

@@ -1 +1 @@
-GIT_VERSION = 2.1.1
+GIT_VERSION = 2.2.0

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -1,153 +1,10 @@
-# use GNU Make to run tests in parallel, and without depending on RubyGems
 all::
-RUBY = ruby
-RAKE = rake
-RSYNC = rsync
-
-GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
-	@./GIT-VERSION-GEN
--include GIT-VERSION-FILE
--include local.mk
-ifeq ($(DLEXT),) # "so" for Linux
-  DLEXT := $(shell $(RUBY) -rrbconfig -e 'puts Config::CONFIG["DLEXT"]')
-endif
-ifeq ($(RUBY_VERSION),)
-  RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
-endif
-
-install:
-	$(prep_setup_rb)
-	$(RM) -r .install-tmp
-	mkdir .install-tmp
-	$(RUBY) setup.rb all
-	$(RM) $^
-	$(RM) -r .install-tmp
-	$(prep_setup_rb)
-
-setup_rb_files := .config InstalledFiles
-prep_setup_rb := @-$(RM) $(setup_rb_files);$(MAKE) -C $(ext) clean
-
-clean:
-	-$(MAKE) -C ext/kgio clean
-	$(RM) $(setup_rb_files) ext/kgio/Makefile
-
-pkg_extra := GIT-VERSION-FILE NEWS ChangeLog LATEST
-ChangeLog: GIT-VERSION-FILE .wrongdoc.yml
-	wrongdoc prepare
-
-.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 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),)
+RSYNC_DEST := bogomips.org:/srv/bogomips/kgio
 rfproject := rainbows
 rfpackage := kgio
-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)
-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)
+include pkg.mk
+ifneq ($(VERSION),)
+release::
 	$(RAKE) raa_update VERSION=$(VERSION)
 	$(RAKE) publish_news VERSION=$(VERSION)
-else
-gem install-gem: GIT-VERSION-FILE
-	$(MAKE) $@ VERSION=$(GIT_VERSION)
 endif
-
-ext := ext/kgio/kgio_ext.$(DLEXT)
-ext/kgio/Makefile: ext/kgio/extconf.rb
-	cd $(@D) && $(RUBY) extconf.rb
-
-$(ext): $(wildcard ext/kgio/*.[ch] ext/kgio/*/*.h) ext/kgio/Makefile
-	$(MAKE) -C $(@D)
-
-all:: test
-
-build: $(ext)
-test_units := $(wildcard test/test_*.rb)
-test: test-unit
-test-unit: $(test_units)
-$(test_units): build
-	$(RUBY) -I lib:ext/kgio $@
-
-# this requires GNU coreutils variants
-publish_doc:
-	-git set-file-times
-	$(MAKE) doc
-	find doc/images -type f | \
-		TZ=UTC xargs touch -d '1970-01-01 00:00:00' doc/rdoc.css
-	$(MAKE) doc_gz
-	chmod 644 $$(find doc -type f)
-	$(RSYNC) -av doc/ bogomips.org:/srv/bogomips/kgio/
-	git ls-files | xargs touch
-
-# 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: .FORCE-GIT-VERSION-FILE doc manifest test $(test_units)

data/LATEST

@@ -0,0 +1,25 @@
+=== kgio 2.2.0 - kinder, gentler I/O for the Internets / 2011-02-04 03:07 UTC
+
+  * sockets accept()ed by a TCP_NOPUSH/TCP_CORK listener
+    automatically flush on kgio_*read calls if there is pending
+    data.  "Kgio.autopush = false" disables this globally,
+    and Kgio::Socket also get "kgio_autopush=" to enable/disable
+    on a per-object individual basis.
+
+  * ECONNRESET exceptions get empty backtraces for kgio_*read.
+    There's nothing a programmer can do about these, so there's
+    no point in going through the expensive backtrace generation
+    process.
+
+  * Kgio.try* singleton methods added for working with non-Kgio
+    enhanced objects.  No more needing to use Object#extend
+    and blowing away your method cache to make existing I/O
+    objects kinder and gentler.
+
+  * IPv6 support should be complete, systems without a native
+    getaddrinfo(3) are now unsupported (and will remain so
+    unless somebody complains).
+
+  There should be no other backwards-incompatible changes other
+  than requiring getaddrinfo(3) and friends for IPv6 support.
+

data/NEWS

@@ -1,4 +1,44 @@
-=== 2.0.0 / 2010-11-19 01:18 UTC
+=== kgio 2.2.0 - kinder, gentler I/O for the Internets / 2011-02-04 03:07 UTC
+
+  * sockets accept()ed by a TCP_NOPUSH/TCP_CORK listener
+    automatically flush on kgio_*read calls if there is pending
+    data.  "Kgio.autopush = false" disables this globally,
+    and Kgio::Socket also get "kgio_autopush=" to enable/disable
+    on a per-object individual basis.
+
+  * ECONNRESET exceptions get empty backtraces for kgio_*read.
+    There's nothing a programmer can do about these, so there's
+    no point in going through the expensive backtrace generation
+    process.
+
+  * Kgio.try* singleton methods added for working with non-Kgio
+    enhanced objects.  No more needing to use Object#extend
+    and blowing away your method cache to make existing I/O
+    objects kinder and gentler.
+
+  * IPv6 support should be complete, systems without a native
+    getaddrinfo(3) are now unsupported (and will remain so
+    unless somebody complains).
+
+  There should be no other backwards-incompatible changes other
+  than requiring getaddrinfo(3) and friends for IPv6 support.
+
+=== kgio 2.1.1 - one small Rubinius fix / 2010-12-26 02:08 UTC
+
+  We now avoid errno side-effects in kgio_wait_*able methods.
+  This affects Rubinius, but may affect other Ruby platforms
+  (particularly those that use stdio) as well.
+
+=== kgio 2.1.0 - accept improvements and fixes / 2010-12-26 01:07 UTC
+
+  kgio_accept and kgio_tryaccept now take an optional argument
+  to override the default Kgio::Socket class that is returned.
+
+  These methods also fall back to using regular accept() if
+  kgio was built on a system with accept4() and later run on
+  a system without accept4().
+
+=== kgio 2.0.0 - major internal API changes / 2010-11-19 01:18 UTC
 
   (no code changes from 2.0.0pre1)
 
@@ -19,7 +59,7 @@
       add default kgio_wait_*able methods
       switch entirely to kgio_wait_*able methods
 
-=== 2.0.0pre1 / 2010-11-18 23:16 UTC
+=== kgio 2.0.0pre1 - major internal API changes / 2010-11-18 23:16 UTC
 
   This release should make Kgio easier and more consistent
   to use across a variety of libraries/applications.
@@ -38,20 +78,20 @@
         add default kgio_wait_*able methods
         switch entirely to kgio_wait_*able methods
 
-=== 1.3.1 / 2010-10-08 22:20 UTC
+=== kgio 1.3.1 - fix zero-length reads / 2010-10-08 22:20 UTC
 
   kgio_read and kgio_tryread will now return an empty string when
   a length of zero is specified instead of nil (which would signal
   an EOF).  This emulates the behavior of IO#read, IO#readpartial,
   IO#sysread, IO#read_nonblock in core Ruby for consistency.
 
-=== 1.3.0 / 2010-10-08 03:03 UTC
+=== kgio 1.3.0 - bug and usability fixes / 2010-10-08 03:03 UTC
 
   * make Kgio::WaitWritable and Kgio::WaitReadable symbols
   * trywrite: fix stupid off-by-one error causing corrupt writes
     on retries
 
-=== 1.2.1 / 2010-10-07 07:20 UTC
+=== kgio 1.2.1 - doc and *BSD workarounds / 2010-10-07 07:20 UTC
 
   This fixes our accept4() wrapper which did not work as expected
   on some *BSD-based systems due to fcntl(fd, F_GETFL) returning
@@ -60,7 +100,7 @@
 
   Also some RDoc fixes.
 
-=== 1.2.0 / 2010-10-05 23:14 UTC
+=== kgio 1.2.0 - cleanups and minor improvements / 2010-10-05 23:14 UTC
 
   The C extension is now split into several files for
   ease-of-maintenance.
@@ -69,17 +109,17 @@
   Errno::EPIPE, Errno::ECONNRESET) are now less expensive as they
   are generated without backtraces.
 
-=== 1.1.0 / 2010-09-29 01:17 UTC
+=== kgio 1.1.0 - flexible accept methods / 2010-09-29 01:17 UTC
 
   * alternate classes may now be returned by accept/tryaccept
     by setting Kgio.accept_class=
 
-=== 1.0.1 / 2010-09-28 03:00 UTC
+=== kgio 1.0.1 - compatibility fixes / 2010-09-28 03:00 UTC
 
   * add compatibility for ancient Rubies (1.8.6)
   * linux: fix accept4() support for newer Linux
 
-=== 1.0.0 / 2010-09-28 00:29 UTC
+=== kgio 1.0.0 - initial release / 2010-09-28 00:29 UTC
 
   A kinder, gentler I/O library for Ruby
 

data/README

@@ -45,13 +45,13 @@ You may also install it via RubyGems.org:
 You can get the latest source via git from the following locations
 (these versions may not be stable):
 
-  git://git.bogomips.org/kgio.git
+  git://bogomips.org/kgio.git
   git://repo.or.cz/kgio.git (mirror)
 
 You may browse the code from the web and download the latest snapshot
 tarballs here:
 
-* http://git.bogomips.org/cgit/kgio.git (cgit)
+* http://bogomips.org/kgio.git (cgit)
 * http://repo.or.cz/w/kgio.git (gitweb)
 
 See the HACKING guide on how to contribute and build prerelease gems

data/Rakefile

@@ -1,6 +1,6 @@
 # -*- encoding: binary -*-
-cgit_url = "http://git.bogomips.org/cgit/kgio.git"
-git_url = 'git://git.bogomips.org/kgio.git'
+cgit_url = "http://bogomips.org/kgio.git"
+git_url = 'git://bogomips.org/kgio.git'
 
 desc "post news article to rubyforge"
 task :publish_news do

data/ext/kgio/accept.c

@@ -1,5 +1,5 @@
 #include "kgio.h"
-#include "missing/accept4.h"
+#include "missing_accept4.h"
 #include "sock_for_fd.h"
 
 static VALUE localhost;
@@ -133,14 +133,21 @@ static VALUE acceptor(int argc, const VALUE *argv)
 	rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
 }
 
+#if defined(__linux__)
+#  define post_accept kgio_autopush_accept
+#else
+#  define post_accept(a,b) for(;0;)
+#endif
+
 static VALUE
-my_accept(VALUE io, VALUE klass,
+my_accept(VALUE accept_io, VALUE klass,
           struct sockaddr *addr, socklen_t *addrlen, int nonblock)
 {
 	int client;
+	VALUE client_io;
 	struct accept_args a;
 
-	a.fd = my_fileno(io);
+	a.fd = my_fileno(accept_io);
 	a.addr = addr;
 	a.addrlen = addrlen;
 retry:
@@ -175,20 +182,55 @@ retry:
 			rb_sys_fail("accept");
 		}
 	}
-	return sock_for_fd(klass, client);
+	client_io = sock_for_fd(klass, client);
+	post_accept(accept_io, client_io);
+	return client_io;
 }
 
-static void in_addr_set(VALUE io, struct sockaddr_in *addr)
+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:
+ *
+ *	io.kgio_addr! => refreshes the given sock address
+ */
+static VALUE addr_bang(VALUE io)
 {
-	VALUE host = rb_str_new(0, INET_ADDRSTRLEN);
-	socklen_t addrlen = (socklen_t)INET_ADDRSTRLEN;
-	const char *name;
-
-	name = inet_ntop(AF_INET, &addr->sin_addr, RSTRING_PTR(host), addrlen);
-	if (name == NULL)
-		rb_sys_fail("inet_ntop");
-	rb_str_set_len(host, strlen(name));
-	rb_ivar_set(io, iv_kgio_addr, host);
+	int fd = my_fileno(io);
+	struct sockaddr_storage addr;
+	socklen_t len = sizeof(struct sockaddr_storage);
+
+	if (getpeername(fd, (struct sockaddr *)&addr, &len) != 0)
+		rb_sys_fail("getpeername");
+
+	if (addr.ss_family == AF_UNIX)
+		return rb_ivar_set(io, iv_kgio_addr, localhost);
+
+	return in_addr_set(io, &addr, len);
 }
 
 /*
@@ -210,13 +252,13 @@ static void in_addr_set(VALUE io, struct sockaddr_in *addr)
  */
 static VALUE tcp_tryaccept(int argc, VALUE *argv, VALUE io)
 {
-	struct sockaddr_in addr;
-	socklen_t addrlen = sizeof(struct sockaddr_in);
+	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);
 
 	if (!NIL_P(rv))
-		in_addr_set(rv, &addr);
+		in_addr_set(rv, &addr, addrlen);
 	return rv;
 }
 
@@ -240,12 +282,12 @@ static VALUE tcp_tryaccept(int argc, VALUE *argv, VALUE io)
  */
 static VALUE tcp_accept(int argc, VALUE *argv, VALUE io)
 {
-	struct sockaddr_in addr;
-	socklen_t addrlen = sizeof(struct sockaddr_in);
+	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);
 
-	in_addr_set(rv, &addr);
+	in_addr_set(rv, &addr, addrlen);
 	return rv;
 }
 
@@ -402,6 +444,8 @@ void init_kgio_accept(void)
 	cClientSocket = cKgio_Socket;
 	mSocketMethods = rb_const_get(mKgio, rb_intern("SocketMethods"));
 
+	rb_define_method(mSocketMethods, "kgio_addr!", addr_bang, 0);
+
 	rb_define_singleton_method(mKgio, "accept_cloexec?", get_cloexec, 0);
 	rb_define_singleton_method(mKgio, "accept_cloexec=", set_cloexec, 1);
 	rb_define_singleton_method(mKgio, "accept_nonblock?", get_nonblock, 0);

data/ext/kgio/autopush.c

@@ -0,0 +1,203 @@
+/*
+ * We use a very basic strategy to use TCP_CORK semantics optimally
+ * in most TCP servers:  On corked sockets, we will uncork on recv()
+ * if there was a previous send().  Otherwise we do not fiddle
+ * with TCP_CORK at all.
+ *
+ * Under Linux, we can rely on TCP_CORK being inherited in an
+ * accept()-ed client socket so we can avoid syscalls for each
+ * accept()-ed client if we know the accept() socket corks.
+ *
+ * This module does NOTHING for client TCP sockets, we only deal
+ * with accept()-ed sockets right now.
+ */
+
+#include "kgio.h"
+#include <netinet/tcp.h>
+
+/*
+ * As of FreeBSD 4.5, TCP_NOPUSH == TCP_CORK
+ * ref: http://dotat.at/writing/nopush.html
+ * We won't care for older FreeBSD since nobody runs Ruby on them...
+ */
+#ifdef TCP_CORK
+#  define KGIO_NOPUSH TCP_CORK
+#elif defined(TCP_NOPUSH)
+#  define KGIO_NOPUSH TCP_NOPUSH
+#endif
+
+#ifdef KGIO_NOPUSH
+static ID id_autopush_state;
+static int enabled = 1;
+
+enum autopush_state {
+	AUTOPUSH_STATE_ACCEPTOR_IGNORE = -1,
+	AUTOPUSH_STATE_IGNORE = 0,
+	AUTOPUSH_STATE_WRITER = 1,
+	AUTOPUSH_STATE_WRITTEN = 2,
+	AUTOPUSH_STATE_ACCEPTOR = 3
+};
+
+#if defined(R_CAST) && \
+    defined(HAVE_TYPE_STRUCT_RFILE) && \
+    defined(HAVE_TYPE_STRUCT_ROBJECT) && \
+    ((SIZEOF_STRUCT_RFILE + SIZEOF_INT) <= (SIZEOF_STRUCT_ROBJECT))
+
+struct AutopushSocket {
+	struct RFile rfile;
+	enum autopush_state autopush_state;
+};
+
+static enum autopush_state state_get(VALUE io)
+{
+	return ((struct AutopushSocket *)(io))->autopush_state;
+}
+
+static void state_set(VALUE io, enum autopush_state state)
+{
+	((struct AutopushSocket *)(io))->autopush_state = state;
+}
+#else
+static enum autopush_state state_get(VALUE io)
+{
+	VALUE val;
+
+	if (rb_ivar_defined(io, id_autopush_state) == Qfalse)
+		return AUTOPUSH_STATE_IGNORE;
+	val = rb_ivar_get(io, id_autopush_state);
+
+	return (enum autopush_state)NUM2INT(val);
+}
+
+static void state_set(VALUE io, enum autopush_state state)
+{
+	rb_ivar_set(io, id_autopush_state, INT2NUM(state));
+}
+#endif /* IVAR fallback */
+
+static enum autopush_state detect_acceptor_state(VALUE io);
+static void push_pending_data(VALUE io);
+
+static VALUE s_get_autopush(VALUE self)
+{
+	return enabled ? Qtrue : Qfalse;
+}
+
+static VALUE s_set_autopush(VALUE self, VALUE val)
+{
+	enabled = RTEST(val);
+
+	return val;
+}
+
+static VALUE autopush_get(VALUE io)
+{
+	return state_get(io) <= 0 ? Qfalse : Qtrue;
+}
+
+static VALUE autopush_set(VALUE io, VALUE vbool)
+{
+	int fd = my_fileno(io);
+	int val;
+	socklen_t len = sizeof(val);
+
+	if (RTEST(vbool))
+		state_set(io, AUTOPUSH_STATE_WRITER);
+	else
+		state_set(io, AUTOPUSH_STATE_IGNORE);
+	return vbool;
+}
+
+void init_kgio_autopush(void)
+{
+	VALUE mKgio = rb_define_module("Kgio");
+	VALUE tmp;
+
+	rb_define_singleton_method(mKgio, "autopush?", s_get_autopush, 0);
+	rb_define_singleton_method(mKgio, "autopush=", s_set_autopush, 1);
+
+	tmp = rb_define_module_under(mKgio, "SocketMethods");
+	rb_define_method(tmp, "kgio_autopush=", autopush_set, 1);
+	rb_define_method(tmp, "kgio_autopush?", autopush_get, 0);
+
+	id_autopush_state = rb_intern("@kgio_autopush_state");
+}
+
+/*
+ * called after a successful write, just mark that we've put something
+ * in the skb and will need to uncork on the next write.
+ */
+void kgio_autopush_send(VALUE io)
+{
+	if (state_get(io) == AUTOPUSH_STATE_WRITER)
+		state_set(io, AUTOPUSH_STATE_WRITTEN);
+}
+
+/* called on successful accept() */
+void kgio_autopush_accept(VALUE accept_io, VALUE client_io)
+{
+	enum autopush_state acceptor_state;
+
+	if (!enabled)
+		return;
+	acceptor_state = state_get(accept_io);
+	if (acceptor_state == AUTOPUSH_STATE_IGNORE)
+		acceptor_state = detect_acceptor_state(accept_io);
+	if (acceptor_state == AUTOPUSH_STATE_ACCEPTOR)
+		state_set(client_io, AUTOPUSH_STATE_WRITER);
+	else
+		state_set(client_io, AUTOPUSH_STATE_IGNORE);
+}
+
+void kgio_autopush_recv(VALUE io)
+{
+	if (enabled && (state_get(io) == AUTOPUSH_STATE_WRITTEN)) {
+		push_pending_data(io);
+		state_set(io, AUTOPUSH_STATE_WRITER);
+	}
+}
+
+static enum autopush_state detect_acceptor_state(VALUE io)
+{
+	int corked = 0;
+	int fd = my_fileno(io);
+	socklen_t optlen = sizeof(int);
+	enum autopush_state state;
+
+	if (getsockopt(fd, IPPROTO_TCP, KGIO_NOPUSH, &corked, &optlen) != 0) {
+		if (errno != EOPNOTSUPP)
+			rb_sys_fail("getsockopt(TCP_CORK/TCP_NOPUSH)");
+		errno = 0;
+		state = AUTOPUSH_STATE_ACCEPTOR_IGNORE;
+	} else if (corked) {
+		state = AUTOPUSH_STATE_ACCEPTOR;
+	} else {
+		state = AUTOPUSH_STATE_ACCEPTOR_IGNORE;
+	}
+	state_set(io, state);
+
+	return state;
+}
+
+/*
+ * checks to see if we've written anything since the last recv()
+ * If we have, uncork the socket and immediately recork it.
+ */
+static void push_pending_data(VALUE io)
+{
+	int optval = 0;
+	const socklen_t optlen = sizeof(int);
+	const int fd = my_fileno(io);
+
+	if (setsockopt(fd, IPPROTO_TCP, KGIO_NOPUSH, &optval, optlen) != 0)
+		rb_sys_fail("setsockopt(TCP_CORK/TCP_NOPUSH, 0)");
+	/* immediately recork */
+	optval = 1;
+	if (setsockopt(fd, IPPROTO_TCP, KGIO_NOPUSH, &optval, optlen) != 0)
+		rb_sys_fail("setsockopt(TCP_CORK/TCP_NOPUSH, 1)");
+}
+#else /* !KGIO_NOPUSH */
+void init_kgio_autopush(void)
+{
+}
+#endif /* ! KGIO_NOPUSH */