raindrops 0.4.1 → 0.5.0

data/examples/linux-listener-stats.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/ruby
+# -*- encoding: binary -*-
+$stdout.sync = $stderr.sync = true
+# this is used to show or watch the number of active and queued
+# connections on any listener socket from the command line
+
+require 'raindrops'
+require 'optparse'
+require 'ipaddr'
+require 'time'
+begin
+  require 'sleepy_penguin'
+rescue LoadError
+end
+usage = "Usage: #$0 [-d DELAY] [-t QUEUED_THRESHOLD] ADDR..."
+ARGV.size > 0 or abort usage
+delay = false
+all = false
+queued_thresh = -1
+# "normal" exits when driven on the command-line
+trap(:INT) { exit 130 }
+trap(:PIPE) { exit 0 }
+
+opts = OptionParser.new('', 24, '  ') do |opts|
+  opts.banner = usage
+  opts.on('-d', '--delay=DELAY', Float) { |n| delay = n }
+  opts.on('-t', '--queued-threshold=INT', Integer) { |n| queued_thresh = n }
+  opts.on('-a', '--all') { all = true }
+  opts.parse! ARGV
+end
+
+begin
+  require 'aggregate'
+rescue LoadError
+  $stderr.puts "Aggregate missing, USR1 and USR2 handlers unavailable"
+end if delay
+
+if delay && defined?(SleepyPenguin::TimerFD)
+  @tfd = SleepyPenguin::TimerFD.new
+  @tfd.settime nil, delay, delay
+  def delay_for(seconds)
+    @tfd.expirations
+  end
+else
+  alias delay_for sleep
+end
+
+agg_active = agg_queued = nil
+if delay && defined?(Aggregate)
+  agg_active = Aggregate.new
+  agg_queued = Aggregate.new
+
+  def dump_aggregate(label, agg)
+    $stderr.write "--- #{label} ---\n"
+    %w(count min max outliers_low outliers_high mean std_dev).each do |f|
+      $stderr.write "#{f}=#{agg.__send__ f}\n"
+    end
+    $stderr.write "#{agg}\n\n"
+  end
+
+  trap(:USR1) do
+    dump_aggregate "active", agg_active
+    dump_aggregate "queued", agg_queued
+  end
+  trap(:USR2) do
+    agg_active = Aggregate.new
+    agg_queued = Aggregate.new
+  end
+  $stderr.puts "USR1(dump_aggregate) and USR2(reset) handlers ready for PID=#$$"
+end
+
+ARGV.each do |addr|
+  addr =~ %r{\A(127\..+):(\d+)\z} or next
+  host, port = $1, $2
+  hex_port = '%X' % port.to_i
+  ip_addr = IPAddr.new(host)
+  hex_host = ip_addr.hton.each_byte.inject('') { |s,o| s << '%02X' % o }
+  socks = File.readlines('/proc/net/tcp')
+  hex_addr = "#{hex_host}:#{hex_port}"
+  if socks.grep(/^\s+\d+:\s+#{hex_addr}\s+/).empty? &&
+     ! socks.grep(/^\s+\d+:\s+00000000:#{hex_port}\s+/).empty?
+    warn "W: #{host}:#{port} (#{hex_addr}) not found in /proc/net/tcp"
+    warn "W: Did you mean 0.0.0.0:#{port}?"
+  end
+end
+
+len = "address".size
+now = nil
+tcp, unix = [], []
+ARGV.each do |addr|
+  bs = addr.respond_to?(:bytesize) ? addr.bytesize : addr.size
+  len = bs if bs > len
+  (addr =~ %r{\A/} ? unix : tcp) << addr
+end
+combined = {}
+tcp_args = unix_args = nil
+unless tcp.empty? && unix.empty?
+  tcp_args = tcp
+  unix_args = unix
+end
+sock = Raindrops::InetDiagSocket.new if tcp
+
+len = 35 if len > 35
+fmt = "%20s % #{len}s % 10u % 10u\n"
+$stderr.printf fmt.tr('u','s'), *%w(timestamp address active queued)
+
+begin
+  if now
+    combined.clear
+    now = nil
+  end
+  combined.merge! Raindrops::Linux.tcp_listener_stats(tcp_args, sock)
+  combined.merge! Raindrops::Linux.unix_listener_stats(unix_args)
+  combined.each do |addr,stats|
+    active, queued = stats.active, stats.queued
+    if agg_active
+      agg_active << active
+      agg_queued << queued
+    end
+    next if queued < queued_thresh
+    printf fmt, now ||= Time.now.utc.iso8601, addr, active, queued
+  end
+end while delay && delay_for(delay)

data/examples/{config.ru → middleware.ru}

@@ -1,4 +1,4 @@
-# sample stand-alone rackup application
+# sample stand-alone rackup application for Raindrops::Middleware
 require 'rack/lobster'
 require 'raindrops'
 use Raindrops::Middleware

data/examples/watcher.ru

@@ -0,0 +1,4 @@
+# Sample standalone Rack application, recommended use is with Zbatery
+# See zbatery.conf.rb
+require "raindrops"
+run Raindrops::Watcher.new

data/examples/watcher_demo.ru

@@ -0,0 +1,13 @@
+# This is the exact config that powers http://raindrops-demo.bogomips.org/
+# This is used with zbatery.conf.rb
+#
+# zbatery -c zbatery.conf.ru watcher_demo.ru -E none
+require "raindrops"
+use Raindrops::Middleware
+listeners = %w(
+  0.0.0.0:9418
+  0.0.0.0:80
+  /tmp/.raindrops
+  /tmp/.r
+)
+run Raindrops::Watcher.new :listeners => listeners

data/examples/zbatery.conf.rb

@@ -0,0 +1,13 @@
+# Used for running Raindrops::Watcher, which requires a multi-threaded
+# Rack server capable of streaming a response.  Threads must be used,
+# so Zbatery is recommended: http://zbatery.bogomip.org/
+Rainbows! do
+  use :ThreadSpawn
+end
+log_dir = "/var/log/zbatery"
+if File.writable?(log_dir) && File.directory?(log_dir)
+  stderr_path "#{log_dir}/raindrops-demo.stderr.log"
+  stdout_path "#{log_dir}/raindrops-demo.stdout.log"
+  user "www-data", "www-data"
+  listen "/tmp/.raindrops"
+end

data/ext/raindrops/extconf.rb

@@ -3,6 +3,11 @@ require 'mkmf'
 have_func('mmap', 'sys/mman.h') or abort 'mmap() not found'
 have_func('munmap', 'sys/mman.h') or abort 'munmap() not found'
 
+$CPPFLAGS += " -D_GNU_SOURCE "
+have_func('mremap', 'sys/mman.h')
+
+$CPPFLAGS += " -D_BSD_SOURCE -D_XOPEN_SOURCE=600 "
+have_func("getpagesize", "unistd.h")
 have_func("rb_struct_alloc_noinit")
 have_func('rb_thread_blocking_region')
 

data/ext/raindrops/linux_inet_diag.c

@@ -1,34 +1,20 @@
 #include <ruby.h>
+#ifdef HAVE_RUBY_ST_H
+#  include <ruby/st.h>
+#else
+#  include <st.h>
+#endif
+#include "my_fileno.h"
 #ifdef __linux__
 
 /* Ruby 1.8.6+ macros (for compatibility with Ruby 1.9) */
-#ifndef RSTRING_PTR
-#  define RSTRING_PTR(s) (RSTRING(s)->ptr)
-#endif
 #ifndef RSTRING_LEN
 #  define RSTRING_LEN(s) (RSTRING(s)->len)
 #endif
-#ifdef RSTRUCT
-#  ifndef RSTRUCT_PTR
-#    define RSTRUCT_PTR(s) (RSTRUCT(s)->ptr)
-#   endif
-#  ifndef RSTRUCT_LEN
-#    define RSTRUCT_LEN(s) (RSTRUCT(s)->len)
-#  endif
-#endif
-
-#ifndef HAVE_RB_STRUCT_ALLOC_NOINIT
-static ID id_new;
-static VALUE rb_struct_alloc_noinit(VALUE class)
-{
-	return rb_funcall(class, id_new, 0, 0);
-}
-#endif /* !defined(HAVE_RB_STRUCT_ALLOC_NOINIT) */
 
 /* partial emulation of the 1.9 rb_thread_blocking_region under 1.8 */
 #ifndef HAVE_RB_THREAD_BLOCKING_REGION
 #  include <rubysig.h>
-#  define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
 typedef void rb_unblock_function_t(void *);
 typedef VALUE rb_blocking_function_t(void *);
 static VALUE
@@ -50,6 +36,7 @@ rb_thread_blocking_region(
 #include <errno.h>
 #include <sys/socket.h>
 #include <sys/types.h>
+#include <netdb.h>
 #include <unistd.h>
 #include <string.h>
 #include <asm/types.h>
@@ -62,59 +49,220 @@ rb_thread_blocking_region(
 
 static size_t page_size;
 static unsigned g_seq;
-static VALUE cListenStats;
-
-struct my_addr {
-	in_addr_t addr;
-	uint16_t port;
-};
+static VALUE cListenStats, cIDSock;
+static ID id_new;
 
 struct listen_stats {
-	long active;
-	long queued;
+	uint32_t active;
+	uint32_t listener_p:1;
+	uint32_t queued:31;
 };
 
 #define OPLEN (sizeof(struct inet_diag_bc_op) + \
-               sizeof(struct inet_diag_hostcond) + \
-               sizeof(in_addr_t))
+	       sizeof(struct inet_diag_hostcond) + \
+	       sizeof(struct sockaddr_storage))
 
 struct nogvl_args {
+	st_table *table;
 	struct iovec iov[3]; /* last iov holds inet_diag bytecode */
-	struct my_addr query_addr;
 	struct listen_stats stats;
+	int fd;
 };
 
+/*
+ * call-seq:
+ *	Raindrops::InetDiagSocket.new	-> Socket
+ *
+ * Creates a new Socket object for the netlink inet_diag facility
+ */
+static VALUE ids_s_new(VALUE klass)
+{
+	VALUE argv[3];
+	argv[0] = INT2NUM(AF_NETLINK);
+	argv[1] = INT2NUM(SOCK_RAW);
+	argv[2] = INT2NUM(NETLINK_INET_DIAG);
+
+	return rb_call_super(3, argv);
+}
+
 /* creates a Ruby ListenStats Struct based on our internal listen_stats */
 static VALUE rb_listen_stats(struct listen_stats *stats)
 {
-	VALUE rv = rb_struct_alloc_noinit(cListenStats);
-	VALUE active = LONG2NUM(stats->active);
-	VALUE queued = LONG2NUM(stats->queued);
-
-#ifdef RSTRUCT_PTR
-	VALUE *ptr = RSTRUCT_PTR(rv);
-	ptr[0] = active;
-	ptr[1] = queued;
-#else /* Rubinius */
-	rb_funcall(rv, rb_intern("active="), 1, active);
-	rb_funcall(rv, rb_intern("queued="), 1, queued);
-#endif /* ! Rubinius */
-	return rv;
+	VALUE active = UINT2NUM(stats->active);
+	VALUE queued = UINT2NUM(stats->queued);
+
+	return rb_struct_new(cListenStats, active, queued);
 }
 
-/*
- * converts a base 10 string representing a port number into
- * an unsigned 16 bit integer.  Raises ArgumentError on failure
- */
-static uint16_t my_inet_port(const char *port)
+static int st_free_data(st_data_t key, st_data_t value, st_data_t ignored)
+{
+	xfree((void *)key);
+	xfree((void *)value);
+
+	return ST_DELETE;
+}
+
+static int st_to_hash(st_data_t key, st_data_t value, VALUE hash)
 {
-	char *err;
-	unsigned long tmp = strtoul(port, &err, 10);
+	struct listen_stats *stats = (struct listen_stats *)value;
 
-	if (*err != 0 || tmp > 0xffff)
-		rb_raise(rb_eArgError, "port not parsable: `%s'\n", port);
+	if (stats->listener_p) {
+		VALUE k = rb_str_new2((const char *)key);
+		VALUE v = rb_listen_stats(stats);
 
-	return (uint16_t)tmp;
+		OBJ_FREEZE(k);
+		rb_hash_aset(hash, k, v);
+	}
+	return st_free_data(key, value, 0);
+}
+
+static int st_AND_hash(st_data_t key, st_data_t value, VALUE hash)
+{
+	struct listen_stats *stats = (struct listen_stats *)value;
+
+	if (stats->listener_p) {
+		VALUE k = rb_str_new2((const char *)key);
+
+		if (rb_hash_lookup(hash, k) == Qtrue) {
+			VALUE v = rb_listen_stats(stats);
+			OBJ_FREEZE(k);
+			rb_hash_aset(hash, k, v);
+		}
+	}
+	return st_free_data(key, value, 0);
+}
+
+static const char *addr_any(sa_family_t family)
+{
+	static const char ipv4[] = "0.0.0.0";
+	static const char ipv6[] = "[::]";
+
+	if (family == AF_INET)
+		return ipv4;
+	assert(family == AF_INET6 && "unknown family");
+	return ipv6;
+}
+
+static void bug_warn(void)
+{
+	fprintf(stderr, "Please report how you produced this at "\
+	                "raindrops@librelist.com\n");
+	fflush(stderr);
+}
+
+static struct listen_stats *stats_for(st_table *table, struct inet_diag_msg *r)
+{
+	char *key, *port, *old_key;
+	size_t alloca_len;
+	struct listen_stats *stats;
+	size_t keylen;
+	size_t portlen = sizeof("65535");
+	struct sockaddr_storage ss = { 0 };
+	socklen_t len = sizeof(struct sockaddr_storage);
+	int rc;
+	int flags = NI_NUMERICHOST | NI_NUMERICSERV;
+
+	switch ((ss.ss_family = r->idiag_family)) {
+	case AF_INET: {
+		struct sockaddr_in *in = (struct sockaddr_in *)&ss;
+
+		in->sin_port = r->id.idiag_sport;
+		in->sin_addr.s_addr = r->id.idiag_src[0];
+		keylen = INET_ADDRSTRLEN;
+		alloca_len = keylen + 1 + portlen;
+		key = alloca(alloca_len);
+		key[keylen] = 0; /* will be ':' later */
+		port = key + keylen + 1;
+		rc = getnameinfo((struct sockaddr *)&ss, len,
+				 key, keylen, port, portlen, flags);
+		break;
+		}
+	case AF_INET6: {
+		struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)&ss;
+		in6->sin6_port = r->id.idiag_sport;
+		memcpy(&in6->sin6_addr.in6_u.u6_addr32,
+		       &r->id.idiag_src, sizeof(__be32[4]));
+		keylen = INET6_ADDRSTRLEN;
+		          /* [            ] */
+		alloca_len = 1 + keylen + 1 + 1 + portlen;
+		key = alloca(alloca_len);
+		*key = '[';
+		key[1 + keylen + 1] = 0; /* will be ':' later */
+		port = 1 + key + keylen + 1 + 1;
+		rc = getnameinfo((struct sockaddr *)&ss, len,
+				 key + 1, keylen, port, portlen, flags);
+		break;
+		}
+	default:
+		assert(0 && "unsupported address family, could that be IPv7?!");
+	}
+	if (rc != 0) {
+		fprintf(stderr, "BUG: getnameinfo: %s\n", gai_strerror(rc));
+		bug_warn();
+		*key = 0;
+	}
+
+	keylen = strlen(key);
+	portlen = strlen(port);
+
+	switch (ss.ss_family) {
+	case AF_INET:
+		key[keylen] = ':';
+		memmove(key + keylen + 1, port, portlen + 1);
+		break;
+	case AF_INET6:
+		key[keylen] = ']';
+		key[keylen + 1] = ':';
+		memmove(key + keylen + 2, port, portlen + 1);
+		keylen++;
+		break;
+	default:
+		assert(0 && "unsupported address family, could that be IPv7?!");
+	}
+
+	if (st_lookup(table, (st_data_t)key, (st_data_t *)&stats))
+		return stats;
+
+	old_key = key;
+
+	if (r->idiag_state == TCP_ESTABLISHED) {
+		int n = snprintf(key, alloca_len, "%s:%u",
+				 addr_any(ss.ss_family),
+				 ntohs(r->id.idiag_sport));
+		if (n <= 0) {
+			fprintf(stderr, "BUG: snprintf: %d\n", n);
+			bug_warn();
+		}
+		if (st_lookup(table, (st_data_t)key, (st_data_t *)&stats))
+			return stats;
+		if (n <= 0) {
+			key = xmalloc(1);
+			*key = '\0';
+		} else {
+			old_key = key;
+			key = xmalloc(n + 1);
+			memcpy(key, old_key, n + 1);
+		}
+	} else {
+		key = xmalloc(keylen + 1 + portlen + 1);
+		memcpy(key, old_key, keylen + 1 + portlen + 1);
+	}
+	stats = xcalloc(1, sizeof(struct listen_stats));
+	st_insert(table, (st_data_t)key, (st_data_t)stats);
+	return stats;
+}
+
+static void table_incr_active(st_table *table, struct inet_diag_msg *r)
+{
+	struct listen_stats *stats = stats_for(table, r);
+	++stats->active;
+}
+
+static void table_set_queued(st_table *table, struct inet_diag_msg *r)
+{
+	struct listen_stats *stats = stats_for(table, r);
+	stats->listener_p = 1;
+	stats->queued = r->idiag_rqueue;
 }
 
 /* inner loop of inet_diag, called for every socket returned by netlink */
@@ -127,85 +275,108 @@ static inline void r_acc(struct nogvl_args *args, struct inet_diag_msg *r)
 	 */
 	if (r->idiag_inode == 0)
 		return;
-	if (r->idiag_state == TCP_ESTABLISHED)
-		args->stats.active++;
-	else /* if (r->idiag_state == TCP_LISTEN) */
-		args->stats.queued = r->idiag_rqueue;
+	if (r->idiag_state == TCP_ESTABLISHED) {
+		if (args->table)
+			table_incr_active(args->table, r);
+		else
+			args->stats.active++;
+	} else { /* if (r->idiag_state == TCP_LISTEN) */
+		if (args->table)
+			table_set_queued(args->table, r);
+		else
+			args->stats.queued = r->idiag_rqueue;
+	}
 	/*
 	 * we wont get anything else because of the idiag_states filter
 	 */
 }
 
