girl 4.4.0 → 4.9.0

data/lib/girl/version.rb

@@ -1,3 +1,3 @@
 module Girl
-  VERSION = '4.4.0'.freeze
+  VERSION = '4.9.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: girl
 version: !ruby/object:Gem::Version
-  version: 4.4.0
+  version: 4.9.0
 platform: ruby
 authors:
 - takafan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-14 00:00:00.000000000 Z
+date: 2021-05-07 00:00:00.000000000 Z
 dependencies: []
 description: escape evil.
 email:
@@ -33,8 +33,6 @@ files:
 - lib/girl/resolv_custom.rb
 - lib/girl/resolvd.rb
 - lib/girl/resolvd_worker.rb
-- lib/girl/ssl.rb
-- lib/girl/ssl_worker.rb
 - lib/girl/version.rb
 homepage: https://github.com/takafan/girl
 licenses:
@@ -55,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: 妹子

data/lib/girl/ssl.rb

@@ -1,79 +0,0 @@
-require 'etc'
-require 'girl/concurrent_hash'
-require 'girl/head'
-require 'girl/ssl_worker'
-require 'girl/version'
-require 'json'
-require 'openssl'
-require 'socket'
-
-##
-# Girl::Ssl
-#
-module Girl
-  class Ssl
-
-    def initialize( config_path = nil )
-      unless config_path then
-        config_path = File.expand_path( '../girl.conf.json', __FILE__ )
-      end
-
-      raise "missing config file #{ config_path }" unless File.exist?( config_path )
-
-      conf = JSON.parse( IO.binread( config_path ), symbolize_names: true )
-      redir_port = conf[ :ssl_port ]
-      worker_count = conf[ :worker_count ]
-
-      unless redir_port then
-        redir_port = 1080
-      end
-
-      nprocessors = Etc.nprocessors
-
-      if worker_count.nil? || worker_count <= 0 || worker_count > nprocessors then
-        worker_count = nprocessors
-      end
-
-      len = CONSTS.map{ | name | name.size }.max
-
-      CONSTS.each do | name |
-        puts "#{ name.gsub( '_', ' ' ).ljust( len ) } #{ Girl.const_get( name ) }"
-      end
-
-      title = "girl ssl #{ Girl::VERSION }"
-      puts title
-      puts "redir port #{ redir_port } worker count #{ worker_count }"
-
-      $0 = title
-      workers = []
-
-      worker_count.times do | i |
-        workers << fork do
-          $0 = 'girl ssl worker'
-          worker = Girl::SslWorker.new( redir_port )
-
-          Signal.trap( :TERM ) do
-            puts "w#{ i } exit"
-            worker.quit!
-          end
-
-          worker.looping
-        end
-      end
-
-      Signal.trap( :TERM ) do
-        puts 'trap TERM'
-        workers.each do | pid |
-          begin
-            Process.kill( :TERM, pid )
-          rescue Errno::ESRCH => e
-            puts e.class
-          end
-        end
-      end
-
-      Process.waitall
-    end
-
-  end
-end

data/lib/girl/ssl_worker.rb

