ds9 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa3ba996d357a12053551efdb6f4f60b89db4807
+  data.tar.gz: 24e779cd44010f0d19158199c75f849ff9db37c2
+SHA512:
+  metadata.gz: 5cd6a8a0d6e38d1374c1c0cde4e3c34cd46639a28e76df77e024281322570e33e1ed38afd5f62371604693fa5e4306675311f8b5a9913d90c225306b3c88a828
+  data.tar.gz: ca98ca2db7715ac4ad8e7ec22b0eecdbceb76f31e5ba701026f5c450e0d38b0664c6e91030c2b624704213a2688446005c980bdad6cd335bba31d4128ae6b23d

data/.autotest

@@ -0,0 +1,8 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+Autotest.add_hook :initialize do |at|
+  at.testlib          = 'minitest/autorun'
+  at.find_directories = ARGV unless ARGV.empty?
+end

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2015-06-23
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,13 @@
+.autotest
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+ext/ds9/ds9.c
+ext/ds9/ds9.h
+ext/ds9/ds9_frames.c
+ext/ds9/extconf.rb
+lib/ds9.rb
+test/helper.rb
+test/test_client.rb
+test/test_ds9.rb

data/README.md

@@ -0,0 +1,185 @@
+# DS9
+
+* https://github.com/tenderlove/ds9
+
+## DESCRIPTION:
+
+This library allows you to write HTTP/2 clients and servers.  It is a wrapper
+around nghttp2.
+
+## INSTALLING
+
+On OS X:
+
+```
+$ brew install nghttp2
+$ gem install ds9
+```
+
+I'm not sure about other platforms, but it should Just Work if you install
+libnghttp2.
+
+## FEATURES/PROBLEMS:
+
+* Needs nghttp2
+
+## SYNOPSIS:
+
+Here is a full client that supports server pushes:
+
+```ruby
+##
+# ruby client.rb https://nghttp2.org/
+# ruby client.rb https://www.google.com/
+
+require 'ds9'
+require 'socket'
+require 'openssl'
+require 'stringio'
+require 'uri'
+require 'thread'
+
+class MySession < DS9::Client
+  def initialize sock
+    @sock      = sock
+    @responses = Queue.new
+    @requests  = []
+    @in_flight = {}
+    super()
+  end
+
+  def on_stream_close id, errcode
+    @responses << @in_flight.delete(id)
+    puts "FINISHED READING STREAM: #{id}"
+    if @requests.any?
+      submit_request @requests.pop
+    else
+      @responses << nil
+      @thread.join
+      terminate_session DS9::NO_ERROR
+    end
+  end
+
+  def on_begin_headers frame
+    @in_flight[frame.stream_id] = StringIO.new if frame.headers?
+    @requests << [] if frame.push_promise?
+  end
+
+  def on_header name, value, frame, flags
+    if frame.push_promise?
+      @requests.last << [name, value]
+    else
+      puts "HEADER: #{name}: #{value}"
+    end
+  end
+
+  def on_data_chunk_recv id, data, flags
+    @in_flight[id] << data
+  end
+
+  def send_event string
+    @sock.write_nonblock string
+  end
+
+  def recv_event length
+    case data = @sock.read_nonblock(length, nil, exception: false)
+    when :wait_readable then DS9::ERR_WOULDBLOCK
+    when nil            then DS9::ERR_EOF
+    else
+      data
+    end
+  end
+
+  def run
+    @thread = Thread.new do
+      while response = @responses.pop
+        yield response
+      end
+    end
+
+    while want_read? || want_write?
+      rd, wr, _ = IO.select([@sock], [@sock])
+      receive
+      send
+    end
+  end
+end
+
+uri = URI.parse ARGV[0]
+socket = TCPSocket.new uri.host, uri.port
+
+ctx               = OpenSSL::SSL::SSLContext.new
+ctx.npn_protocols = [DS9::PROTO_VERSION_ID]
+ctx.npn_select_cb = lambda do |protocols|
+  if protocols.include?(DS9::PROTO_VERSION_ID)
+    puts "The negotiated protocol: " + DS9::PROTO_VERSION_ID
+    DS9::PROTO_VERSION_ID
+  end
+end
+
+socket            = OpenSSL::SSL::SSLSocket.new socket, ctx
+socket.hostname = uri.hostname
+socket.connect
+socket.sync_close = true
+
+session = MySession.new socket
+session.submit_settings []
+
+path = uri.path == '' ? '/' : uri.path
+session.submit_request [
+  [':method', 'GET'],
+  [':path', path],
+  [':scheme', uri.scheme],
+  [':authority', [uri.host, uri.port].join(':')],
+  ['accept', '*/*'],
+  ['user-agent', 'test'],
+]
+
+session.run do |res|
+  p res
+end
+```
+
+## HACKING:
+
+On OS X:
+
+```
+$ brew install nghttp2
+$ gem install hoe rake-compiler
+$ rake compile test
+```
+
+## REQUIREMENTS:
+
+* Needs nghttp2
+
+## INSTALL:
+
+* brew install nghttp2
+* gem install ds9
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2015 Aaron Patterson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,31 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugins.delete :rubyforge
+Hoe.plugin :minitest
+Hoe.plugin :gemspec # `gem install hoe-gemspec`
+Hoe.plugin :git     # `gem install hoe-git`
+
+gem 'rake-compiler', '>= 0.4.1'
+require "rake/extensiontask"
+
+Hoe.spec 'ds9' do
+  developer('Aaron Patterson', 'aaron@tenderlovemaking.com')
+  self.readme_file   = 'README.md'
+  self.history_file  = 'CHANGELOG.md'
+  self.extra_rdoc_files  = FileList['*.md']
+  extra_dev_deps << ['rake-compiler', '>= 0.4.1']
+
+  self.spec_extras = {
+    :required_ruby_version => '>= 2.2.2'
+  }
+
+  self.spec_extras[:extensions] = ["ext/ds9/extconf.rb"]
+  Rake::ExtensionTask.new "ds9", spec do |ext|
+    ext.lib_dir = File.join(*['lib', ENV['FAT_DIR']].compact)
+  end
+end
+
+# vim: syntax=ruby