-static const char err_socket[] = "socket";
 static const char err_sendmsg[] = "sendmsg";
 static const char err_recvmsg[] = "recvmsg";
 static const char err_nlmsg[] = "nlmsg";
 
+struct diag_req {
+	struct nlmsghdr nlh;
+	struct inet_diag_req r;
+};
+
+static void prep_msghdr(
+	struct msghdr *msg,
+	struct nogvl_args *args,
+	struct sockaddr_nl *nladdr,
+	size_t iovlen)
+{
+	memset(msg, 0, sizeof(struct msghdr));
+	msg->msg_name = (void *)nladdr;
+	msg->msg_namelen = sizeof(struct sockaddr_nl);
+	msg->msg_iov = args->iov;
+	msg->msg_iovlen = iovlen;
+}
+
+static void prep_diag_args(
+	struct nogvl_args *args,
+	struct sockaddr_nl *nladdr,
+	struct rtattr *rta,
+	struct diag_req *req,
+	struct msghdr *msg)
+{
+	memset(req, 0, sizeof(struct diag_req));
+	memset(nladdr, 0, sizeof(struct sockaddr_nl));
+
+	nladdr->nl_family = AF_NETLINK;
+
+	req->nlh.nlmsg_len = sizeof(struct diag_req) +
+	                    RTA_LENGTH(args->iov[2].iov_len);
+	req->nlh.nlmsg_type = TCPDIAG_GETSOCK;
+	req->nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
+	req->nlh.nlmsg_pid = getpid();
+	req->r.idiag_states = (1<<TCP_ESTABLISHED) | (1<<TCP_LISTEN);
+	rta->rta_type = INET_DIAG_REQ_BYTECODE;
+	rta->rta_len = RTA_LENGTH(args->iov[2].iov_len);
+
+	args->iov[0].iov_base = req;
+	args->iov[0].iov_len = sizeof(struct diag_req);
+	args->iov[1].iov_base = rta;
+	args->iov[1].iov_len = sizeof(struct rtattr);
+
+	prep_msghdr(msg, args, nladdr, 3);
+}
+
+static void prep_recvmsg_buf(struct nogvl_args *args)
+{
+	/* reuse buffer that was allocated for bytecode */
+	args->iov[0].iov_len = page_size;
+	args->iov[0].iov_base = args->iov[2].iov_base;
+}
+
 /* does the inet_diag stuff with netlink(), this is called w/o GVL */
 static VALUE diag(void *ptr)
 {
 	struct nogvl_args *args = ptr;
 	struct sockaddr_nl nladdr;
 	struct rtattr rta;
-	struct {
-		struct nlmsghdr nlh;
-		struct inet_diag_req r;
-	} req;
+	struct diag_req req;
 	struct msghdr msg;
 	const char *err = NULL;
-	unsigned seq = ++g_seq; /* not atomic, rely on GVL for now */
-	int fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_INET_DIAG);
-
-	if (fd < 0)
-		return (VALUE)err_socket;
+	unsigned seq = ++g_seq;
 
