yahns 1.14.1 → 1.18.0

data/README

@@ -16,6 +16,7 @@ Features
 * suitable for slow clients, fast clients, or a mixture of both
 * HTTP/0.9 support
 * HTTP/1.1 persistent connections and pipelining
+* HTTPS for HTTP/1.1 support
 * decodes HTTP chunked encoding for requests
 * parses HTTP/1.1 trailers in requests
 * supports streaming responses with lazy buffering for slow clients
@@ -55,40 +56,38 @@ Contact
 
 We are happy to see feedback of all types via plain-text email.
 Please send comments, user/dev discussion, patches, bug reports,
-and pull requests to the open-to-all mailing list at:
+and pull requests to our public inbox at:
 
 	yahns-public@yhbt.net
 
-No subscription is necessary to post.  Please Cc: all recipients as
-subscription is not necessary.
+Please use reply-to-all as we do not require any sort of subscription.
+We archive all of our mail publically at:
 
-You may optionally subscribe by sending an email to:
+	https://yhbt.net/yahns-public/
+	nntp://news.public-inbox.org/inbox.comp.lang.ruby.yahns
 
-	yahns-public+subscribe@yhbt.net
-
-Mailing list archives browsable via HTTP: https://yhbt.net/yahns-public/
-Or NNTP: nntp://news.public-inbox.org/inbox.comp.lang.ruby.yahns
+Atom feed: https://yhbt.net/yahns-public/new.atom
 
 This README is our homepage, we would rather be working on HTTP servers
 all day than worrying about the next browser vulnerability because
 HTML/CSS/JS is too complicated for us.
 
-* https://yhbt.net/yahns/README
+* https://yhbt.net/yahns.git/about/
 
 Hacking
 -------
 
 We use git and follow the same development model as git itself
-(mailing list-oriented, benevolent dictator).
+(email-oriented, benevolent dictator).
 
-	git clone git://yhbt.net/yahns
+	git clone https://yhbt.net/yahns.git
 
 Please use git-format-patch(1) and git-send-email(1) distributed with
 the git(7) suite for generating and sending patches.  Please format
 pull requests with the git-request-pull(1) script (also distributed
 with git(7)) and send them via email.
 
-See http://www.git-scm.com/ for more information on git.
+See https://www.git-scm.com/ for more information on git.
 
 Design
 ------

data/Rakefile

@@ -3,7 +3,24 @@
 require 'tempfile'
 include Rake::DSL
 