data/ext/ds9/ds9.c

@@ -0,0 +1,838 @@
+#include <ds9.h>
+#include <assert.h>
+
+VALUE mDS9;
+VALUE cDS9Session;
+VALUE cDS9Client;
+VALUE cDS9Server;
+VALUE cDS9Callbacks;
+VALUE eDS9Exception;
+VALUE eDS9UninitializedException;
+
+ID id_on_header,
+   id_on_begin_headers,
+   id_on_frame_not_send,
+   id_on_begin_frame,
+   id_on_invalid_frame_recv,
+   id_send_event,
+   id_recv_event,
+   id_on_frame_send,
+   id_on_frame_recv,
+   id_on_stream_close,
+   id_on_data_chunk_recv,
+   id_on_data_source_read,
+   id_before_frame_send;
+
+#define CheckSelf(ptr) \
+    if (NULL == (ptr)) \
+      rb_raise(eDS9UninitializedException, "not initialized, call `super` from `initialize`");
+
+static void * wrap_xmalloc(size_t size, void *mem_user_data)
+{
+    return xmalloc(size);
+}
+
+static void wrap_xfree(void *ptr, void *mem_user_data)
+{
+    xfree(ptr);
+}
+
+static void *wrap_xcalloc(size_t nmemb, size_t size, void *mem_user_data)
+{
+    return xcalloc(nmemb, size);
+}
+
+static void *wrap_xrealloc(void *ptr, size_t size, void *mem_user_data)
+{
+    return xrealloc(ptr, size);
+}
+
+static VALUE explode(int code) {
+    return rb_funcall(eDS9Exception, rb_intern("abort"), 1, INT2NUM(code));
+}
+
+static int before_frame_send_callback(nghttp2_session *session,
+				      const nghttp2_frame *frame,
+				      void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+    VALUE ret;
+
+    ret = rb_funcall(self, id_before_frame_send, 1, WrapDS9Frame(frame));
+
+    if (ret == Qfalse) return 1;
+
+    return 0;
+}
+
+static ssize_t send_callback(nghttp2_session * session,
+			     const uint8_t *data,
+			     size_t length,
+			     int flags, void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+    VALUE ret;
+
+    ret = rb_funcall(self, id_send_event, 1, rb_str_new((const char *)data, length));
+
+    return NUM2INT(ret);
+}
+
+static int on_frame_recv_callback(nghttp2_session *session,
+				  const nghttp2_frame *frame,
+				  void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+    VALUE ret;
+
+    ret = rb_funcall(self, id_on_frame_recv, 1, WrapDS9Frame(frame));
+
+    if (ret == Qfalse) {
+	return 1;
+    }
+
+    return 0;
+}
+
+static int on_stream_close_callback(nghttp2_session *session,
+				    int32_t stream_id,
+				    uint32_t error_code,
+				    void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+
+    VALUE ret = rb_funcall(self, id_on_stream_close, 2, INT2NUM(stream_id), INT2NUM(error_code));
+
+    if (ret == Qfalse) {
+	return 1;
+    }
+
+    return 0;
+}
+
+static int on_header_callback(nghttp2_session *session,
+			      const nghttp2_frame *frame,
+			      const uint8_t *name, size_t namelen,
+			      const uint8_t *value, size_t valuelen,
+			      uint8_t flags, void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+
+    VALUE ret = rb_funcall(self, id_on_header, 4,
+	    rb_usascii_str_new((const char *)name, namelen),
+	    rb_usascii_str_new((const char *)value, valuelen),
+	    WrapDS9Frame(frame),
+	    INT2NUM(flags));
+
+    if (ret == Qfalse) {
+	return 1;
+    }
+
+    return 0;
+}
+
+static int on_begin_headers_callback(nghttp2_session *session,
+			             const nghttp2_frame *frame,
+			             void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+
+    VALUE ret = rb_funcall(self, id_on_begin_headers, 1,
+	    WrapDS9Frame(frame));
+
+    if (ret == Qfalse) {
+	return 1;
+    }
+
+    return 0;
+}
+
+static ssize_t recv_callback(nghttp2_session *session, uint8_t *buf,
+			     size_t length, int flags,
+			     void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+    VALUE ret;
+    ssize_t len;
+
+    ret = rb_funcall(self, id_recv_event, 1, INT2NUM(length));
+
+    if (FIXNUM_P(ret)) {
+	return NUM2INT(ret);
+    }
+
+    Check_Type(ret, T_STRING);
+    len = RSTRING_LEN(ret);
+
+    memcpy(buf, StringValuePtr(ret), len);
+
+    return len;
+}
+
+static int on_begin_frame_callback(nghttp2_session *session,
+				   const nghttp2_frame_hd *hd,
+				   void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+    VALUE ret;
+
+    ret = rb_funcall(self, id_on_begin_frame, 1, WrapDS9FrameHeader(hd));
+
+    if (ret == Qfalse) {
+	return 1;
+    }
+
+    return 0;
+}
+
+static int on_data_chunk_recv_callback(nghttp2_session *session,
+				       uint8_t flags,
+				       int32_t stream_id,
+				       const uint8_t *data,
+				       size_t len, void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+    VALUE ret;
+
+    ret = rb_funcall(self, id_on_data_chunk_recv, 3,
+	    INT2NUM(stream_id),
+	    rb_str_new((const char *)data, len),
+	    INT2NUM(flags));
+
+    if (ret == Qfalse) {
+	return 1;
+    }
+
+    return 0;
+}
+
+static int on_invalid_frame_recv_callback(nghttp2_session *session,
+					  const nghttp2_frame *frame, int lib_error_code,
+					  void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+    VALUE ret;
+
+    ret = rb_funcall(self, id_on_invalid_frame_recv, 2,
+	    WrapDS9Frame(frame),
+	    INT2NUM(lib_error_code));
+
+    if (ret == Qfalse) {
+	return 1;
+    }
+
+    return 0;
+}
+
+static int on_frame_send_callback(nghttp2_session *session,
+				  const nghttp2_frame *frame,
+				  void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+    VALUE ret;
+
+    ret = rb_funcall(self, id_on_frame_send, 1, WrapDS9Frame(frame));
+
+    if (ret == Qfalse) {
+	return 1;
+    }
+
+    return 0;
+}
+
+static int on_frame_not_send_callback(nghttp2_session *session,
+				      const nghttp2_frame *frame,
+				      int lib_error_code,
+				      void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+    VALUE reason = rb_str_new2(nghttp2_strerror(lib_error_code));
+    VALUE ret;
+
+    ret = rb_funcall(self, id_on_frame_not_send, 2, WrapDS9Frame(frame), reason);
+
+    if (ret == Qfalse) {
+	return 1;
+    }
+
+    return 0;
+}
+
+static ssize_t rb_data_read_callback(nghttp2_session *session,
+				     int32_t stream_id, uint8_t *buf,
+				     size_t length, uint32_t *data_flags,
+				     nghttp2_data_source *source, void *user_data)
+{
+    VALUE self = (VALUE)user_data;
+    VALUE ret;
+    ssize_t len;
+
+    ret = rb_funcall(self, id_on_data_source_read, 2, INT2NUM(stream_id),
+	    INT2NUM(length));
+
+    if (NIL_P(ret)) {
+	*data_flags |= NGHTTP2_DATA_FLAG_EOF;
+	return 0;
+    }
+
+    Check_Type(ret, T_STRING);
+    len = RSTRING_LEN(ret);
+    memcpy(buf, StringValuePtr(ret), len);
+
+    return len;
+}
+
+static void copy_list_to_nv(VALUE list, nghttp2_nv * head, size_t niv)
+{
+    size_t i;
+
+    for(i = 0; i < niv; i++, head++) {
+	VALUE tuple = rb_ary_entry(list, (long)i);
+	VALUE name = rb_ary_entry(tuple, 0);
+	VALUE value = rb_ary_entry(tuple, 1);
+
+	head->name = (uint8_t *)StringValuePtr(name);
+	head->namelen = RSTRING_LEN(name);
+
+	head->value = (uint8_t *)StringValuePtr(value);
+	head->valuelen = RSTRING_LEN(value);
+	head->flags = NGHTTP2_NV_FLAG_NONE;
+    }
+}
+
+static VALUE allocate_session(VALUE klass)
+{
+    return TypedData_Wrap_Struct(klass, &ds9_session_type, 0);
+}
+
+static VALUE client_init_internals(VALUE self, VALUE cb)
+{
+    nghttp2_session_callbacks *callbacks;
+    nghttp2_session *session;
+    nghttp2_mem mem = {
+	NULL,
+	wrap_xmalloc,
+	wrap_xfree,
+	wrap_xcalloc,
+	wrap_xrealloc
+    };
+
+    TypedData_Get_Struct(cb, nghttp2_session_callbacks, &ds9_callbacks_type, callbacks);
+
+    nghttp2_session_client_new3(&session, callbacks, (void *)self, NULL, &mem);
+    DATA_PTR(self) = session;
+
+    return self;
+}
+
+static VALUE server_init_internals(VALUE self, VALUE cb)
+{
+    nghttp2_session_callbacks *callbacks;
+    nghttp2_session *session;
+    nghttp2_mem mem = {
+	NULL,
+	wrap_xmalloc,
+	wrap_xfree,
+	wrap_xcalloc,
+	wrap_xrealloc
+    };
+
+    TypedData_Get_Struct(cb, nghttp2_session_callbacks, &ds9_callbacks_type, callbacks);
+
+    nghttp2_session_server_new3(&session, callbacks, (void *)self, NULL, &mem);
+    DATA_PTR(self) = session;
+
+    return self;
+}
+
+static VALUE session_want_write_p(VALUE self)
+{
+    nghttp2_session *session;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    if (nghttp2_session_want_write(session) == 0) {
+	return Qfalse;
+    }
+
+    return Qtrue;
+}
+
+static VALUE session_want_read_p(VALUE self)
+{
+    nghttp2_session *session;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    if (nghttp2_session_want_read(session) == 0) {
+	return Qfalse;
+    }
+
+    return Qtrue;
+}
+
+static VALUE session_submit_ping(VALUE self)
+{
+    nghttp2_session *session;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    if (nghttp2_submit_ping(session, NGHTTP2_FLAG_NONE, NULL) == 0)
+	return Qtrue;
+
+    return Qfalse;
+}
+
+static VALUE session_submit_settings(VALUE self, VALUE settings)
+{
+    size_t niv, i;
+    nghttp2_settings_entry *iv, *head;
+    nghttp2_session *session;
+    int rv;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    niv = RARRAY_LEN(settings);
+    iv = xcalloc(niv, sizeof(nghttp2_settings_entry));
+    head = iv;
+
+    for(i = 0; i < niv; i++, head++) {
+	VALUE tuple = rb_ary_entry(settings, (long)i);
+	head->settings_id = NUM2INT(rb_ary_entry(tuple, 0));
+	head->value = NUM2INT(rb_ary_entry(tuple, 1));
+    }
+
+    rv = nghttp2_submit_settings(session, NGHTTP2_FLAG_NONE, iv, niv);
+
+    xfree(iv);
+
+    if (0 != rv) {
+	explode(rv);
+    }
+
+    return self;
+}
+
+static VALUE session_send(VALUE self)
+{
+    int rv;
+    nghttp2_session *session;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    rv = nghttp2_session_send(session);
+    if (rv != 0) {
+	explode(rv);
+    }
+
+    return self;
+}
+
+static VALUE session_receive(VALUE self)
+{
+    int rv;
+    nghttp2_session *session;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    assert(session);
+    rv = nghttp2_session_recv(session);
+    if (rv != 0) {
+	explode(rv);
+    }
+
+    return self;
+}
+
+static VALUE session_mem_receive(VALUE self, VALUE buf)
+{
+    int rv;
+    nghttp2_session *session;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    rv = nghttp2_session_mem_recv(session, (const uint8_t *)StringValuePtr(buf), RSTRING_LEN(buf));
+    if (rv < 0) {
+	explode(rv);
+    }
+
+    return INT2NUM(rv);
+}
+
+static VALUE session_mem_send(VALUE self)
+{
+    ssize_t rv;
+    const uint8_t *data;
+    nghttp2_session *session;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    rv = nghttp2_session_mem_send(session, &data);
+
+    if (rv == 0) {
+	return Qfalse;
+    }
+
+    if (rv < 0) {
+	explode(rv);
+    }
+
+    return rb_str_new((const char *)data, rv);
+}
+
+static VALUE session_outbound_queue_size(VALUE self)
+{
+    nghttp2_session *session;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    return INT2NUM(nghttp2_session_get_outbound_queue_size(session));
+}
+
+static VALUE session_submit_request(VALUE self, VALUE settings)
+{
+    size_t niv, i;
+    nghttp2_nv *nva, *head;
+    nghttp2_session *session;
+    int rv;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    Check_Type(settings, T_ARRAY);
+    niv = RARRAY_LEN(settings);
+    nva = xcalloc(niv, sizeof(nghttp2_nv));
+
+    copy_list_to_nv(settings, nva, niv);
+
+    rv = nghttp2_submit_request(session, NULL, nva, niv, NULL, NULL);
+
+    xfree(nva);
+
+    if (rv < 0) {
+	explode(rv);
+    }
+
+    return INT2NUM(rv);
+}
+
+static VALUE session_submit_shutdown(VALUE self)
+{
+    int rv;
+    nghttp2_session *session;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    rv = nghttp2_submit_shutdown_notice(session);
+
+    if (rv == 0)
+	return Qtrue;
+
+    return explode(rv);
+}
+
+static VALUE session_submit_goaway(VALUE self, VALUE last_stream_id, VALUE err)
+{
+    int rv;
+    nghttp2_session *session;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    rv = nghttp2_submit_goaway(session, NGHTTP2_FLAG_NONE,
+	    NUM2INT(last_stream_id), NUM2INT(err), NULL, 0);
+
+    if (rv == 0)
+	return Qtrue;
+
+    return explode(rv);
+}
+
+static VALUE session_stream_local_closed_p(VALUE self, VALUE streamid)
+{
+    nghttp2_session *session;
+    int stream_id;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    stream_id = NUM2INT(streamid);
+
+    switch(nghttp2_session_get_stream_local_close(session, stream_id))
+    {
+	case 1:
+	    return Qtrue;
+	    break;
+	case 0:
+	    return Qfalse;
+	    break;
+	default:
+	    rb_raise(rb_eStandardError, "no such stream: %d", stream_id);
+    }
+
+    return Qfalse;
+}
+
+static VALUE session_stream_remote_closed_p(VALUE self, VALUE streamid)
+{
+    nghttp2_session *session;
+    int stream_id;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    stream_id = NUM2INT(streamid);
+
+    switch(nghttp2_session_get_stream_remote_close(session, stream_id))
+    {
+	case 1:
+	    return Qtrue;
+	    break;
+	case 0:
+	    return Qfalse;
+	    break;
+	default:
+	    rb_raise(rb_eStandardError, "no such stream: %d", stream_id);
+    }
+
+    return Qfalse;
+}
+
+static VALUE session_terminate_session(VALUE self, VALUE err)
+{
+    int rv;
+    nghttp2_session *session;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    rv = nghttp2_session_terminate_session(session, NUM2INT(err));
+
+    if (rv != 0) {
+	explode(rv);
+    }
+
+    return self;
+}
+
+static VALUE server_submit_response(VALUE self, VALUE stream_id, VALUE headers)
+{
+    nghttp2_session *session;
+    size_t niv;
+    nghttp2_nv *nva, *head;
+    nghttp2_data_provider provider;
+    int rv;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    niv = RARRAY_LEN(headers);
+    nva = xcalloc(niv, sizeof(nghttp2_nv));
+
+    copy_list_to_nv(headers, nva, niv);
+
+    provider.read_callback = rb_data_read_callback;
+
+    rv = nghttp2_submit_response(session, NUM2INT(stream_id), nva, niv, &provider);
+
+    xfree(nva);
+
+    if (0 != rv) {
+	explode(rv);
+    }
+
+    return self;
+}
+
+static VALUE make_callbacks(VALUE self)
+{
+    nghttp2_session_callbacks *callbacks;
+    nghttp2_session_callbacks_new(&callbacks);
+
+    if (rb_obj_respond_to(self, id_on_header, 1))
+	nghttp2_session_callbacks_set_on_header_callback(callbacks, on_header_callback);
+
+    if (rb_obj_respond_to(self, id_on_begin_headers, 1))
+	nghttp2_session_callbacks_set_on_begin_headers_callback(callbacks, on_begin_headers_callback);
+
+    if (rb_obj_respond_to(self, id_on_frame_not_send, 1))
+	nghttp2_session_callbacks_set_on_frame_not_send_callback(callbacks, on_frame_not_send_callback);
+
+    if (rb_obj_respond_to(self, id_on_begin_frame, 1))
+	nghttp2_session_callbacks_set_on_begin_frame_callback(callbacks, on_begin_frame_callback);
+
+    if (rb_obj_respond_to(self, id_on_invalid_frame_recv, 1))
+	nghttp2_session_callbacks_set_on_invalid_frame_recv_callback(callbacks, on_invalid_frame_recv_callback);
+
+    if (rb_obj_respond_to(self, id_send_event, 1))
+	nghttp2_session_callbacks_set_send_callback(callbacks, send_callback);
+
+    if (rb_obj_respond_to(self, id_recv_event, 1))
+	nghttp2_session_callbacks_set_recv_callback(callbacks, recv_callback);
+
+    if (rb_obj_respond_to(self, id_on_frame_send, 1))
+	nghttp2_session_callbacks_set_on_frame_send_callback(callbacks, on_frame_send_callback);
+
+    if (rb_obj_respond_to(self, id_on_frame_recv, 1))
+	nghttp2_session_callbacks_set_on_frame_recv_callback(callbacks, on_frame_recv_callback);
+
+    if (rb_obj_respond_to(self, id_on_stream_close, 1))
+	nghttp2_session_callbacks_set_on_stream_close_callback(callbacks, on_stream_close_callback);
+
+    if (rb_obj_respond_to(self, id_on_data_chunk_recv, 1))
+	nghttp2_session_callbacks_set_on_data_chunk_recv_callback(callbacks, on_data_chunk_recv_callback);
+
+    if (rb_obj_respond_to(self, id_before_frame_send, 1))
+	nghttp2_session_callbacks_set_before_frame_send_callback(callbacks, before_frame_send_callback);
+
+    return TypedData_Wrap_Struct(cDS9Callbacks, &ds9_callbacks_type, callbacks);
+}
+
+static VALUE server_submit_push_promise(VALUE self, VALUE stream_id, VALUE headers)
+{
+    nghttp2_session *session;
+    nghttp2_nv *nva, *head;
+    size_t niv, i;
+    int rv;
+
+    TypedData_Get_Struct(self, nghttp2_session, &ds9_session_type, session);
+    CheckSelf(session);
+
+    Check_Type(headers, T_ARRAY);
+    niv = RARRAY_LEN(headers);
+    nva = xcalloc(niv, sizeof(nghttp2_nv));
+    head = nva;
+
+    for(i = 0; i < niv; i++, head++) {
+	VALUE tuple = rb_ary_entry(headers, (long)i);
+	VALUE name = rb_ary_entry(tuple, 0);
+	VALUE value = rb_ary_entry(tuple, 1);
+
+	head->name = (uint8_t *)StringValuePtr(name);
+	head->namelen = RSTRING_LEN(name);
+
+	head->value = (uint8_t *)StringValuePtr(value);
+	head->valuelen = RSTRING_LEN(value);
+	head->flags = NGHTTP2_NV_FLAG_NONE;
+    }
+
+    rv = nghttp2_submit_push_promise(session, 0, NUM2INT(stream_id), nva, niv, NULL);
+
+    xfree(nva);
+
+    switch(rv) {
+	case NGHTTP2_ERR_NOMEM:
+	case NGHTTP2_ERR_PROTO:
+	case NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE:
+	case NGHTTP2_ERR_INVALID_ARGUMENT:
+	    return explode(rv);
+	    break;
+	default:
+	    return INT2NUM(rv);
+    }
+}
+
+static VALUE rb_nghttp_version(VALUE klass)
+{
+    nghttp2_info * info = nghttp2_version(0);
+
+    return rb_usascii_str_new2(info->version_str);
+}
+
+static VALUE errors_to_string(VALUE mod, VALUE err)
+{
+    return rb_usascii_str_new2(nghttp2_strerror(NUM2INT(err)));
+}
+
+void Init_ds9(void)
+{
+    mDS9 = rb_define_module("DS9");
+
+    Init_ds9_frames(mDS9);
+
+    rb_define_const(mDS9, "PROTO_VERSION_ID", rb_str_new(NGHTTP2_PROTO_VERSION_ID, NGHTTP2_PROTO_VERSION_ID_LEN));
+
+    eDS9Exception = rb_define_class_under(mDS9, "Exception", rb_eStandardError);
+    eDS9UninitializedException = rb_define_class_under(mDS9, "UninitializedException", rb_eStandardError);
+
+    VALUE mDS9Settings = rb_define_module_under(mDS9, "Settings");
+    rb_define_const(mDS9Settings, "MAX_CONCURRENT_STREAMS", INT2NUM(NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS));
+    rb_define_const(mDS9Settings, "INITIAL_WINDOW_SIZE", INT2NUM(NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE));
+    rb_define_const(mDS9Settings, "HEADER_TABLE_SIZE", INT2NUM(NGHTTP2_SETTINGS_HEADER_TABLE_SIZE));
+    rb_define_const(mDS9Settings, "ENABLE_PUSH", INT2NUM(NGHTTP2_SETTINGS_ENABLE_PUSH));
+    rb_define_const(mDS9Settings, "MAX_FRAME_SIZE", INT2NUM(NGHTTP2_SETTINGS_MAX_FRAME_SIZE));
+    rb_define_const(mDS9Settings, "MAX_HEADER_LIST_SIZE", INT2NUM(NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE));
+
+    rb_define_const(mDS9, "ERR_WOULDBLOCK", INT2NUM(NGHTTP2_ERR_WOULDBLOCK));
+    rb_define_const(mDS9, "ERR_EOF", INT2NUM(NGHTTP2_ERR_EOF));
+    rb_define_const(mDS9, "NO_ERROR", INT2NUM(NGHTTP2_NO_ERROR));
+    rb_define_const(mDS9, "DEFAULT_WEIGHT", INT2NUM(NGHTTP2_DEFAULT_WEIGHT));
+    rb_define_const(mDS9, "MAX_WEIGHT", INT2NUM(NGHTTP2_MAX_WEIGHT));
+    rb_define_const(mDS9, "MIN_WEIGHT", INT2NUM(NGHTTP2_MIN_WEIGHT));
+    rb_define_const(mDS9, "MAX_WINDOW_SIZE", INT2NUM(NGHTTP2_MAX_WINDOW_SIZE));
+    rb_define_const(mDS9, "INITIAL_WINDOW_SIZE", INT2NUM(NGHTTP2_INITIAL_WINDOW_SIZE));
+    rb_define_const(mDS9, "INITIAL_CONNECTION_WINDOW_SIZE", INT2NUM(NGHTTP2_INITIAL_CONNECTION_WINDOW_SIZE));
+    rb_define_const(mDS9, "DEFAULT_HEADER_TABLE_SIZE", INT2NUM(NGHTTP2_DEFAULT_HEADER_TABLE_SIZE));
+    rb_define_const(mDS9, "CLIENT_MAGIC", rb_str_new(NGHTTP2_CLIENT_MAGIC, NGHTTP2_CLIENT_MAGIC_LEN));
+
+    rb_define_singleton_method(mDS9, "nghttp_version", rb_nghttp_version, 0);
+
+    cDS9Callbacks = rb_define_class_under(mDS9, "Callbacks", rb_cData);
+
+    cDS9Session = rb_define_class_under(mDS9, "Session", rb_cObject);
+    cDS9Client = rb_define_class_under(mDS9, "Client", cDS9Session);
+    cDS9Server = rb_define_class_under(mDS9, "Server", cDS9Session);
+
+    rb_define_alloc_func(cDS9Session, allocate_session);
+
+    rb_define_method(cDS9Session, "want_write?", session_want_write_p, 0);
+    rb_define_method(cDS9Session, "want_read?", session_want_read_p, 0);
+    rb_define_method(cDS9Session, "submit_settings", session_submit_settings, 1);
+    rb_define_method(cDS9Session, "submit_ping", session_submit_ping, 0);
+    rb_define_method(cDS9Session, "submit_goaway", session_submit_goaway, 2);
+    rb_define_method(cDS9Session, "send", session_send, 0);
+    rb_define_method(cDS9Session, "receive", session_receive, 0);
+    rb_define_method(cDS9Session, "mem_receive", session_mem_receive, 1);
+    rb_define_method(cDS9Session, "mem_send", session_mem_send, 0);
+    rb_define_method(cDS9Session, "outbound_queue_size", session_outbound_queue_size, 0);
+    rb_define_method(cDS9Session, "terminate_session", session_terminate_session, 1);
+    rb_define_method(cDS9Session, "stream_local_closed?", session_stream_local_closed_p, 1);
+    rb_define_method(cDS9Session, "stream_remote_closed?", session_stream_remote_closed_p, 1);
+
+    rb_define_method(cDS9Session, "submit_request", session_submit_request, 1);
+    rb_define_private_method(cDS9Session, "make_callbacks", make_callbacks, 0);
+    rb_define_private_method(cDS9Client, "init_internals", client_init_internals, 1);
+    rb_define_private_method(cDS9Server, "init_internals", server_init_internals, 1);
+
+    rb_define_method(cDS9Server, "submit_response", server_submit_response, 2);
+    rb_define_method(cDS9Server, "submit_push_promise", server_submit_push_promise, 2);
+    rb_define_method(cDS9Server, "submit_shutdown", session_submit_shutdown, 0);
+
+    rb_define_singleton_method(eDS9Exception, "to_string", errors_to_string, 1);
+
+    id_on_header             = rb_intern("on_header");
+    id_on_begin_headers      = rb_intern("on_begin_headers");
+    id_on_frame_not_send     = rb_intern("on_frame_not_send");
+    id_on_begin_frame        = rb_intern("on_begin_frame");
+    id_on_invalid_frame_recv = rb_intern("on_invalid_frame_recv");
+    id_send_event            = rb_intern("send_event");
+    id_recv_event            = rb_intern("recv_event");
+    id_on_frame_send         = rb_intern("on_frame_send");
+    id_on_frame_recv         = rb_intern("on_frame_recv");
+    id_on_stream_close       = rb_intern("on_stream_close");
+    id_on_data_chunk_recv    = rb_intern("on_data_chunk_recv");
+    id_before_frame_send     = rb_intern("before_frame_send");
+    id_on_data_source_read   = rb_intern("on_data_source_read");
+}
+
+/* vim: set noet sws=4 sw=4: */