-	memset(&args->stats, 0, sizeof(struct listen_stats));
-
-	memset(&nladdr, 0, sizeof(nladdr));
-	nladdr.nl_family = AF_NETLINK;
-
-	memset(&req, 0, sizeof(req));
-	req.nlh.nlmsg_len = sizeof(req) + RTA_LENGTH(args->iov[2].iov_len);
-	req.nlh.nlmsg_type = TCPDIAG_GETSOCK;
-	req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
-	req.nlh.nlmsg_pid = getpid();
+	prep_diag_args(args, &nladdr, &rta, &req, &msg);
 	req.nlh.nlmsg_seq = seq;
-	req.r.idiag_family = AF_INET;
-	req.r.idiag_states = (1<<TCP_ESTABLISHED) | (1<<TCP_LISTEN);
-	rta.rta_type = INET_DIAG_REQ_BYTECODE;
-	rta.rta_len = RTA_LENGTH(args->iov[2].iov_len);
-
-	args->iov[0].iov_base = &req;
-	args->iov[0].iov_len = sizeof(req);
-	args->iov[1].iov_base = &rta;
-	args->iov[1].iov_len = sizeof(rta);
-
-	memset(&msg, 0, sizeof(msg));
-	msg.msg_name = (void *)&nladdr;
-	msg.msg_namelen = sizeof(nladdr);
-	msg.msg_iov = args->iov;
-	msg.msg_iovlen = 3;
-
-	if (sendmsg(fd, &msg, 0) < 0) {
+
+	if (sendmsg(args->fd, &msg, 0) < 0) {
 		err = err_sendmsg;
 		goto out;
 	}
 
-	/* reuse buffer that was allocated for bytecode */
-	args->iov[0].iov_len = page_size;
-	args->iov[0].iov_base = args->iov[2].iov_base;
+	prep_recvmsg_buf(args);
 
 	while (1) {
 		ssize_t readed;
+		size_t r;
 		struct nlmsghdr *h = (struct nlmsghdr *)args->iov[0].iov_base;
 
-		memset(&msg, 0, sizeof(msg));
-		msg.msg_name = (void *)&nladdr;
-		msg.msg_namelen = sizeof(nladdr);
-		msg.msg_iov = args->iov;
-		msg.msg_iovlen = 1;
-
-		readed = recvmsg(fd, &msg, 0);
+		prep_msghdr(&msg, args, &nladdr, 1);
+		readed = recvmsg(args->fd, &msg, 0);
 		if (readed < 0) {
 			if (errno == EINTR)
 				continue;
@@ -214,8 +385,8 @@ static VALUE diag(void *ptr)
 		}
 		if (readed == 0)
 			goto out;
-
-		for ( ; NLMSG_OK(h, readed); h = NLMSG_NEXT(h, readed)) {
+		r = (size_t)readed;
+		for ( ; NLMSG_OK(h, r); h = NLMSG_NEXT(h, r)) {
 			if (h->nlmsg_seq != seq)
 				continue;
 			if (h->nlmsg_type == NLMSG_DONE)
@@ -230,33 +401,90 @@ static VALUE diag(void *ptr)
 out:
 	{
 		int save_errno = errno;
-		close(fd);
+		if (err && args->table) {
+			st_foreach(args->table, st_free_data, 0);
+			st_free_table(args->table);
+		}
 		errno = save_errno;
 	}
 	return (VALUE)err;
 }
 
-/* populates inet my_addr struct by parsing +addr+ */
-static void parse_addr(struct my_addr *inet, VALUE addr)
+/* populates sockaddr_storage struct by parsing +addr+ */
+static void parse_addr(struct sockaddr_storage *inet, VALUE addr)
 {
-	char *host_port, *colon;
-
-	if (TYPE(addr) != T_STRING)
-		rb_raise(rb_eArgError, "addrs must be an Array of Strings");
+	char *host_ptr;
+	char *check;
+	char *colon = NULL;
+	char *rbracket = NULL;
+	void *dst;
+	long host_len;
+	int af, rc;
+	uint16_t *portdst;
+	unsigned long port;
+
+	Check_Type(addr, T_STRING);
+	host_ptr = StringValueCStr(addr);
+	host_len = RSTRING_LEN(addr);
+	if (*host_ptr == '[') { /* ipv6 address format (rfc2732) */
+		struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)inet;
+		rbracket = memchr(host_ptr + 1, ']', host_len - 1);
+
+		if (rbracket == NULL)
+			rb_raise(rb_eArgError, "']' not found in IPv6 addr=%s",
+			         host_ptr);
+		if (rbracket[1] != ':')
+			rb_raise(rb_eArgError, "':' not found in IPv6 addr=%s",
+			         host_ptr);
+		colon = rbracket + 1;
+		host_ptr++;
+		*rbracket = 0;
+		inet->ss_family = af = AF_INET6;
+		dst = &in6->sin6_addr;
+		portdst = &in6->sin6_port;
+	} else { /* ipv4 */
+		struct sockaddr_in *in = (struct sockaddr_in *)inet;
+		colon = memchr(host_ptr, ':', host_len);
+		inet->ss_family = af = AF_INET;
+		dst = &in->sin_addr;
+		portdst = &in->sin_port;
+	}
 
-	host_port = RSTRING_PTR(addr);
-	colon = memchr(host_port, ':', RSTRING_LEN(addr));
 	if (!colon)
-		rb_raise(rb_eArgError, "port not found in: `%s'", host_port);
-
+		rb_raise(rb_eArgError, "port not found in: `%s'", host_ptr);
+	port = strtoul(colon + 1, &check, 10);
 	*colon = 0;
-	inet->addr = inet_addr(host_port);
+	rc = inet_pton(af, host_ptr, dst);
 	*colon = ':';
-	inet->port = htons(my_inet_port(colon + 1));
+	if (rbracket) *rbracket = ']';
+	if (*check || ((uint16_t)port != port))
+		rb_raise(rb_eArgError, "invalid port: %s", colon + 1);
+	if (rc != 1)
+		rb_raise(rb_eArgError, "inet_pton failed for: `%s' with %d",
+		         host_ptr, rc);
+	*portdst = ntohs((uint16_t)port);
+}
+
+/* generates inet_diag bytecode to match all addrs */
+static void gen_bytecode_all(struct iovec *iov)
+{
+	struct inet_diag_bc_op *op;
+	struct inet_diag_hostcond *cond;
+
+	/* iov_len was already set and base allocated in a parent function */
+	assert(iov->iov_len == OPLEN && iov->iov_base && "iov invalid");
+	op = iov->iov_base;
+	op->code = INET_DIAG_BC_S_COND;
+	op->yes = OPLEN;
+	op->no = sizeof(struct inet_diag_bc_op) + OPLEN;
+	cond = (struct inet_diag_hostcond *)(op + 1);
+	cond->family = AF_UNSPEC;
+	cond->port = -1;
+	cond->prefix_len = 0;
 }
 
 /* generates inet_diag bytecode to match a single addr */
-static void gen_bytecode(struct iovec *iov, struct my_addr *inet)
+static void gen_bytecode(struct iovec *iov, struct sockaddr_storage *inet)
 {
 	struct inet_diag_bc_op *op;
 	struct inet_diag_hostcond *cond;
@@ -269,47 +497,79 @@ static void gen_bytecode(struct iovec *iov, struct my_addr *inet)
 	op->no = sizeof(struct inet_diag_bc_op) + OPLEN;
 
 	cond = (struct inet_diag_hostcond *)(op + 1);
-	cond->family = AF_INET;
-	cond->port = ntohs(inet->port);
-	cond->prefix_len = inet->addr == 0 ? 0 : sizeof(in_addr_t) * CHAR_BIT;
-	*cond->addr = inet->addr;
+	cond->family = inet->ss_family;
+	switch (inet->ss_family) {
+	case AF_INET: {
+		struct sockaddr_in *in = (struct sockaddr_in *)inet;
+
+		cond->port = ntohs(in->sin_port);
+		cond->prefix_len = in->sin_addr.s_addr == 0 ? 0 :
+				   sizeof(in->sin_addr.s_addr) * CHAR_BIT;
+		*cond->addr = in->sin_addr.s_addr;
+		}
+		break;
+	case AF_INET6: {
+		struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)inet;
+
+		cond->port = ntohs(in6->sin6_port);
+		cond->prefix_len = memcmp(&in6addr_any, &in6->sin6_addr,
+				          sizeof(struct in6_addr)) == 0 ?
+				  0 : sizeof(in6->sin6_addr) * CHAR_BIT;
+		memcpy(&cond->addr, &in6->sin6_addr, sizeof(struct in6_addr));
+		}
+		break;
+	default:
+		assert(0 && "unsupported address family, could that be IPv7?!");
+	}
 }
 
-static VALUE tcp_stats(struct nogvl_args *args, VALUE addr)
+static void nl_errcheck(VALUE r)
 {
-	const char *err;
-	VALUE verr;
+	const char *err = (const char *)r;
 
-	parse_addr(&args->query_addr, addr);
-	gen_bytecode(&args->iov[2], &args->query_addr);
-
-	verr = rb_thread_blocking_region(diag, args, RUBY_UBF_IO, 0);
-	err = (const char *)verr;
 	if (err) {
 		if (err == err_nlmsg)
 			rb_raise(rb_eRuntimeError, "NLMSG_ERROR");
 		else
 			rb_sys_fail(err);
 	}
+}
+
+static VALUE tcp_stats(struct nogvl_args *args, VALUE addr)
+{
+	struct sockaddr_storage query_addr;
+
+	parse_addr(&query_addr, addr);
+	gen_bytecode(&args->iov[2], &query_addr);
+
+	memset(&args->stats, 0, sizeof(struct listen_stats));
+	nl_errcheck(rb_thread_blocking_region(diag, args, 0, 0));
 
 	return rb_listen_stats(&args->stats);
 }
 
 /*
  * call-seq:
+ *      Raindrops::Linux.tcp_listener_stats([addrs[, sock]]) => hash
+ *
+ * If specified, +addr+ may be a string or array of strings representing
+ * listen addresses to filter for. Returns a hash with given addresses as
+ * keys and ListenStats objects as the values or a hash of all addresses.
+ *
  *      addrs = %w(0.0.0.0:80 127.0.0.1:8080)
- *      Raindrops::Linux.tcp_listener_stats(addrs) => hash
  *
- * Takes an array of strings representing listen addresses to filter for.
- * Returns a hash with given addresses as keys and ListenStats
- * objects as the values.
+ * If +addr+ is nil or not specified, all (IPv4) addresses are returned.
+ * If +sock+ is specified, it should be a Raindrops::InetDiagSock object.
  */
-static VALUE tcp_listener_stats(VALUE obj, VALUE addrs)
+static VALUE tcp_listener_stats(int argc, VALUE *argv, VALUE self)
 {
 	VALUE *ary;
 	long i;
-	VALUE rv;
+	VALUE rv = rb_hash_new();
 	struct nogvl_args args;
+	VALUE addrs, sock;
+
+	rb_scan_args(argc, argv, "02", &addrs, &sock);
 
 	/*
 	 * allocating page_size instead of OP_LEN since we'll reuse the
@@ -318,15 +578,45 @@ static VALUE tcp_listener_stats(VALUE obj, VALUE addrs)
 	 */
 	args.iov[2].iov_len = OPLEN;
 	args.iov[2].iov_base = alloca(page_size);
+	args.table = NULL;
+	if (NIL_P(sock))
+		sock = rb_funcall(cIDSock, id_new, 0);
+	args.fd = my_fileno(sock);
+
+	switch (TYPE(addrs)) {
+	case T_STRING:
+		rb_hash_aset(rv, addrs, tcp_stats(&args, addrs));
+		return rv;
+	case T_ARRAY:
+		ary = RARRAY_PTR(addrs);
+		i = RARRAY_LEN(addrs);
+		if (i == 1) {
+			rb_hash_aset(rv, *ary, tcp_stats(&args, *ary));
+			return rv;
+		}
+		for (; --i >= 0; ary++) {
+			struct sockaddr_storage check;
+
+			parse_addr(&check, *ary);
+			rb_hash_aset(rv, *ary, Qtrue);
+		}
+		/* fall through */
+	case T_NIL:
+		args.table = st_init_strtable();
+		gen_bytecode_all(&args.iov[2]);
+		break;
+	default:
+		rb_raise(rb_eArgError,
+		         "addr must be an array of strings, a string, or nil");
+	}
 
-	if (TYPE(addrs) != T_ARRAY)
-		rb_raise(rb_eArgError, "addrs must be an Array or String");
+	nl_errcheck(rb_thread_blocking_region(diag, &args, NULL, 0));
 
-	rv = rb_hash_new();
-	ary = RARRAY_PTR(addrs);
-	for (i = RARRAY_LEN(addrs); --i >= 0; ary++)
-		rb_hash_aset(rv, *ary, tcp_stats(&args, *ary));
+	st_foreach(args.table, NIL_P(addrs) ? st_to_hash : st_AND_hash, rv);
+	st_free_table(args.table);
 
+	/* let GC deal with corner cases */
+	if (argc < 2) rb_io_close(sock);
 	return rv;
 }
 
@@ -335,15 +625,23 @@ void Init_raindrops_linux_inet_diag(void)
 	VALUE cRaindrops = rb_const_get(rb_cObject, rb_intern("Raindrops"));
 	VALUE mLinux = rb_define_module_under(cRaindrops, "Linux");
 
+	rb_require("socket");
+	cIDSock = rb_const_get(rb_cObject, rb_intern("Socket"));
+	id_new = rb_intern("new");
+
+	/*
+	 * Document-class: Raindrops::InetDiagSocket
+	 *
+	 * This is a subclass of +Socket+ specifically for talking
+	 * to the inet_diag facility of Netlink.
+	 */
+	cIDSock = rb_define_class_under(cRaindrops, "InetDiagSocket", cIDSock);
+	rb_define_singleton_method(cIDSock, "new", ids_s_new, 0);
+
 	cListenStats = rb_const_get(cRaindrops, rb_intern("ListenStats"));
 
 	rb_define_module_function(mLinux, "tcp_listener_stats",
-	                          tcp_listener_stats, 1);
-
-#ifndef HAVE_RB_STRUCT_ALLOC_NOINIT
-	id_new = rb_intern("new");
-#endif
-	rb_require("raindrops/linux");
+	                          tcp_listener_stats, -1);
 
 	page_size = getpagesize();