-gendocs = %w(NEWS NEWS.atom.xml)
+apidoc = {
+  'doc/Yahns.html' => 'lib/yahns.rb',
+  'doc/Yahns/ProxyPass.html' => 'lib/yahns/proxy_pass.rb'
+}
+
+task apidoc.keys[0] => apidoc.values do
+  rdoc = ENV['rdoc'] || 'rdoc'
+  system("git", "set-file-times", *(apidoc.values))
+  sh "#{rdoc} -f dark216" # dark216 requires olddoc 1.7+
+
+  apidoc.each do |dst, src|
+    src = File.stat(src)
+    File.utime(src.atime, src.mtime, dst)
+  end
+end
+
+gendocs = %W(NEWS NEWS.atom.xml #{apidoc.keys[0]})
+task html: apidoc.keys[0]
 task rsync_docs: gendocs do
   dest = ENV["RSYNC_DEST"] || "yhbt.net:/srv/yhbt/yahns/"
   top = %w(INSTALL HACKING README COPYING)
@@ -28,6 +45,7 @@ task rsync_docs: gendocs do
   files = `git ls-files Documentation/*.txt`.split(/\n/)
   files.concat(top)
   files.concat(gendocs)
+  files.concat(%w(doc/Yahns.html))
   files.concat(%w(yahns yahns-rackup yahns_config).map! { |x|
     "Documentation/#{x}.txt"
   })
@@ -41,6 +59,11 @@ task rsync_docs: gendocs do
   examples.concat(gzex)
 
   sh("rsync --chmod=Fugo=r -av #{examples.join(' ')} #{dest}/examples/")
+
+  rdoc = apidoc.keys.grep(%r{\Adoc/Yahns/})
+  gzex = rdoc.map { |txt| do_gzip.call(txt) }
+  examples.concat(gzex)
+  sh("rsync --chmod=Fugo=r -av #{rdoc.join(' ')} #{dest}/Yahns/")
 end
 
 def tags
@@ -66,12 +89,105 @@ def tags
   end.compact.sort { |a,b| b[:time] <=> a[:time] }
 end
 
+def xml(dst, tag, text = nil, attrs = nil)
+  if Hash === text
+    attrs = text
+    text = nil
+  end
+  if attrs
+    attrs = attrs.map { |k,v| "#{k}=#{v.encode(xml: :attr)}" }
+    attrs = "\n#{attrs.join("\n")}"
+  end
+  case text
+  when nil
+    if block_given?
+      dst << "<#{tag}#{attrs}>"
+      yield
+      dst << "</#{tag}>"
+    else
+      dst << "<#{tag}#{attrs}/>"
+    end
+  else
+    dst << "<#{tag}#{attrs}>#{text.encode(xml: :text)}</#{tag}>"
+  end
+end
+
 desc 'prints news as an Atom feed'
 task "NEWS.atom.xml" do
-  # gem install 'olddoc', 'olddoc prepare' has no API besides the
-  # command-line.  This requires olddoc 1.1 or later.
-  system('olddoc', 'prepare') or abort "olddoc prepare failed #$?"
+  require 'uri'
+  cgit_uri = URI('https://yhbt.net/yahns.git')
+  uri = URI('https://yhbt.net/yahns/')
+  new_tags = tags[0,10]
+  time = nil
+  project_name = 'yahns'
+  short_desc = File.readlines('README')[0].split(' - ')[0]
+  new_tags = tags[0,10]
+  atom_uri = uri.dup
+  atom_uri.path += 'NEWS.atom.xml'
+  news_uri = uri.dup
+  news_uri.path += 'NEWS.html'
+  dst = ''
+  xml(dst, 'feed', xmlns: 'http://www.w3.org/2005/Atom') do
+    xml(dst, 'id', atom_uri.to_s)
+    xml(dst, 'title', "#{project_name} news")
+    xml(dst, 'subtitle', short_desc)
+    xml(dst, 'link', rel: 'alternate', type: 'text/html', href: news_uri.to_s)
+    xml(dst, 'updated', new_tags.empty? ? '1970-01-01:00:00:00Z'
+                                      : new_tags[0][:time])
+    new_tags.each do |tag|
+      xml(dst, 'entry') do
+        xml(dst, 'title', tag[:subject])
+        xml(dst, 'updated', tag[:time])
+        xml(dst, 'published', tag[:time])
+        xml(dst, 'author') do
+          xml(dst, 'name', tag[:tagger_name])
+          xml(dst, 'email', tag[:tagger_email])
+        end
+        uri = cgit_uri.dup
+        uri.path += '/tag/'
+        uri.query = "id=#{tag[:tag]}"
+        uri = uri.to_s
+        xml(dst, 'link', rel: 'alternate', type: 'text/html', href: uri)
+        xml(dst, 'id', uri)
+        xml(dst, 'content', type: 'xhtml') do
+          xml(dst, 'div', xmlns: 'http://www.w3.org/1999/xhtml') do
+            xml(dst, 'pre', tag[:body])
+          end # div
+        end # content
+      end # entry
+    end # new_tags.each
+  end # feed
+
+  fp = Tempfile.new('NEWS.atom.xml', '.')
+  fp.sync = true
+  fp.write(dst)
+  fp.chmod 0644
+  File.utime(time, time, fp.path) if time
+  File.rename(fp.path, 'NEWS.atom.xml')
+  fp.close!
 end
 
 desc 'prints news as a text file'
-task 'NEWS' => 'NEWS.atom.xml'
+task 'NEWS' do
+  fp = Tempfile.new('NEWS', '.')
+  fp.sync = true
+  time = nil
+  tags.each do |tag|
+    time ||= tag[:time_obj]
+    line = tag[:subject] + ' / ' + tag[:time].sub(/T.*/, '')
+    fp.puts line
+    fp.puts('-' * line.length)
+    fp.puts
+    fp.puts tag[:body]
+    fp.puts
+  end
+  fp.write("Unreleased\n\n") unless fp.size > 0
+  fp.puts "COPYRIGHT"
+  fp.puts "---------"
+  fp.puts "Copyright (C) 2013-2017 all contributors <yahns-public@yhbt.net>"
+  fp.puts "License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>"
+  fp.chmod 0644
+  File.utime(time, time, fp.path) if time
+  File.rename(fp.path, 'NEWS')
+  fp.close!
+end

data/examples/https_proxy_pass.conf.rb

@@ -0,0 +1,36 @@
+# To the extent possible under law, Eric Wong has waived all copyright and
+# related or neighboring rights to this example.
+#
+# See examples/proxy_pass.ru for the complementary rackup file
+# <https://yhbt.net/yahns.git/tree/examples/proxy_pass.ru>
+
+# Setup an OpenSSL context:
+require 'openssl'
+ssl_ctx = OpenSSL::SSL::SSLContext.new
+ssl_ctx.cert = OpenSSL::X509::Certificate.new(
+  File.read('/etc/ssl/certs/example.crt')
+)
+ssl_ctx.extra_chain_cert = [
+  OpenSSL::X509::Certificate.new(
+    File.read('/etc/ssl/certs/chain.crt')
+  )
+]
+ssl_ctx.key = OpenSSL::PKey::RSA.new(
+  File.read('/etc/ssl/private/example.key')
+)
+
+# use defaults provided by Ruby on top of OpenSSL,
+# but disable client certificate verification as it is rare for servers:
+ssl_ctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_NONE)
+
+# Built-in session cache (only useful if worker_processes is nil or 1)
+ssl_ctx.session_cache_mode = OpenSSL::SSL::SSLContext::SESSION_CACHE_SERVER
+
+worker_processes 1
+app(:rack, "/path/to/proxy_pass.ru", preload: true) do
+  listen 443, ssl_ctx: ssl_ctx
+  listen '[::]:443', ipv6only: true, ssl_ctx: ssl_ctx
+end
+
+stdout_path "/path/to/my_logs/out.log"
+stderr_path "/path/to/my_logs/err.log"