@@ -1,851 +0,0 @@
-module Girl
-  class SslWorker
-
-    ##
-    # initialize
-    #
-    def initialize( redir_port )
-      @redir_port = redir_port
-      @reads = []
-      @writes = []
-      @closing_srcs = []
-      @paused_srcs = []
-      @paused_dsts = []
-      @resume_srcs = []
-      @resume_dsts = []
-      @roles = ConcurrentHash.new         # sock => :dotr / :redir / :src / :dst
-      @src_infos = ConcurrentHash.new     # src => {}
-      @dst_infos = ConcurrentHash.new     # dst => {}
-      @resolv_caches = ConcurrentHash.new # domain => [ ip, created_at ]
-
-      dotr, dotw = IO.pipe
-      @dotw = dotw
-      add_read( dotr, :dotr )
-      new_a_redir
-    end
-
-    ##
-    # looping
-    #
-    def looping
-      puts "p#{ Process.pid } #{ Time.new } looping"
-      loop_check_expire
-      loop_check_resume
-
-      loop do
-        rs, ws = IO.select( @reads, @writes )
-
-        rs.each do | sock |
-          case @roles[ sock ]
-          when :dotr then
-            read_dotr( sock )
-          when :redir then
-            read_redir( sock )
-          when :src then
-            read_src( sock )
-          when :dst then
-            read_dst( sock )
-          end
-        end
-
-        ws.each do | sock |
-          case @roles[ sock ]
-          when :src then
-            write_src( sock )
-          when :dst then
-            write_dst( sock )
-          end
-        end
-      end
-    rescue Interrupt => e
-      puts e.class
-      quit!
-    end
-
-    ##
-    # quit!
-    #
-    def quit!
-      # puts "debug exit"
-      exit
-    end
-
-    private
-
-    ##
-    # add closing src
-    #
-    def add_closing_src( src )
-      return if src.closed? || @closing_srcs.include?( src )
-      @closing_srcs << src
-      next_tick
-    end
-
-    ##
-    # add dst wbuff
-    #
-    def add_dst_wbuff( dst, data )
-      return if dst.closed?
-      dst_info = @dst_infos[ dst ]
-      dst_info[ :wbuff ] << data
-      add_write( dst )
-
-      if dst_info[ :wbuff ].bytesize >= WBUFF_LIMIT then
-        puts "p#{ Process.pid } #{ Time.new } pause direct src #{ dst_info[ :domain ] }"
-        add_paused_src( dst_info[ :src ] )
-      end
-    end
-
-    ##
-    # add paused dst
-    #
-    def add_paused_dst( dst )
-      return if dst.closed? || @paused_dsts.include?( dst )
-      @reads.delete( dst )
-      @paused_dsts << dst
-    end
-
-    ##
-    # add paused src
-    #
-    def add_paused_src( src )
-      return if src.closed? || @paused_srcs.include?( src )
-      @reads.delete( src )
-      @paused_srcs << src
-    end
-
-    ##
-    # add read
-    #
-    def add_read( sock, role = nil )
-      return if sock.closed? || @reads.include?( sock )
-      @reads << sock
-
-      if role then
-        @roles[ sock ] = role
-      end
-
-      next_tick
-    end
-
-    ##
-    # add resume dst
-    #
-    def add_resume_dst( dst )
-      return if @resume_dsts.include?( dst )
-      @resume_dsts << dst
-      next_tick
-    end
-
-    ##
-    # add resume src
-    #
-    def add_resume_src( src )
-      return if @resume_srcs.include?( src )
-      @resume_srcs << src
-      next_tick
-    end
-
-    ##
-    # add socks5 conn reply
-    #
-    def add_socks5_conn_reply( src )
-      # +----+-----+-------+------+----------+----------+
-      # |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
-      # +----+-----+-------+------+----------+----------+
-      # | 1  |  1  | X'00' |  1   | Variable |    2     |
-      # +----+-----+-------+------+----------+----------+
-      redir_ip, redir_port = @redir_local_address.ip_unpack
-      data = [ [ 5, 0, 0, 1 ].pack( 'C4' ), IPAddr.new( redir_ip ).hton, [ redir_port ].pack( 'n' ) ].join
-      # puts "debug add src.wbuff socks5 conn reply #{ data.inspect }"
-      add_src_wbuff( src, data )
-    end
-
-    ##
-    # add src rbuff
-    #
-    def add_src_rbuff( src, data )
-      src_info = @src_infos[ src ]
-      src_info[ :rbuff ] << data
-
-      if src_info[ :rbuff ].bytesize >= WBUFF_LIMIT then
-        # puts "debug src.rbuff full"
-        add_closing_src( src )
-      end
-    end
-
-    ##
-    # add src wbuff
-    #
-    def add_src_wbuff( src, data )
-      return if src.closed? || @closing_srcs.include?( src )
-      src_info = @src_infos[ src ]
-      src_info[ :wbuff ] << data
-      src_info[ :last_recv_at ] = Time.new
-      add_write( src )
-
-      if src_info[ :wbuff ].bytesize >= WBUFF_LIMIT then
-        dst = src_info[ :dst ]
-
-        if dst then
-          puts "p#{ Process.pid } #{ Time.new } pause dst #{ src_info[ :destination_domain ] }"
-          add_paused_dst( dst )
-        end
-      end
-    end
-
-    ##
-    # add write
-    #
-    def add_write( sock )
-      return if sock.closed? || @writes.include?( sock )
-      @writes << sock
-      next_tick
-    end
-
-    ##
-    # close read dst
-    #
-    def close_read_dst( dst )
-      return if dst.closed?
-      # puts "debug close read dst"
-      dst.close_read
-      @reads.delete( dst )
-
-      if dst.closed? then
-        @writes.delete( dst )
-        @roles.delete( dst )
-        del_dst_info( dst )
-      end
-    end
-
-    ##
-    # close read src
-    #
-    def close_read_src( src )
-      return if src.closed?
-      # puts "debug close read src"
-      src_info = @src_infos[ src ]
-      src_info[ :close_read ] = true
-
-      if src_info[ :close_write ] then
-        close_sock( src )
-        del_src_info( src )
-      else
-        @reads.delete( src )
-      end
-    end
-
-    ##
-    # close redir
-    #
-    def close_redir( redir )
-      return if redir.closed?
-      redir.close
-      @roles.delete( redir )
-      @reads.delete( redir )
-      @src_infos.each { | src, _ | close_src( src ) }
-    end
-
-    ##
-    # close sock
-    #
-    def close_sock( sock )
-      sock.close
-      @reads.delete( sock )
-      @writes.delete( sock )
-      @roles.delete( sock )
-    end
-
-    ##
-    # close src
-    #
-    def close_src( src )
-      return if src.closed?
-      # puts "debug close src"
-      close_sock( src )
-      src_info = del_src_info( src )
-      dst = src_info[ :dst ]
-
-      if dst then
-        close_sock( dst )
-        del_dst_info( dst )
-      end
-    end
-
-    ##
-    # close write dst
-    #
-    def close_write_dst( dst )
-      return if dst.closed?
-      # puts "debug close write dst"
-      dst.close_write
-      @writes.delete( dst )
-
-      if dst.closed? then
-        @reads.delete( dst )
-        @roles.delete( dst )
-        del_dst_info( dst )
-      end
-    end
-
-    ##
-    # close write src
-    #
-    def close_write_src( src )
-      return if src.closed?
-      # puts "debug close write src"
-      src_info = @src_infos[ src ]
-      src_info[ :close_write ] = true
-
-      if src_info[ :close_read ] then
-        close_sock( src )
-        del_src_info( src )
-      else
-        @writes.delete( src )
-      end
-    end
-
-    ##
-    # del dst info
-    #
-    def del_dst_info( dst )
-      # puts "debug delete dst info"
-      dst_info = @dst_infos.delete( dst )
-      @paused_dsts.delete( dst )
-      @resume_dsts.delete( dst )
-      dst_info
-    end
-
-    ##
-    # del src info
-    #
-    def del_src_info( src )
-      # puts "debug delete src info"
-      src_info = @src_infos.delete( src )
-      @paused_srcs.delete( src )
-      @resume_srcs.delete( src )
-      src_info
-    end
-
-    ##
-    # loop check expire
-    #
-    def loop_check_expire
-      Thread.new do
-        loop do
-          sleep CHECK_EXPIRE_INTERVAL
-          now = Time.new
-
-          @src_infos.each do | src, src_info |
-            last_recv_at = src_info[ :last_recv_at ] || src_info[ :created_at ]
-            last_sent_at = src_info[ :last_sent_at ] || src_info[ :created_at ]
-            expire_after = src_info[ :dst ] ? EXPIRE_AFTER : EXPIRE_NEW
-
-            if ( now - last_recv_at >= expire_after ) && ( now - last_sent_at >= expire_after ) then
-              puts "p#{ Process.pid } #{ Time.new } expire src #{ expire_after } #{ src_info[ :id ] } #{ src_info[ :destination_domain ] }"
-              add_closing_src( src )
-
-              unless src_info[ :rbuff ].empty? then
-                puts "p#{ Process.pid } #{ Time.new } lost rbuff #{ src_info[ :rbuff ].inspect }"
-              end
-            end
-          end
-        end
-      end
-    end
-
-    ##
-    # loop check resume
-    #
-    def loop_check_resume
-      Thread.new do
-        loop do
-          sleep CHECK_RESUME_INTERVAL
-
-          @paused_srcs.each do | src |
-            src_info = @src_infos[ src ]
-            dst = src_info[ :dst ]
-
-            if dst && !dst.closed? then
-              dst_info = @dst_infos[ dst ]
-
-              if dst_info[ :wbuff ].size < RESUME_BELOW then
-                puts "p#{ Process.pid } #{ Time.new } resume direct src #{ src_info[ :destination_domain ] }"
-                add_resume_src( src )
-              end
-            end
-          end
-
-          @paused_dsts.each do | dst |
-            dst_info = @dst_infos[ dst ]
-            src = dst_info[ :src ]
-
-            if src && !src.closed? then
-              src_info = @src_infos[ src ]
-
-              if src_info[ :wbuff ].size < RESUME_BELOW then
-                puts "p#{ Process.pid } #{ Time.new } resume dst #{ dst_info[ :domain ] }"
-                add_resume_dst( dst )
-              end
-            end
-          end
-        end
-      end
-    end
-
-    ##
-    # new a dst
-    #
-    def new_a_dst( src, ip_info )
-      return if src.closed?
-      src_info = @src_infos[ src ]
-      domain = src_info[ :destination_domain ]
-      destination_addr = Socket.sockaddr_in( src_info[ :destination_port ], ip_info.ip_address )
-      dst = Socket.new( ip_info.ipv4? ? Socket::AF_INET : Socket::AF_INET6, Socket::SOCK_STREAM, 0 )
-
-      begin
-        dst.connect_nonblock( destination_addr )
-      rescue IO::WaitWritable
-        # connect nonblock 必抛 wait writable
-      rescue Exception => e
-        puts "p#{ Process.pid } #{ Time.new } dst connect destination #{ domain } #{ src_info[ :destination_port ] } #{ ip_info.ip_address } #{ e.class }, close src"
-        dst.close
-        add_closing_src( src )
-        return
-      end
-
-      # puts "debug a new dst #{ dst.local_address.inspect }"
-      dst_info = {
-        src: src,            # 对应src
-        domain: domain,      # 目的地
-        wbuff: '',           # 写前
-        closing_write: false # 准备关闭写
-      }
-
-      @dst_infos[ dst ] = dst_info
-      add_read( dst, :dst )
-      src_info[ :proxy_type ] = :direct
-      src_info[ :dst ] = dst
-      add_socks5_conn_reply( src )
-    end
-
-    ##
-    # new a redir
-    #
-    def new_a_redir
-      pre = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
-      pre.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
-      pre.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-      pre.bind( Socket.sockaddr_in( @redir_port, '0.0.0.0' ) )
-      @redir_local_address = pre.local_address
-      puts "p#{ Process.pid } #{ Time.new } pre bind on #{ @redir_port } local address #{ pre.local_address.inspect }"
-
-      now = Time.new
-      name = OpenSSL::X509::Name.new
-      key = OpenSSL::PKey::RSA.new 1024
-      cert = OpenSSL::X509::Certificate.new
-      cert.version = 2
-      cert.serial = 0
-      cert.not_before = now
-      cert.not_after = now + 365 * 24 * 60 * 60
-      cert.public_key = key.public_key
-      cert.subject = name
-      cert.issuer = name
-      cert.sign key, OpenSSL::Digest.new('SHA1')
-      context = OpenSSL::SSL::SSLContext.new
-      context.security_level = 1
-      context.add_certificate( cert, key )
-      redir = OpenSSL::SSL::SSLServer.new pre, context
-      redir.listen( 127 )
-      puts "p#{ Process.pid } #{ Time.new } redir listening"
-      add_read( redir, :redir )
-    end
-
-    ##
-    # next tick
-    #
-    def next_tick
-      @dotw.write( '.' )
-    end
-
-    ##
-    # resolve domain
-    #
-    def resolve_domain( src, domain )
-      resolv_cache = @resolv_caches[ domain ]
-
-      if resolv_cache then
-        ip_info, created_at = resolv_cache
-
-        if Time.new - created_at < RESOLV_CACHE_EXPIRE then
-          # puts "debug #{ domain } hit resolv cache #{ ip_info.inspect }"
-          new_a_dst( src, ip_info )
-          return
-        end
-
-        # puts "debug expire #{ domain } resolv cache"
-        @resolv_caches.delete( domain )
-      end
-
-      src_info = @src_infos[ src ]
-      src_info[ :proxy_type ] = :checking
-
-      Thread.new do
-        begin
-          ip_info = Addrinfo.ip( domain )
-        rescue Exception => e
-          puts "p#{ Process.pid } #{ Time.new } resolv #{ domain.inspect } #{ e.class }"
-        end
-
-        if ip_info then
-          @resolv_caches[ domain ] = [ ip_info, Time.new ]
-          puts "p#{ Process.pid } #{ Time.new } resolved #{ domain } #{ ip_info.ip_address }"
-          new_a_dst( src, ip_info )
-        else
-          add_closing_src( src )
-        end
-      end
-    end
-
-    ##
-    # set dst closing write
-    #
-    def set_dst_closing_write( dst )
-      return if dst.closed?
-      dst_info = @dst_infos[ dst ]
-      return if dst_info[ :closing_write ]
-      dst_info[ :closing_write ] = true
-      add_write( dst )
-    end
-
-    ##
-    # set src closing write
-    #
-    def set_src_closing_write( src )
-      return if src.closed? || @closing_srcs.include?( src )
-      src_info = @src_infos[ src ]
-      return if src_info[ :closing_write ]
-      src_info[ :closing_write ] = true
-      add_write( src )
-    end
-
-    ##
-    # read dotr
-    #
-    def read_dotr( dotr )
-      dotr.read_nonblock( 65535 )
-
-      if @closing_srcs.any? then
-        @closing_srcs.each { | src | close_src( src ) }
-        @closing_srcs.clear
-      end
-
-      if @resume_srcs.any? then
-        @resume_srcs.each do | src |
-          add_read( src )
-          @paused_srcs.delete( src )
-        end
-
-        @resume_srcs.clear
-      end
-
-      if @resume_dsts.any? then
-        @resume_dsts.each do | dst |
-          add_read( dst )
-          @paused_dsts.delete( dst )
-        end
-
-        @resume_dsts.clear
-      end
-    end
-
-    ##
-    # read redir
-    #
-    def read_redir( redir )
-      accepted = false
-
-      Thread.new do
-        sleep 1
-
-        unless accepted then
-          puts "p#{ Process.pid } #{ Time.new } accept timeout"
-          close_redir( redir )
-          new_a_redir
-        end
-      end
-
-      begin
-        src = redir.accept
-      rescue SystemExit => e
-        puts "p#{ Process.pid } #{ Time.new } redir accept #{ e.class }"
-        close_redir( redir )
-        return
-      rescue Exception => e
-        puts "p#{ Process.pid } #{ Time.new } redir accept #{ e.class }"
-        puts e.full_message
-        return
-      end
-
-      accepted = true
-      # puts "debug accept a src"
-
-      @src_infos[ src ] = {
-        proxy_proto: :uncheck,   # :uncheck / :socks5
-        proxy_type: :uncheck,    # :uncheck / :checking / :direct / :negotiation
-        destination_domain: nil, # 目的地域名
-        destination_port: nil,   # 目的地端口
-        is_connect: true,        # 代理协议是http的场合，是否是CONNECT
-        rbuff: '',               # 读到的流量
-        dst: nil,                # 对应的dst
-        wbuff: '',               # 从dst读到的流量
-        created_at: Time.new,    # 创建时间
-        last_recv_at: nil,       # 上一次收到新流量（由dst收到）的时间
-        last_sent_at: nil,       # 上一次发出流量（由dst发出）的时间
-        closing_write: false,    # 准备关闭写
-        close_read: false,       # 已经关闭读
-        close_write: false       # 已经关闭写
-      }
-
-      add_read( src, :src )
-    end
-
-    ##
-    # read src
-    #
-    def read_src( src )
-      if src.closed? then
-        puts "p#{ Process.pid } #{ Time.new } read src but src closed?"
-        return
-      end
-
-      src_info = @src_infos[ src ]
-
-      begin
-        data = src.read_nonblock( 65535 )
-      rescue IO::WaitReadable
-        return
-      rescue Errno::EINTR => e
-        puts e.class
-        return
-      rescue Exception => e
-        # puts "debug read src #{ e.class }"
-        dst = src_info[ :dst ]
-        close_read_src( src )
-
-        if dst then
-          set_dst_closing_write( dst )
-        end
-
-        return
-      end
-
-      src_info = @src_infos[ src ]
-      proxy_type = src_info[ :proxy_type ]
-
-      case proxy_type
-      when :uncheck then
-        if data[ 0 ].unpack( 'C' ).first != 5 then
-          "p#{ Process.pid } #{ Time.new } unknown data #{ data.inspect }"
-        end
-
-        # puts "debug socks5 #{ data.inspect }"
-
-        # https://tools.ietf.org/html/rfc1928
-        #
-        # +----+----------+----------+
-        # |VER | NMETHODS | METHODS  |
-        # +----+----------+----------+
-        # | 1  |    1     | 1 to 255 |
-        # +----+----------+----------+
-        nmethods = data[ 1 ].unpack( 'C' ).first
-        methods = data[ 2, nmethods ].unpack( 'C*' )
-
-        unless methods.include?( 0 ) then
-          puts "p#{ Process.pid } #{ Time.new } miss method 0x00"
-          add_closing_src( src )
-          return
-        end
-
-        # +----+--------+
-        # |VER | METHOD |
-        # +----+--------+
-        # | 1  |   1    |
-        # +----+--------+
-        data2 = [ 5, 0 ].pack( 'CC' )
-        add_src_wbuff( src, data2 )
-        src_info[ :proxy_proto ] = :socks5
-        src_info[ :proxy_type ] = :negotiation
-      when :checking then
-        # puts "debug add src rbuff before resolved #{ data.inspect }"
-        src_info[ :rbuff ] << data
-      when :negotiation then
-        # +----+-----+-------+------+----------+----------+
-        # |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
-        # +----+-----+-------+------+----------+----------+
-        # | 1  |  1  | X'00' |  1   | Variable |    2     |
-        # +----+-----+-------+------+----------+----------+
-        # puts "debug negotiation #{ data.inspect }"
-        ver, cmd, rsv, atyp = data[ 0, 4 ].unpack( 'C4' )
-
-        if cmd == 1 then
-          # puts "debug socks5 CONNECT"
-
-          if atyp == 1 then
-            destination_host, destination_port = data[ 4, 6 ].unpack( 'Nn' )
-            destination_addr = Socket.sockaddr_in( destination_port, destination_host )
-            destination_addrinfo = Addrinfo.new( destination_addr )
-            destination_ip = destination_addrinfo.ip_address
-            src_info[ :destination_domain ] = destination_ip
-            src_info[ :destination_port ] = destination_port
-            # puts "debug IP V4 address #{ destination_addrinfo.ip_unpack.inspect }"
-            new_a_dst( src, destination_addrinfo )
-          elsif atyp == 3 then
-            domain_len = data[ 4 ].unpack( 'C' ).first
-
-            if ( domain_len + 7 ) == data.bytesize then
-              domain = data[ 5, domain_len ]
-              port = data[ ( 5 + domain_len ), 2 ].unpack( 'n' ).first
-              src_info[ :destination_domain ] = domain
-              src_info[ :destination_port ] = port
-              # puts "debug DOMAINNAME #{ domain } #{ port }"
-              resolve_domain( src, domain )
-            end
-          end
-        else
-          puts "p#{ Process.pid } #{ Time.new } socks5 cmd #{ cmd } not implement"
-        end
-      when :direct then
-        dst = src_info[ :dst ]
-
-        if dst then
-          add_dst_wbuff( dst, data )
-        else
-          # puts "debug add src.rbuff #{ data.bytesize }"
-          add_src_rbuff( src, data )
-        end
-      end
-    end
-
-    ##
-    # read dst
-    #
-    def read_dst( dst )
-      if dst.closed? then
-        puts "p#{ Process.pid } #{ Time.new } read dst but dst closed?"
-        return
-      end
-
-      dst_info = @dst_infos[ dst ]
-      src = dst_info[ :src ]
-
-      begin
-        data = dst.read_nonblock( 65535 )
-      rescue IO::WaitReadable, Errno::EINTR
-        print 'r'
-        return
-      rescue Exception => e
-        # puts "debug read dst #{ e.class }"
-        close_read_dst( dst )
-        set_src_closing_write( src )
-        return
-      end
-
-      # puts "debug read dst #{ data.bytesize }"
-      add_src_wbuff( src, data )
-    end
-
-    ##
-    # write src
-    #
-    def write_src( src )
-      if src.closed? then
-        puts "p#{ Process.pid } #{ Time.new } write src but src closed?"
-        return
-      end
-
-      src_info = @src_infos[ src ]
-      dst = src_info[ :dst ]
-      data = src_info[ :wbuff ]
-
-      # 写前为空，处理关闭写
-      if data.empty? then
-        if src_info[ :closing_write ] then
-          close_write_src( src )
-        else
-          @writes.delete( src )
-        end
-
-        return
-      end
-
-      # 写入
-      begin
-        written = src.write_nonblock( data )
-      rescue IO::WaitWritable, Errno::EINTR
-        print 'w'
-        return
-      rescue Exception => e
-        # puts "debug write src #{ e.class }"
-        close_write_src( src )
-
-        if dst then
-          close_read_dst( dst )
-        end
-
-        return
-      end
-
-      data = data[ written..-1 ]
-      src_info[ :wbuff ] = data
-    end
-
-    ##
-    # write dst
-    #
-    def write_dst( dst )
-      if dst.closed? then
-        puts "p#{ Process.pid } #{ Time.new } write dst but dst closed?"
-        return
-      end
-
-      dst_info = @dst_infos[ dst ]
-      src = dst_info[ :src ]
-      data = dst_info[ :wbuff ]
-
-      # 写前为空，处理关闭写
-      if data.empty? then
-        if dst_info[ :closing_write ] then
-          close_write_dst( dst )
-        else
-          @writes.delete( dst )
-        end
-
-        return
-      end
-
-      # 写入
-      begin
-        written = dst.write_nonblock( data )
-      rescue IO::WaitWritable, Errno::EINTR
-        print 'w'
-        return
-      rescue Exception => e
-        # puts "debug write dst #{ e.class }"
-        close_write_dst( dst )
-        close_read_src( src )
-        return
-      end
-
-      data = data[ written..-1 ]
-      dst_info[ :wbuff ] = data
-
-      unless src.closed? then
-        src_info = @src_infos[ src ]
-        src_info[ :last_sent_at ] = Time.new
-      end
-    end
-
-  end
-end