data/examples/logrotate.conf

@@ -5,7 +5,7 @@
 # /etc/logrotate.d/yahns_app on my Debian systems
 #
 # See the logrotate(8) manpage for more information:
-#    http://linux.die.net/man/8/logrotate
+#    https://linux.die.net/man/8/logrotate
 
 # Modify the following glob to match the logfiles your app writes to:
 /var/log/yahns_app/*.log {

data/examples/proxy_pass.ru

@@ -0,0 +1,11 @@
+# To the extent possible under law, Eric Wong has waived all copyright and
+# related or neighboring rights to this example.
+#
+# See examples/https_proxy_pass.conf.rb for the complementary rackup file
+# <https://yhbt.net/yahns.git/tree/examples/https_proxy_pass.conf.rb>
+
+# optionally, intercept static requests with Rack::Static middleware:
+# use Rack::Static, root: '/path/to/public', gzip: true
+
+require 'yahns/proxy_pass'
+run Yahns::ProxyPass.new('http://127.0.0.1:6081')

data/extras/autoindex.rb

@@ -14,6 +14,21 @@ class Autoindex
   FN = %{<a href="%s">%s</a>}
   TFMT = "%Y-%m-%d %H:%M"
 
+  # default to a dark, web-safe (216 color) palette for power-savings.
+  # Color-capable browsers can respect the prefers-color-scheme:light
+  # @media query (browser support a work-in-progress)
+  STYLE = <<''.gsub(/^\s*/m, '').delete!("\n")
+@media screen {
+  *{background:#000;color:#ccc}
+  a{color:#69f;text-decoration:none}
+  a:visited{color:#96f}
+}
+@media screen AND (prefers-color-scheme:light) {
+  *{background:#fff;color:#333}
+  a{color:#00f;text-decoration:none}
+  a:visited{color:#808}
+}
+
   def initialize(app, *args)
     app.respond_to?(:root) or raise ArgumentError,
        "wrapped app #{app.inspect} does not respond to #root"
@@ -56,7 +71,7 @@ class Autoindex
     case env["REQUEST_METHOD"]
     when "GET", "HEAD"
       # try to serve the static file, first
-      status, headers, body = res = @app.call(env)
+      status, _, body = res = @app.call(env)
       return res if status.to_i != 404
 
       path_info = env["PATH_INFO"]
@@ -78,7 +93,7 @@ class Autoindex
       tryenv = env.dup
       @index.each do |base|
         tryenv["PATH_INFO"] = "#{path_info}#{base}"
-        status, headers, body = res = @app.call(tryenv)
+        status, _, body = res = @app.call(tryenv)
         return res if status.to_i != 404
       end
 
@@ -139,8 +154,9 @@ class Autoindex
       path_info_html = path_info_ue.split(%r{/}, -1).map! do |part|
         Rack::Utils.escape_html(part)
       end.join("/")
-      body = "<html><head><title>Index of #{path_info_html}</title></head>" \
-             "<body><h1>Index of #{path_info_html}</h1><hr><pre>\n" \
+      body = "<html><head><title>Index of #{path_info_html}</title>" \
+             "<style>#{STYLE}</style>" \
+             "</head><body><h1>Index of #{path_info_html}</h1><hr><pre>\n" \
              "#{dirs.concat(files).join("\n")}" \
              "</pre><hr></body></html>\n"
       h = { "Content-Type" => "text/html", "Content-Length" => body.size.to_s }

data/extras/exec_cgi.rb

@@ -1,6 +1,6 @@
 # -*- encoding: binary -*-
-# Copyright (C) 2013-2016 all contributors <yahns-public@yhbt.net>
-# License: GPLv2 or later (https://www.gnu.org/licenses/gpl-2.0.txt)
+# Copyright (C) 2013-2018 all contributors <yahns-public@yhbt.net>
+# License: GPL-2.0+ <https://www.gnu.org/licenses/gpl-2.0.txt>
 # frozen_string_literal: true
 #
 # if running under yahns, worker_processes is recommended to avoid conflicting
@@ -18,21 +18,31 @@
 #   use Rack::Chunked
 #   # other Rack middlewares can go here...
 #
-#   run ExecCgi.new('/path/to/cgit.cgi') # cgit: https://git.zx2c4.com/cgit/
+#   # cgit: https://git.zx2c4.com/cgit/
+#   run ExecCgi.new('/path/to/cgit.cgi', opts)
 #
 class ExecCgi
-  class MyIO < Kgio::Pipe
+  class MyIO
     attr_writer :my_pid
     attr_writer :body_tip
+    attr_reader :rd
+
+    def initialize(rd)
+      @rd = rd
+    end
 
     def each
-      buf = @body_tip || ''.dup
-      if buf.size > 0
-        yield buf
-      end
-      while tmp = kgio_read(8192, buf)
+      buf = @body_tip
+      yield buf unless buf.empty?
+
+      case tmp = @rd.read_nonblock(8192, buf, exception: false)
+      when :wait_readable
+        @rd.wait_readable
+      when nil
+        break
+      else # String
         yield tmp
-      end
+      end while true
       self
     ensure
       # do this sooner, since the response body may be buffered, we want
@@ -46,8 +56,8 @@ class ExecCgi
       # Note: this object (and any client-specific objects) will never
       # be shared across different threads, so we do not need extra
       # mutual exclusion here.
-      return if closed?
-      super
+      return if @rd.closed?
+      @rd.close
       begin
         Process.waitpid(@my_pid)
       rescue Errno::ECHILD
@@ -72,7 +82,7 @@ class ExecCgi
     SERVER_PROTOCOL
     SERVER_SOFTWARE
     SCRIPT_NAME
-  ).map(&:freeze)  # frozen strings are faster for Hash assignments
+  )
 
   def initialize(*args)
     @env = Hash === args[0] ? args.shift : {}
@@ -82,6 +92,7 @@ class ExecCgi
     first[0] == ?/ or args[0] = ::File.expand_path(first)
     File.executable?(args[0]) or
       raise ArgumentError, "#{args[0]} is not executable"
+    @opts = Hash === args[-1] ? args.pop : {}
   end
 
   # Calls the app
@@ -90,20 +101,23 @@ class ExecCgi
     cgi_env = { "GATEWAY_INTERFACE" => "CGI/1.1" }
     PASS_VARS.each { |key| val = env[key] and cgi_env[key] = val }
     env.each { |key,val| cgi_env[key] = val if key =~ /\AHTTP_/ }
-    pipe = MyIO.pipe
-    errbody = pipe[0]
-    errbody.my_pid = Process.spawn(cgi_env.merge!(@env), *@args,
-                                   out: pipe[1], close_others: true)
-    pipe[1].close
-    pipe = pipe[0]
 
-    if head = pipe.kgio_read(8192)
+    rd, wr = IO.pipe
+    io = MyIO.new(rd)
+    errbody = io
+    errbody.my_pid = spawn(cgi_env.merge!(@env), *@args,
+                           @opts.merge(out: wr, close_others: true))
+    wr.close
+
+    begin
+      head = rd.readpartial(8192)
       until head =~ /\r?\n\r?\n/
-        tmp = pipe.kgio_read(8192) or break
+        tmp = rd.readpartial(8192)
         head << tmp
+        tmp.clear
       end
       head, body = head.split(/\r?\n\r?\n/, 2)
-      pipe.body_tip = body
+      io.body_tip = body
 
       env["HTTP_VERSION"] ||= "HTTP/1.0" # stop Rack::Chunked for HTTP/0.9
 
@@ -117,8 +131,8 @@ class ExecCgi
       end
       status = headers.delete("Status") || 200
       errbody = nil
-      [ status, headers, pipe ]
-    else
+      [ status, headers, io ]
+    rescue EOFError
       [ 500, { "Content-Length" => "0", "Content-Type" => "text/plain" }, [] ]
     end
   ensure

data/extras/proxy_pass.rb

@@ -10,12 +10,13 @@ require 'rack/request'
 require 'thread'
 require 'timeout'
 
-# Totally synchronous and Rack 1.1-compatible, this will probably be rewritten.
-# to take advantage of rack.hijack and use the non-blocking I/O facilities
-# in yahns.  yahns may have to grow a supported API for that...
+# Totally synchronous and Rack 1.1-compatible.  See Yahns::ProxyPass for
+# the rewritten version which takes advantage of rack.hijack and uses
+# the internal non-blocking I/O facilities in yahns.  yahns may have to
+# grow a supported API for that...
+#
 # For now, we this blocks a worker thread; fortunately threads are reasonably
 # cheap on GNU/Linux...
-# This is totally untested but currently doesn't serve anything important.
 class ProxyPass # :nodoc:
   class ConnPool
     def initialize
@@ -36,7 +37,7 @@ class ProxyPass # :nodoc:
     attr_writer :expiry
 
     # called automatically by kgio_read!
-    def kgio_wait_readable(timeout = nil)
+    def wait_readable(timeout = nil)
       super(timeout || wait_time)
     end
 
@@ -59,7 +60,7 @@ class ProxyPass # :nodoc:
       @expiry = Time.now + timeout
       case rv = kgio_trywrite(buf)
       when :wait_writable
-        kgio_wait_writable(wait_time)
+        wait_writable(wait_time)
       when nil
         return
       when String

data/extras/try_gzip_static.rb

@@ -79,7 +79,10 @@ class TryGzipStatic
       "Accept-Ranges" => "bytes",
     }
     h["Cache-Control"] = "no-transform" unless mime =~ %r{\Atext\/}
-    h["Content-Encoding"] = "gzip" if gz_st
+    if gz_st
+      h["Content-Encoding"] = "gzip"
+      h["Vary"] = "Accept-Encoding"
+    end
     h
   end
 

data/lib/yahns/acceptor.rb

@@ -24,7 +24,7 @@ module Yahns::Acceptor # :nodoc:
       close
       return true
     end
-    @thrs.each { |t| t[:yahns_quit] = true }
+    @quit = true
     return true if __ac_quit_done?
 
     @thrs.each do
@@ -42,10 +42,10 @@ module Yahns::Acceptor # :nodoc:
   end
 
   def spawn_acceptor(nr, logger, client_class)
+    @quit = false
     @thrs = nr.times.map do
       Thread.new do
         queue = client_class.queue
-        t = Thread.current
         accept_flags = Kgio::SOCK_NONBLOCK | Kgio::SOCK_CLOEXEC
         qev_flags = client_class.superclass::QEV_FLAGS
         begin
@@ -64,7 +64,7 @@ module Yahns::Acceptor # :nodoc:
           sleep 1 # let other threads do some work
         rescue => e
           Yahns::Log.exception(logger, "accept loop", e)
-        end until t[:yahns_quit]
+        end until @quit
       end
     end
   end

data/lib/yahns/chunk_body.rb

@@ -2,7 +2,8 @@
 # Copyright (C) 2016 all contributors <yahns-public@yhbt.net>
 # License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
-class Yahns::ChunkBody
+
+class Yahns::ChunkBody # :nodoc:
   def initialize(body, vec)
     @body = body
     @vec = vec

data/lib/yahns/config.rb

@@ -4,8 +4,8 @@
 # frozen_string_literal: true
 #
 # Implements a DSL for configuring a yahns server.
-# See https://yhbt.net/yahns/examples/yahns_multi.conf.rb for a full
-# example configuration file.
+# See https://yhbt.net/yahns.git/tree/examples/yahns_multi.conf.rb
+# for a full example configuration file.
 class Yahns::Config # :nodoc:
   # public within yahns itself, NOT a public interface for users outside
   # of yahns.  See yahns/rack for usage example
@@ -328,8 +328,8 @@ class Yahns::Config # :nodoc:
         "#{var}: #{file} did not register #{type} in #{self.class}::APP_CLASS"
 
     # apps may have multiple configurator contexts
-    app = @app_instances[klass.instance_key(*args)] = klass.new(*args)
-    ctx = app.config_context
+    app_cfg = @app_instances[klass.instance_key(*args)] = klass.new(*args)
+    ctx = app_cfg.config_context
     if block_given?
       @block = CfgBlock.new(:app, ctx)
       instance_eval(&block)
@@ -409,7 +409,7 @@ class Yahns::Config # :nodoc:
     if String === val
       # we've already bound working_directory by the time we get here
       val = File.open(File.expand_path(val), "ab")
-      val.close_on_exec = val.sync = true
+      val.sync = true
     else
       rt = [ :puts, :write, :flush ] # match Rack::Lint
       rt.all? { |m| val.respond_to?(m) } or raise ArgumentError,
@@ -438,4 +438,9 @@ class Yahns::Config # :nodoc:
 
     @app_ctx.each { |app| app.logger ||= server.logger }
   end
+
+  def register_inherited(name)
+    return unless @config_listeners.empty? && @app_ctx.size == 1
+    @config_listeners[name] = { :yahns_app_ctx => @app_ctx[0] }
+  end
 end

data/lib/yahns/daemon.rb

@@ -32,7 +32,6 @@ module Yahns::Daemon # :nodoc:
       # We cannot use Yahns::Sigevent (eventfd) here because we need
       # to detect EOF on unexpected death, not just read/write
       rd, wr = IO.pipe
-      rd.close_on_exec = wr.close_on_exec = true
       grandparent = $$
       if fork
         wr.close # grandparent does not write

data/lib/yahns/http_client.rb

@@ -235,25 +235,17 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
     http_response_write(res, opt)
   end
 
-  # called automatically by kgio_write
-  def kgio_wait_writable(timeout = self.class.client_timeout)
-    super timeout
-  end
-
-  # called automatically by kgio_read
-  def kgio_wait_readable(timeout = self.class.client_timeout)
-    super timeout
-  end
-
   # used by StreamInput (and thus TeeInput) for input_buffering {false|:lazy}
   def yahns_read(bytes, buf)
     case rv = kgio_tryread(bytes, buf)
     when String, nil
       return rv
     when :wait_readable
-      kgio_wait_readable or raise Yahns::ClientTimeout, "waiting for read", []
+      wait_readable(self.class.client_timeout) or
+        raise Yahns::ClientTimeout, "waiting for read", []
     when :wait_writable
-      kgio_wait_writable or raise Yahns::ClientTimeout, "waiting for write", []
+      wait_writable(self.class.client_timeout) or
+        raise Yahns::ClientTimeout, "waiting for write", []
     end while true
   end
 
@@ -298,10 +290,18 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
     when Unicorn::HttpParserError # try to tell the client they're bad
       400
     else
+      n = 500
+      case e.class.to_s
+      when 'OpenSSL::SSL::SSLError'
+        if e.message.include?('wrong version number')
+          n = nil
+          e.set_backtrace([])
+        end
+      end
       Yahns::Log.exception(@hs.env["rack.logger"], "app error", e)
-      500
+      n
     end
-    kgio_trywrite(err_response(code))
+    kgio_trywrite(err_response(code)) if code
   rescue
   ensure
     shutdown rescue nil
@@ -314,12 +314,22 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
     true
   end
 
-  def trysendio(io, offset, count)
-    return 0 if count == 0
+  def do_pread(io, count, offset)
     count = 0x4000 if count > 0x4000
     buf = Thread.current[:yahns_sfbuf] ||= ''.dup
-    io.pos = offset
-    str = io.read(count, buf) or return # nil for EOF
+    if io.respond_to?(:pread)
+      io.pread(count, offset, buf)
+    else
+      io.pos = offset
+      io.read(count, buf)
+    end
+  rescue EOFError
+    nil
+  end
+
+  def trysendio(io, offset, count)
+    return 0 if count == 0
+    str = do_pread(io, count, offset) or return # nil for EOF
     n = 0
     case rv = kgio_trywrite(str)
     when String # partial write, keep trying