girl 3.7.0 → 4.2.0

data/lib/girl/proxyd.rb

@@ -5,7 +5,6 @@ require 'girl/proxyd_custom'
 require 'girl/proxyd_worker'
 require 'girl/version'
 require 'json'
-require 'openssl'
 require 'socket'
 
 ##
@@ -47,26 +46,13 @@ module Girl
       puts title
       puts "proxyd port #{ proxyd_port } infod port #{ infod_port } worker count #{ worker_count }"
 
-      now = Time.new
-      name = OpenSSL::X509::Name.new
-      key = OpenSSL::PKey::RSA.new 2048
-      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')
-
       $0 = title
       workers = []
 
       worker_count.times do | i |
         workers << fork do
           $0 = 'girl proxyd worker'
-          worker = Girl::ProxydWorker.new( proxyd_port, infod_port, cert, key )
+          worker = Girl::ProxydWorker.new( proxyd_port, infod_port )
 
           Signal.trap( :TERM ) do
             puts "w#{ i } exit"

data/lib/girl/proxyd_custom.rb

@@ -1,5 +1,8 @@
+require 'girl/custom'
+
 module Girl
   class ProxydCustom
+    include Custom
 
     def check( data, addrinfo )
       :success

data/lib/girl/proxyd_worker.rb

@@ -4,34 +4,31 @@ module Girl
     ##
     # initialize
     #
-    def initialize( proxyd_port, infod_port, cert, key )
+    def initialize( proxyd_port, infod_port )
       @custom = Girl::ProxydCustom.new
       @reads = []
       @writes = []
-      @closing_proxys = []
+      @deleting_ctl_infos = []
       @closing_dsts = []
-      @closing_tuns = []
       @paused_dsts = []
-      @paused_tuns = []
+      @paused_atuns = []
       @resume_dsts = []
-      @resume_tuns = []
-      @roles = ConcurrentHash.new         # sock => :dotr / :proxyd / :proxy / :infod / :dst / :tund / :tun
-      @proxy_infos = ConcurrentHash.new   # proxy => {}
+      @resume_atuns = []
+      @roles = ConcurrentHash.new         # sock => :dotr / :ctld / :ctl / :infod / :dst / :atund / :btund / :atun / :btun
+      @ctl_infos = ConcurrentHash.new     # ctl => {}
       @dst_infos = ConcurrentHash.new     # dst => {}
-      @tund_infos = ConcurrentHash.new    # tund => {}
-      @tun_infos = ConcurrentHash.new     # tun => {}
+      @atund_infos = ConcurrentHash.new   # atund => {}
+      @btund_infos = ConcurrentHash.new   # btund => {}
+      @atun_infos = ConcurrentHash.new    # atun => {}
+      @btun_infos = ConcurrentHash.new    # btun => {}
       @resolv_caches = ConcurrentHash.new # domain => [ ip, created_at ]
       @traff_ins = ConcurrentHash.new     # im => 0
       @traff_outs = ConcurrentHash.new    # im => 0
 
-      context = OpenSSL::SSL::SSLContext.new
-      context.add_certificate( cert, key )
-      @context = context
-
       dotr, dotw = IO.pipe
       @dotw = dotw
       add_read( dotr, :dotr )
-      new_a_proxyd( proxyd_port )
+      new_a_ctld( proxyd_port )
       new_a_infod( infod_port )
     end
 
@@ -51,29 +48,29 @@ module Girl
           case @roles[ sock ]
           when :dotr then
             read_dotr( sock )
-          when :proxyd then
-            read_proxyd( sock )
-          when :proxy then
-            read_proxy( sock )
+          when :ctld then
+            read_ctld( sock )
           when :infod then
             read_infod( sock )
           when :dst then
             read_dst( sock )
-          when :tund then
-            read_tund( sock )
-          when :tun then
-            read_tun( sock )
+          when :atund then
+            read_atund( sock )
+          when :btund then
+            read_btund( sock )
+          when :atun then
+            read_atun( sock )
+          when :btun then
+            read_btun( sock )
           end
         end
 
         ws.each do | sock |
           case @roles[ sock ]
-          when :proxy then
-            write_proxy( sock )
           when :dst then
             write_dst( sock )
-          when :tun then
-            write_tun( sock )
+          when :btun then
+            write_btun( sock )
           end
         end
       end
@@ -86,26 +83,25 @@ module Girl
     # quit!
     #
     def quit!
-      @proxy_infos.keys.each do | proxy |
-        # puts "debug1 send tund fin"
-        data = [ TUND_FIN ].pack( 'C' )
-        proxy.write( data )
-      end
-
-      # puts "debug1 exit"
+      # puts "debug exit"
       exit
     end
 
     private
 
     ##
-    # add ctlmsg
+    # add btun wbuff
     #
-    def add_ctlmsg( proxy, data )
-      return if proxy.closed? || @closing_proxys.include?( proxy )
-      proxy_info = @proxy_infos[ proxy ]
-      proxy_info[ :ctlmsgs ] << data
-      add_write( proxy )
+    def add_btun_wbuff( btun, data )
+      return if btun.closed?
+      btun_info = @btun_infos[ btun ]
+      btun_info[ :wbuff ] << data
+      add_write( btun )
+
+      if btun_info[ :wbuff ].bytesize >= WBUFF_LIMIT then
+        puts "p#{ Process.pid } #{ Time.new } pause dst #{ btun_info[ :domain_port ] }"
+        add_paused_dst( btun_info[ :dst ] )
+      end
     end
 
     ##
@@ -116,7 +112,7 @@ module Girl
       dst_info[ :rbuff ] << data
 
       if dst_info[ :rbuff ].bytesize >= WBUFF_LIMIT then
-        # puts "debug1 dst.rbuff full"
+        # puts "debug dst.rbuff full"
         close_dst( dst )
       end
     end
@@ -132,11 +128,20 @@ module Girl
       add_write( dst )
 
       if dst_info[ :wbuff ].bytesize >= WBUFF_LIMIT then
-        puts "p#{ Process.pid } #{ Time.new } pause tun #{ dst_info[ :domain_port ] }"
-        add_paused_tun( dst_info[ :tun ] )
+        puts "p#{ Process.pid } #{ Time.new } pause atun #{ dst_info[ :domain_port ] }"
+        add_paused_atun( dst_info[ :atun ] )
       end
     end
 
+    ##
+    # add paused atun
+    #
+    def add_paused_atun( atun )
+      return if tun.closed? || @paused_atuns.include?( atun )
+      @reads.delete( atun )
+      @paused_atuns << atun
+    end
+
     ##
     # add paused dst
     #
@@ -146,15 +151,6 @@ module Girl
       @paused_dsts << dst
     end
 
-    ##
-    # add paused tun
-    #
-    def add_paused_tun( tun )
-      return if tun.closed? || @paused_tuns.include?( tun )
-      @reads.delete( tun )
-      @paused_tuns << tun
-    end
-
     ##
     # add read
     #
@@ -169,6 +165,15 @@ module Girl
       next_tick
     end
 
+    ##
+    # add resume atun
+    #
+    def add_resume_atun( atun )
+      return if @resume_atuns.include?( atun )
+      @resume_atuns << atun
+      next_tick
+    end
+
     ##
     # add resume dst
     #
@@ -179,36 +184,57 @@ module Girl
     end
 
     ##
-    # add resume tun
+    # add write
     #
-    def add_resume_tun( tun )
-      return if @resume_tuns.include?( tun )
-      @resume_tuns << tun
+    def add_write( sock )
+      return if sock.closed? || @writes.include?( sock )
+      @writes << sock
       next_tick
     end
 
     ##
-    # add tun wbuff
+    # close atun
     #
-    def add_tun_wbuff( tun, data )
-      return if tun.closed? || @closing_tuns.include?( tun )
-      tun_info = @tun_infos[ tun ]
-      tun_info[ :wbuff ] << data
-      add_write( tun )
-
-      if tun_info[ :wbuff ].bytesize >= WBUFF_LIMIT then
-        puts "p#{ Process.pid } #{ Time.new } pause dst #{ tun_info[ :domain_port ] }"
-        add_paused_dst( tun_info[ :dst ] )
+    def close_atun( atun )
+      return if atun.closed?
+      # puts "debug close atun"
+      close_sock( atun )
+      del_atun_info( atun )
+    end
+
+    ##
+    # close atund
+    #
+    def close_atund( atund )
+      return if atund.closed?
+      # puts "debug close atund"
+      close_sock( atund )
+      @atund_infos.delete( atund )
+    end
+
+    ##
+    # close btun
+    #
+    def close_btun( btun )
+      return if btun.closed?
+      # puts "debug close btun"
+      close_sock( btun )
+      btun_info = @btun_infos.delete( btun )
+      dst = btun_info[ :dst ]
+
+      if dst then
+        @paused_dsts.delete( dst )
       end
     end
 
     ##
-    # add write
+    # close btund
     #
-    def add_write( sock )
-      return if sock.closed? || @writes.include?( sock )
-      @writes << sock
-      next_tick
+    def close_btund( btund )
+      return if btund.closed?
+      # puts "debug close btund"
+      close_sock( btund )
+      @btund_infos.delete( btund )
     end
 
     ##
@@ -216,14 +242,20 @@ module Girl
     #
     def close_dst( dst )
       return if dst.closed?
-      # puts "debug1 close dst"
+      # puts "debug close dst"
       close_sock( dst )
       dst_info = del_dst_info( dst )
-      tun = dst_info[ :tun ]
+      atun = dst_info[ :atun ]
+      btun = dst_info[ :btun ]
+
+      if atun then
+        close_sock( atun )
+        del_atun_info( atun )
+      end
 
-      if tun then
-        close_sock( tun )
-        @tun_infos.delete( tun )
+      if btun then
+        close_sock( btun )
+        @btun_infos.delete( btun )
       end
     end
 
@@ -232,40 +264,15 @@ module Girl
     #
     def close_read_dst( dst )
       return if dst.closed?
-      # puts "debug1 close read dst"
+      # puts "debug close read dst"
       dst.close_read
       @reads.delete( dst )
 
       if dst.closed? then
-        # puts "debug1 delete dst info"
         @writes.delete( dst )
         @roles.delete( dst )
-        dst_info = del_dst_info( dst )
-      else
-        dst_info = @dst_infos[ dst ]
-      end
-
-      dst_info
-    end
-
-    ##
-    # close read tun
-    #
-    def close_read_tun( tun )
-      return if tun.closed?
-      # puts "debug1 close read tun"
-      tun_info = @tun_infos[ tun ]
-      tun_info[ :close_read ] = true
-
-      if tun_info[ :close_write ] then
-        # puts "debug1 close tun"
-        close_sock( tun )
-        tun_info = @tun_infos.delete( tun )
-      else
-        @reads.delete( tun )
+        del_dst_info( dst )
       end
-
-      tun_info
     end
 
     ##
@@ -278,85 +285,27 @@ module Girl
       @roles.delete( sock )
     end
 
-    ##
-    # close tun
-    #
-    def close_tun( tun )
-      return if tun.closed?
-      # puts "debug1 close tun"
-      close_sock( tun )
-      tun_info = @tun_infos.delete( tun )
-      dst = tun_info[ :dst ]
-
-      if dst then
-        close_sock( dst )
-        del_dst_info( dst )
-      end
-    end
-
-    ##
-    # close proxy
-    #
-    def close_proxy( proxy )
-      return if proxy.closed?
-      # puts "debug1 close proxy"
-      close_sock( proxy )
-      proxy_info = @proxy_infos.delete( proxy )
-      tund = proxy_info[ :tund ]
-
-      if tund then
-        close_sock( tund )
-        @tund_infos.delete( tund )
-      end
-    end
-
     ##
     # close write dst
     #
     def close_write_dst( dst )
       return if dst.closed?
-      # puts "debug1 close write dst"
+      # puts "debug close write dst"
       dst.close_write
       @writes.delete( dst )
 
       if dst.closed? then
-        # puts "debug1 delete dst info"
         @reads.delete( dst )
         @roles.delete( dst )
         dst_info = del_dst_info( dst )
-      else
-        dst_info = @dst_infos[ dst ]
       end
-
-      dst_info
-    end
-
-    ##
-    # close write tun
-    #
-    def close_write_tun( tun )
-      return if tun.closed?
-      # puts "debug1 close write tun"
-      tun_info = @tun_infos[ tun ]
-      tun_info[ :close_write ] = true
-
-      if tun_info[ :close_read ] then
-        # puts "debug1 close tun"
-        close_sock( tun )
-        tun_info = @tun_infos.delete( tun )
-      else
-        @writes.delete( tun )
-      end
-
-      tun_info
     end
 
     ##
     # deal with destination addr
     #
-    def deal_with_destination_addr( proxy, src_id, destination_addr, domain_port )
+    def deal_with_destination_addr( ctl_addr, src_id, destination_addr, domain_port )
       dst = Socket.new( Addrinfo.new( destination_addr ).ipv4? ? Socket::AF_INET : Socket::AF_INET6, Socket::SOCK_STREAM, 0 )
-      dst.setsockopt( Socket::SOL_TCP, Socket::TCP_NODELAY, 1 )
 
       begin
         dst.connect_nonblock( destination_addr )
@@ -368,15 +317,16 @@ module Girl
       end
 
       dst_id = dst.local_address.ip_port
-      proxy_info = @proxy_infos[ proxy ]
+      ctl_info = @ctl_infos[ ctl_addr ]
 
       @dst_infos[ dst ] = {
         id: dst_id,               # id
-        proxy: proxy,             # 对应proxy
-        im: proxy_info[ :im ],    # 标识
+        ctl_addr: ctl_addr,       # 对应ctl
+        im: ctl_info[ :im ],      # 标识
         domain_port: domain_port, # 目的地和端口
         rbuff: '',                # 对应的tun没准备好，暂存读到的流量
-        tun: nil,                 # 对应的tun
+        atun: nil,                # 对应的atun
+        btun: nil,                # 对应的btun
         wbuff: '',                # 从tun读到的流量
         src_id: src_id,           # 近端src id
         created_at: Time.new,     # 创建时间
@@ -387,25 +337,47 @@ module Girl
 
       add_read( dst, :dst )
 
-      proxy_info[ :dst_ids ][ src_id ] = dst_id
-      proxy_info[ :dsts ][ dst_id ] = dst
+      ctl_info[ :dst_ids ][ src_id ] = dst_id
+      ctl_info[ :dsts ][ dst_id ] = dst
 
       data = [ PAIRED, src_id, dst_id ].pack( 'CQ>n' )
-      # puts "debug1 add ctlmsg paired #{ src_id } #{ dst_id }"
-      add_ctlmsg( proxy, data )
+      # puts "debug add ctlmsg paired #{ src_id } #{ dst_id }"
+      send_ctlmsg( data, ctl_addr )
+    end
+
+    ##
+    # del atun info
+    #
+    def del_atun_info( atun )
+      @atun_infos.delete( atun )
+      @paused_atuns.delete( atun )
+      @resume_atuns.delete( atun )
+    end
+
+    ##
+    # del ctl info
+    #
+    def del_ctl_info( ctl_addr )
+      # puts "debug delete ctl info"
+      ctl_info = @ctl_infos.delete( ctl_addr )
+      close_atund( ctl_info[ :atund ] )
+      close_btund( ctl_info[ :btund ] )
     end
 
     ##
     # del dst info
     #
     def del_dst_info( dst )
+      # puts "debug delete dst info"
       dst_info = @dst_infos.delete( dst )
-      proxy = dst_info[ :proxy ]
-
-      unless proxy.closed? then
-        proxy_info = @proxy_infos[ proxy ]
-        proxy_info[ :dsts ].delete( dst_info[ :id ] )
-        proxy_info[ :dst_ids ].delete( dst_info[ :src_id ] )
+      @paused_dsts.delete( dst )
+      @resume_dsts.delete( dst )
+      ctl_addr = dst_info[ :ctl_addr ]
+      ctl_info = @ctl_infos[ ctl_addr ]
+
+      if ctl_info then
+        ctl_info[ :dsts ].delete( dst_info[ :id ] )
+        ctl_info[ :dst_ids ].delete( dst_info[ :src_id ] )
       end
 
       dst_info
@@ -420,14 +392,12 @@ module Girl
           sleep CHECK_EXPIRE_INTERVAL
           now = Time.new
 
-          @proxy_infos.each do | proxy, proxy_info |
-            last_recv_at = proxy_info[ :last_recv_at ] || proxy_info[ :created_at ]
+          @ctl_infos.each do | ctl_addr, ctl_info |
+            if now - ctl_info[ :last_recv_at ] >= EXPIRE_CTL
+              puts "p#{ Process.pid } #{ Time.new } expire ctl #{ EXPIRE_CTL } #{ ctl_info[ :addrinfo ].inspect } tund ports #{ ctl_info[ :atund_port ] } #{ ctl_info[ :btund_port ] }"
 
-            if proxy_info[ :dsts ].empty? && ( now - last_recv_at >= EXPIRE_AFTER ) then
-              puts "p#{ Process.pid } #{ Time.new } expire proxy #{ proxy_info[ :addrinfo ].inspect }"
-
-              unless @closing_proxys.include?( proxy ) then
-                @closing_proxys << proxy
+              unless @deleting_ctl_infos.include?( ctl_addr ) then
+                @deleting_ctl_infos << ctl_addr
                 next_tick
               end
             end
@@ -436,7 +406,7 @@ module Girl
           @dst_infos.each do | dst, dst_info |
             last_recv_at = dst_info[ :last_recv_at ] || dst_info[ :created_at ]
             last_sent_at = dst_info[ :last_sent_at ] || dst_info[ :created_at ]
-            expire_after = dst_info[ :tun ] ? EXPIRE_AFTER : EXPIRE_NEW
+            expire_after = dst_info[ :btun ] ? 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 dst #{ expire_after } #{ dst_info[ :domain_port ] }"
@@ -460,31 +430,29 @@ module Girl
           sleep CHECK_RESUME_INTERVAL
 
           @paused_dsts.each do | dst |
-            if dst.closed? then
-              add_resume_dst( dst )
-            else
-              dst_info = @dst_infos[ dst ]
-              tun = dst_info[ :tun ]
-              tun_info = @tun_infos[ tun ]
+            dst_info = @dst_infos[ dst ]
+            btun = dst_info[ :btun ]
 
-              if tun_info[ :wbuff ].size < RESUME_BELOW then
+            if btun && !btun.closed? then
+              btun_info = @btun_infos[ btun ]
+
+              if btun_info[ :wbuff ].size < RESUME_BELOW then
                 puts "p#{ Process.pid } #{ Time.new } resume dst #{ dst_info[ :domain_port ] }"
                 add_resume_dst( dst )
               end
             end
           end
 
-          @paused_tuns.each do | tun |
-            if tun.closed? then
-              add_resume_tun( tun )
-            else
-              tun_info = @tun_infos[ tun ]
-              dst = tun_info[ :dst ]
+          @paused_atuns.each do | atun |
+            atun_info = @atun_infos[ atun ]
+            dst = atun_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 tun #{ tun_info[ :domain_port ] }"
-                add_resume_tun( tun )
+                puts "p#{ Process.pid } #{ Time.new } resume atun #{ atun_info[ :domain_port ] }"
+                add_resume_atun( atun )
               end
             end
           end
@@ -512,18 +480,15 @@ module Girl
     end
 
     ##
-    # new a proxyd
+    # new a ctld
     #
-    def new_a_proxyd( proxyd_port )
-      proxyd = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
-      proxyd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
-      proxyd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-      proxyd.setsockopt( Socket::SOL_TCP, Socket::TCP_NODELAY, 1 )
-      proxyd.bind( Socket.sockaddr_in( proxyd_port, '0.0.0.0' ) )
-      proxyd.listen( 127 )
-      puts "p#{ Process.pid } #{ Time.new } proxyd bind on #{ proxyd_port }"
-      ssl_proxyd = OpenSSL::SSL::SSLServer.new proxyd, @context
-      add_read( ssl_proxyd, :proxyd )
+    def new_a_ctld( proxyd_port )
+      ctld = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
+      ctld.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
+      ctld.bind( Socket.sockaddr_in( proxyd_port, '0.0.0.0' ) )
+      puts "p#{ Process.pid } #{ Time.new } ctld bind on #{ proxyd_port }"
+      add_read( ctld, :ctld )
+      @ctld = ctld
     end
 
     ##
@@ -533,11 +498,20 @@ module Girl
       infod = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
       infod.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
       infod.bind( Socket.sockaddr_in( infod_port, '127.0.0.1' ) )
-
       puts "p#{ Process.pid } #{ Time.new } infod bind on #{ infod_port }"
       add_read( infod, :infod )
     end
 
+    ##
+    # new a tund
+    #
+    def new_a_tund
+      tund = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
+      tund.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
+      tund.listen( 127 )
+      tund
+    end
+
     ##
     # next tick
     #
@@ -545,22 +519,31 @@ module Girl
       @dotw.write( '.' )
     end
 
+    ##
+    # pack a chunk
+    #
+    def pack_a_chunk( data )
+      # puts "debug pack a chunk"
+      data = @custom.encode( data )
+      "#{ [ data.bytesize ].pack( 'n' ) }#{ data }"
+    end
+
     ##
     # resolve domain
     #
-    def resolve_domain( proxy, src_id, domain_port )
+    def resolve_domain( ctl_addr, src_id, domain_port )
       resolv_cache = @resolv_caches[ domain_port ]
 
       if resolv_cache then
         destination_addr, created_at = resolv_cache
 
         if Time.new - created_at < RESOLV_CACHE_EXPIRE then
-          # puts "debug1 #{ domain_port } hit resolv cache #{ Addrinfo.new( destination_addr ).inspect }"
-          deal_with_destination_addr( proxy, src_id, destination_addr, domain_port )
+          # puts "debug #{ domain_port } hit resolv cache #{ Addrinfo.new( destination_addr ).inspect }"
+          deal_with_destination_addr( ctl_addr, src_id, destination_addr, domain_port )
           return
         end
 
-        # puts "debug1 expire #{ domain_port } resolv cache"
+        # puts "debug expire #{ domain_port } resolv cache"
         @resolv_caches.delete( domain_port )
       end
 
@@ -579,16 +562,38 @@ module Girl
         end
 
         if destination_addr then
-          # puts "debug1 resolved #{ domain_port } #{ Addrinfo.new( destination_addr ).inspect }"
+          # puts "debug resolved #{ domain_port } #{ Addrinfo.new( destination_addr ).inspect }"
           @resolv_caches[ domain_port ] = [ destination_addr, Time.new ]
-
-          unless proxy.closed? then
-            deal_with_destination_addr( proxy, src_id, destination_addr, domain_port )
-          end
+          deal_with_destination_addr( ctl_addr, src_id, destination_addr, domain_port )
         end
       end
     end
 
+    ##
+    # send ctlmsg
+    #
+    def send_ctlmsg( data, to_addr )
+      data = @custom.encode( data )
+
+      begin
+        @ctld.sendmsg( data, 0, to_addr )
+      rescue Exception => e
+        puts "p#{ Process.pid } #{ Time.new } sendmsg #{ e.class }"
+      end
+    end
+
+    ##
+    # set btun closing
+    #
+    def set_btun_closing( btun )
+      return if btun.closed?
+      btun_info = @btun_infos[ btun ]
+      return if btun_info[ :closing ]
+      # puts "debug set btun closing"
+      btun_info[ :closing ] = true
+      add_write( btun )
+    end
+
     ##
     # set dst closing write
     #
@@ -596,31 +601,20 @@ module Girl
       return if dst.closed? || @closing_dsts.include?( dst )
       dst_info = @dst_infos[ dst ]
       return if dst_info[ :closing_write ]
+      # puts "debug set dst closing write"
       dst_info[ :closing_write ] = true
       add_write( dst )
     end
 
-    ##
-    # set tun closing write
-    #
-    def set_tun_closing_write( tun )
-      return if tun.closed? || @closing_tuns.include?( tun )
-      tun_info = @tun_infos[ tun ]
-      return if tun_info[ :closing_write ]
-      tun_info[ :closing_write ] = true
-      add_write( tun )
-    end
-
     ##
     # read dotr
     #
     def read_dotr( dotr )
-      dotr.read_nonblock( READ_SIZE )
+      dotr.read_nonblock( 65535 )
 
-      # 处理关闭
-      if @closing_proxys.any? then
-        @closing_proxys.each { | proxy | close_proxy( proxy ) }
-        @closing_proxys.clear
+      if @deleting_ctl_infos.any? then
+        @deleting_ctl_infos.each { | ctl_addr | del_ctl_info( ctl_addr ) }
+        @deleting_ctl_infos.clear
       end
 
       if @closing_dsts.any? then
@@ -628,11 +622,6 @@ module Girl
         @closing_dsts.clear
       end
 
-      if @closing_tuns.any? then
-        @closing_tuns.each { | tun | close_tun( tun ) }
-        @closing_tuns.clear
-      end
-
       if @resume_dsts.any? then
         @resume_dsts.each do | dst |
           add_read( dst )
@@ -642,78 +631,33 @@ module Girl
         @resume_dsts.clear
       end
 
-      if @resume_tuns.any? then
-        @resume_tuns.each do | tun |
-          add_read( tun )
-          @paused_tuns.delete( tun )
+      if @resume_atuns.any? then
+        @resume_atuns.each do | atun |
+          add_read( atun )
+          @paused_atuns.delete( atun )
         end
 
-        @resume_tuns.clear
-      end
-    end
-
-    ##
-    # read proxyd
-    #
-    def read_proxyd( proxyd )
-      begin
-        proxy = proxyd.accept
-      rescue Exception => e
-        puts "p#{ Process.pid } #{ Time.new } proxyd accept #{ e.class }"
-        return
+        @resume_atuns.clear
       end
-
-      @proxy_infos[ proxy ] = {
-        addrinfo: proxy.io.remote_address, # proxy地址
-        im: nil,                        # 标识
-        tund: nil,                      # 对应tund
-        tund_port: nil,                 # tund端口
-        ctlmsgs: [],                    # ctlmsg
-        dsts: ConcurrentHash.new,       # dst_id => dst
-        dst_ids: ConcurrentHash.new,    # src_id => dst_id
-        created_at: Time.new,           # 创建时间
-        last_recv_at: nil               # 上一次收到流量的时间
-      }
-
-      puts "p#{ Process.pid } #{ Time.new } accept a proxy #{ proxy.io.remote_address.inspect } #{ proxy.ssl_version }, #{ @proxy_infos.size } proxys"
-      add_read( proxy, :proxy )
     end
 
     ##
-    # read proxy
+    # read ctld
     #
-    def read_proxy( proxy )
-      if proxy.closed? then
-        puts "p#{ Process.pid } #{ Time.new } read proxy but proxy closed?"
-        return
-      end
-
-      begin
-        data = proxy.read_nonblock( READ_SIZE )
-      rescue IO::WaitReadable
-        return
-      rescue Errno::EINTR
-        puts e.class
-        return
-      rescue Exception => e
-        # puts "debug1 read proxy #{ e.class }"
-        close_proxy( proxy )
-        return
-      end
-
-      proxy_info = @proxy_infos[ proxy ]
-      proxy_info[ :last_recv_at ] = Time.new
-
-      data.split( SEPARATE ).each do | ctlmsg |
-        next unless ctlmsg[ 0 ]
-
-        ctl_num = ctlmsg[ 0 ].unpack( 'C' ).first
+    def read_ctld( ctld )
+      data, addrinfo, rflags, *controls = ctld.recvmsg
+      data = @custom.decode( data )
+      ctl_num = data[ 0 ].unpack( 'C' ).first
+      ctl_addr = addrinfo.to_sockaddr
+      ctl_info = @ctl_infos[ ctl_addr ]
 
-        case ctl_num
-        when HELLO then
-          next if proxy_info[ :tund_port ] || ctlmsg.size <= 1
-          im = ctlmsg[ 1..-1 ]
-          addrinfo = proxy_info[ :addrinfo ]
+      case ctl_num
+      when HELLO then
+        if ctl_info then
+          atund_port, btund_port = ctl_info[ :atund_port ], ctl_info[ :btund_port ]
+        else
+          return if data.size <= 1
+          im = data[ 1..-1 ]
           result = @custom.check( im, addrinfo )
 
           if result != :success then
@@ -726,62 +670,65 @@ module Girl
             @traff_outs[ im ] = 0
           end
 
-          tund = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
-          tund.setsockopt( Socket::SOL_TCP, Socket::TCP_NODELAY, 1 )
-          tund.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
-          tund_port = tund.local_address.ip_port
-          tund.listen( 127 )
-          puts "p#{ Process.pid } #{ Time.new } tund #{ im.inspect } bind on #{ tund_port }"
-          ssl_tund = OpenSSL::SSL::SSLServer.new tund, @context
-          add_read( ssl_tund, :tund )
-
-          @tund_infos[ ssl_tund ] = {
-            proxy: proxy,
-            close_read: false,
-            close_write: false
+          atund = new_a_tund
+          atund_port = atund.local_address.ip_port
+          btund = new_a_tund
+          btund_port = btund.local_address.ip_port
+          add_read( atund, :atund )
+          add_read( btund, :btund )
+
+          @atund_infos[ atund ] = {
+            ctl_addr: ctl_addr,
+            im: im
           }
 
-          proxy_info[ :im ] = im
-          proxy_info[ :tund ] = ssl_tund
-          proxy_info[ :tund_port ] = tund_port
-          data2 = [ TUND_PORT, tund_port ].pack( 'Cn' )
-          add_ctlmsg( proxy, data2 )
-        when A_NEW_SOURCE then
-          next if ctlmsg.size <= 9
-          src_id = ctlmsg[ 1, 8 ].unpack( 'Q>' ).first
-          dst_id = proxy_info[ :dst_ids ][ src_id ]
-          next if dst_id
-          domain_port = ctlmsg[ 9..-1 ]
-          # puts "debug1 a new source #{ src_id } #{ domain_port }"
-          resolve_domain( proxy, src_id, domain_port )
-        when RESOLV then
-          next if ctlmsg.size <= 9
-          src_id = ctlmsg[ 1, 8 ].unpack( 'Q>' ).first
-          domain = ctlmsg[ 9..-1 ]
-
-          Thread.new do
-            begin
-              ip_info = Addrinfo.ip( domain )
-            rescue Exception => e
-              puts "p#{ Process.pid } #{ Time.new } resolv #{ domain.inspect } #{ e.class }"
-            end
+          @btund_infos[ btund ] = {
+            ctl_addr: ctl_addr,
+            im: im
+          }
 
-            if ip_info then
-              ip = ip_info.ip_address
-              puts "p#{ Process.pid } #{ Time.new } resolved #{ domain } #{ ip }"
-              data2 = "#{ [ RESOLVED, src_id ].pack( 'CQ>' ) }#{ ip }"
-              add_ctlmsg( proxy, data2 )
-            end
-          end
-        when TUN_FIN then
-          puts "p#{ Process.pid } #{ Time.new } got tun fin"
-          close_proxy( proxy )
+          @ctl_infos[ ctl_addr ] = {
+            addrinfo: addrinfo,          # 地址
+            im: im,                      # 标识
+            atund: atund,                # 对应atund，src->dst
+            atund_port: atund_port,      # atund端口
+            btund: btund,                # 对应btund，dst->src
+            btund_port: btund_port,      # btund端口
+            dsts: ConcurrentHash.new,    # dst_id => dst
+            dst_ids: ConcurrentHash.new, # src_id => dst_id
+            last_recv_at: Time.new       # 上一次收到流量的时间
+          }
+
+          puts "p#{ Process.pid } #{ Time.new } got hello #{ im.inspect }, atund listen on #{ atund_port }, btund listen on #{ btund_port }, ctl infos size #{ @ctl_infos.size }"
+        end
+
+        data2 = [ TUND_PORT, atund_port, btund_port ].pack( 'Cnn' )
+        send_ctlmsg( data2, ctl_addr )
+      when A_NEW_SOURCE then
+        unless ctl_info then
+          send_ctlmsg( [ UNKNOWN_CTL_ADDR ].pack( 'C' ), addrinfo )
+          return
+        end
+
+        return if data.size <= 9
+        src_id = data[ 1, 8 ].unpack( 'Q>' ).first
+        dst_id = ctl_info[ :dst_ids ][ src_id ]
+
+        if dst_id then
+          data2 = [ PAIRED, src_id, dst_id ].pack( 'CQ>n' )
+          # puts "debug dst id exist, send ctlmsg paired #{ src_id } #{ dst_id }"
+          send_ctlmsg( data2, ctl_addr )
           return
-        when HEARTBEAT
-          # puts "debug1 #{ Time.new } got heartbeat"
-          data2 = [ HEARTBEAT ].pack( 'C' )
-          add_ctlmsg( proxy, data2 )
         end
+
+        domain_port = data[ 9..-1 ]
+        # puts "debug got a new source #{ src_id } #{ domain_port }"
+        resolve_domain( ctl_addr, src_id, domain_port )
+        ctl_info[ :last_recv_at ] = Time.new
+      when CTL_FIN then
+        return unless ctl_info
+        # puts "debug got ctl fin #{ addrinfo.inspect }"
+        del_ctl_info( ctl_addr )
       end
     end
 
@@ -791,7 +738,7 @@ module Girl
     def read_infod( infod )
       data, addrinfo, rflags, *controls = infod.recvmsg
       ctl_num = data[ 0 ].unpack( 'C' ).first
-      # puts "debug1 infod got #{ ctl_num } #{ addrinfo.ip_unpack.inspect }"
+      # puts "debug infod got #{ ctl_num } #{ addrinfo.ip_unpack.inspect }"
 
       case ctl_num
       when TRAFF_INFOS then
@@ -805,9 +752,9 @@ module Girl
 
         begin
           infod.sendmsg_nonblock( data2, 0, addrinfo )
-        rescue IO::WaitWritable, Errno::EINTR
+        rescue IO::WaitWritable
           print 'w'
-        rescue Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ENETDOWN => e
+        rescue Exception => e
           puts "p#{ Process.pid } #{ Time.new } infod sendmsg to #{ addrinfo.ip_unpack.inspect } #{ e.class }"
         end
       end
@@ -822,157 +769,270 @@ module Girl
         return
       end
 
+      dst_info = @dst_infos[ dst ]
+      btun = dst_info[ :btun ]
+
       begin
-        data = dst.read_nonblock( READ_SIZE )
-      rescue IO::WaitReadable, Errno::EINTR
+        data = dst.read_nonblock( 65535 )
+      rescue IO::WaitReadable
         print 'r'
         return
       rescue Exception => e
-        # puts "debug1 read dst #{ e.class }"
-        dst_info = close_read_dst( dst )
-        tun = dst_info[ :tun ]
-        set_tun_closing_write( tun ) if tun
+        # puts "debug read dst #{ e.class }"
+        close_read_dst( dst )
+
+        if btun then
+          set_btun_closing( btun )
+        end
+
         return
       end
 
-      dst_info = @dst_infos[ dst ]
       @traff_ins[ dst_info[ :im ] ] += data.bytesize
-      tun = dst_info[ :tun ]
+      # puts "debug read dst #{ data.bytesize }"
 
-      if tun then
-        unless tun.closed? then
-          tun_info = @tun_infos[ tun ]
-          # puts "debug2 add tun.wbuff #{ data.bytesize }"
-          add_tun_wbuff( tun, data )
-        end
+      if btun then
+        add_btun_wbuff( btun, pack_a_chunk( data ) )
       else
+        # puts "debug add dst.rbuff #{ data.bytesize }"
         add_dst_rbuff( dst, data )
       end
     end
 
     ##
-    # read tund
+    # read atund
     #
-    def read_tund( tund )
-      if tund.closed? then
-        puts "p#{ Process.pid } #{ Time.new } read tund but tund closed?"
+    def read_atund( atund )
+      if atund.closed? then
+        puts "p#{ Process.pid } #{ Time.new } read atund but atund closed?"
         return
       end
 
+      atund_info = @atund_infos[ atund ]
+
       begin
-        tun = tund.accept
+        atun, _ = atund.accept_nonblock
       rescue Exception => e
-        puts "p#{ Process.pid } #{ Time.new } tund accept #{ e.class }"
+        puts "p#{ Process.pid } #{ Time.new } atund #{ atund_info[ :im ] } accept #{ e.class }"
+        puts e.full_message
         return
       end
 
-      # puts "debug1 accept a tun #{ tun.ssl_version }"
-      tund_info = @tund_infos[ tund ]
-      proxy = tund_info[ :proxy ]
-      proxy_info = @proxy_infos[ proxy ]
-
-      @tun_infos[ tun ] = {
-        proxy: proxy,          # 对应proxy
-        im: proxy_info[ :im ], # 标识
-        dst: nil,              # 对应dst
-        domain_port: nil,      # dst的目的地和端口
-        wbuff: '',             # 写前
-        closing_write: false   # 准备关闭写
+      # puts "debug accept a atun #{ atund_info[ :im ] }"
+
+      @atun_infos[ atun ] = {
+        ctl_addr: atund_info[ :ctl_addr ], # 对应ctl
+        im: atund_info[ :im ],             # 标识
+        dst: nil,                          # 对应dst
+        domain_port: nil,                  # dst的目的地和端口
+        rbuff: '',                         # 暂存当前块没收全的流量
+        wait_bytes: 0                      # 还差多少字节收全当前块
       }
 
-      add_read( tun, :tun )
+      add_read( atun, :atun )
     end
 
     ##
-    # read tun
+    # read btund
     #
-    def read_tun( tun )
-      if tun.closed? then
-        puts "p#{ Process.pid } #{ Time.new } read tun but tun closed?"
+    def read_btund( btund )
+      if btund.closed? then
+        puts "p#{ Process.pid } #{ Time.new } read btund but btund closed?"
         return
       end
 
+      btund_info = @btund_infos[ btund ]
+
       begin
-        data = tun.read_nonblock( READ_SIZE )
-      rescue IO::WaitReadable
+        btun, _ = btund.accept_nonblock
+      rescue Exception => e
+        puts "p#{ Process.pid } #{ Time.new } btund #{ btund_info[ :im ] } accept #{ e.class }"
+        puts e.full_message
         return
-      rescue Errno::EINTR
-        puts e.class
+      end
+
+      # puts "debug accept a btun #{ btund_info[ :im ] }"
+
+      @btun_infos[ btun ] = {
+        ctl_addr: btund_info[ :ctl_addr ], # 对应ctl
+        im: btund_info[ :im ],             # 标识
+        dst: nil,                          # 对应dst
+        domain_port: nil,                  # dst的目的地和端口
+        wbuff: '',                         # 写前
+        closing: false                     # 准备关闭
+      }
+
+      add_read( btun, :btun )
+    end
+
+    ##
+    # read atun
+    #
+    def read_atun( atun )
+      if atun.closed? then
+        puts "p#{ Process.pid } #{ Time.new } read atun but atun closed?"
         return
+      end
+
+      atun_info = @atun_infos[ atun ]
+      dst = atun_info[ :dst ]
+
+      begin
+        data = atun.read_nonblock( READ_SIZE )
       rescue Exception => e
-        # puts "debug1 read tun #{ e.class }"
-        tun_info = close_read_tun( tun )
-        dst = tun_info[ :dst ]
-        set_dst_closing_write( dst ) if dst
+        # puts "debug read atun #{ atun_info[ :im ] } #{ e.class }"
+        close_atun( atun )
+
+        if dst then
+          set_dst_closing_write( dst )
+        end
+
         return
       end
 
-      tun_info = @tun_infos[ tun ]
-      @traff_ins[ tun_info[ :im ] ] += data.bytesize
-      dst = tun_info[ :dst ]
-
       unless dst then
+        if data.bytesize < 2 then
+          # puts "debug unexpect data length #{ data.bytesize }"
+          close_atun( atun )
+        end
+
         dst_id = data[ 0, 2 ].unpack( 'n' ).first
-        proxy = tun_info[ :proxy ]
+        ctl_addr = atun_info[ :ctl_addr ]
+        ctl_info = @ctl_infos[ ctl_addr ]
 
-        if proxy.closed? then
-          close_tun( tun )
+        unless ctl_info then
+          close_atun( atun )
           return
         end
 
-        proxy_info = @proxy_infos[ proxy ]
-        dst = proxy_info[ :dsts ][ dst_id ]
+        dst = ctl_info[ :dsts ][ dst_id ]
 
         unless dst then
-          close_tun( tun )
+          close_atun( atun )
           return
         end
 
-        # puts "debug1 set tun.dst #{ dst_id }"
-        tun_info[ :dst ] = dst
+        # puts "debug set atun.dst #{ dst_id }"
+        atun_info[ :dst ] = dst
         dst_info = @dst_infos[ dst ]
-        tun_info[ :domain_port ] = dst_info[ :domain_port ]
-
-        unless dst_info[ :rbuff ].empty? then
-          # puts "debug1 move dst.rbuff to tun.wbuff"
-          add_tun_wbuff( tun, dst_info[ :rbuff ] )
-        end
+        atun_info[ :domain_port ] = dst_info[ :domain_port ]
+        dst_info[ :atun ] = atun
 
-        dst_info[ :tun ] = tun
         data = data[ 2..-1 ]
-        return if data.empty?
       end
 
-      # puts "debug2 add dst.wbuff #{ data.bytesize }"
-      add_dst_wbuff( dst, data )
+      until data.empty? do
+        rbuff = atun_info[ :rbuff ]
+        wait_bytes = atun_info[ :wait_bytes ]
+
+        if wait_bytes > 0 then
+          len = wait_bytes
+          # puts "debug wait bytes #{ len }"
+        else
+          if data.bytesize <= 2 then
+            # puts "debug unexpect data length #{ data.bytesize }"
+            close_atun( atun )
+            return
+          end
+
+          len = data[ 0, 2 ].unpack( 'n' ).first
+          # puts "debug read len #{ len }"
+          data = data[ 2..-1 ]
+        end
+
+        chunk = data[ 0, len ]
+        chunk_size = chunk.bytesize
+
+        if chunk_size == len then
+          # 取完整了
+          chunk = @custom.decode( "#{ rbuff }#{ chunk }" )
+          # puts "debug decode and add dst.wbuff #{ chunk.bytesize }"
+          add_dst_wbuff( dst, chunk )
+          atun_info[ :rbuff ].clear
+          atun_info[ :wait_bytes ] = 0
+        else
+          # 暂存
+          # puts "debug add atun.rbuff #{ chunk_size } wait bytes #{ len - chunk_size }"
+          atun_info[ :rbuff ] << chunk
+          atun_info[ :wait_bytes ] = len - chunk_size
+        end
+
+        data = data[ chunk_size..-1 ]
+      end
     end
 
     ##
-    # write proxy
+    # read btun
     #
-    def write_proxy( proxy )
-      proxy_info = @proxy_infos[ proxy ]
+    def read_btun( btun )
+      if btun.closed? then
+        puts "p#{ Process.pid } #{ Time.new } read btun but btun closed?"
+        return
+      end
 
-      # 发ctlmsg
-      while proxy_info[ :ctlmsgs ].any? do
-        data = proxy_info[ :ctlmsgs ].map{ | ctlmsg | "#{ ctlmsg }#{ SEPARATE }" }.join
+      btun_info = @btun_infos[ btun ]
 
-        # 写入
-        begin
-          written = proxy.write( data )
-        rescue IO::WaitWritable, Errno::EINTR
-          print 'w'
-          return
-        rescue Exception => e
-          # puts "debug1 write proxy #{ e.class }"
-          close_proxy( proxy )
-          return
+      begin
+        data = btun.read_nonblock( READ_SIZE )
+      rescue Exception => e
+        # puts "debug read btun #{ btun_info[ :im ] } #{ e.class }"
+        close_btun( btun )
+        return
+      end
+
+      if data.bytesize != 2 then
+        close_btun( btun )
+        return
+      end
+
+      # puts "debug read btun #{ data.inspect }"
+      @traff_ins[ btun_info[ :im ] ] += data.bytesize
+      dst = btun_info[ :dst ]
+
+      if dst then
+        # puts "debug unexpect data"
+        close_btun( btun )
+        return
+      end
+
+      dst_id = data.unpack( 'n' ).first
+      ctl_addr = btun_info[ :ctl_addr ]
+      ctl_info = @ctl_infos[ ctl_addr ]
+
+      unless ctl_info then
+        # puts "debug ctl info not found"
+        close_btun( btun )
+        return
+      end
+
+      dst = ctl_info[ :dsts ][ dst_id ]
+
+      unless dst then
+        # puts "debug dst #{ dst_id } not found"
+        close_btun( btun )
+        return
+      end
+
+      # puts "debug set btun.dst #{ dst_id }"
+      btun_info[ :dst ] = dst
+      dst_info = @dst_infos[ dst ]
+      btun_info[ :domain_port ] = dst_info[ :domain_port ]
+
+      unless dst_info[ :rbuff ].empty? then
+        data2 = ''
+
+        until dst_info[ :rbuff ].empty? do
+          _data = dst_info[ :rbuff ][ 0, 65535 ]
+          data_size = _data.bytesize
+          # puts "debug move dst.rbuff to btun.wbuff"
+          data2 << pack_a_chunk( _data )
+          dst_info[ :rbuff ] = dst_info[ :rbuff ][ data_size..-1 ]
         end
 
-        proxy_info[ :ctlmsgs ].clear
+        add_btun_wbuff( btun, data2 )
       end
 
-      @writes.delete( proxy )
+      dst_info[ :btun ] = btun
     end
 
     ##
@@ -985,7 +1045,7 @@ module Girl
       end
 
       dst_info = @dst_infos[ dst ]
-      tun = dst_info[ :tun ]
+      atun = dst_info[ :atun ]
       data = dst_info[ :wbuff ]
 
       # 写前为空，处理关闭写
@@ -1002,41 +1062,45 @@ module Girl
       # 写入
       begin
         written = dst.write_nonblock( data )
-      rescue IO::WaitWritable, Errno::EINTR
+      rescue IO::WaitWritable
         print 'w'
         return
       rescue Exception => e
-        # puts "debug1 write dst #{ e.class }"
+        # puts "debug write dst #{ e.class }"
         close_write_dst( dst )
-        close_read_tun( tun ) if tun
+
+        if atun then
+          close_atun( atun )
+        end
+
         return
       end
 
-      # puts "debug2 written dst #{ written }"
+      # puts "debug write dst #{ written }"
       data = data[ written..-1 ]
       dst_info[ :wbuff ] = data
       @traff_outs[ dst_info[ :im ] ] += written
     end
 
     ##
-    # write tun
+    # write btun
     #
-    def write_tun( tun )
-      if tun.closed? then
-        puts "p#{ Process.pid } #{ Time.new } write tun but tun closed?"
+    def write_btun( btun )
+      if btun.closed? then
+        puts "p#{ Process.pid } #{ Time.new } write btun but btun closed?"
         return
       end
 
-      tun_info = @tun_infos[ tun ]
-      dst = tun_info[ :dst ]
-      data = tun_info[ :wbuff ]
+      btun_info = @btun_infos[ btun ]
+      dst = btun_info[ :dst ]
+      data = btun_info[ :wbuff ]
 
       # 写前为空，处理关闭写
       if data.empty? then
-        if tun_info[ :closing_write ] then
-          close_write_tun( tun )
+        if btun_info[ :closing ] then
+          close_btun( btun )
         else
-          @writes.delete( tun )
+          @writes.delete( btun )
         end
 
         return
@@ -1044,21 +1108,21 @@ module Girl
 
       # 写入
       begin
-        written = tun.write_nonblock( data )
-      rescue IO::WaitWritable, Errno::EINTR
+        written = btun.write_nonblock( data )
+      rescue IO::WaitWritable
         print 'w'
         return
       rescue Exception => e
-        # puts "debug1 write tun #{ e.class }"
-        close_write_tun( tun )
+        # puts "debug write btun #{ e.class }"
+        close_btun( btun )
         close_read_dst( dst ) if dst
         return
       end
 
-      # puts "debug2 written tun #{ written }"
+      # puts "debug write btun #{ written }"
       data = data[ written..-1 ]
-      tun_info[ :wbuff ] = data
-      @traff_outs[ tun_info[ :im ] ] += written
+      btun_info[ :wbuff ] = data
+      @traff_outs[ btun_info[ :im ] ] += written
 
       if dst && !dst.closed? then
         dst_info = @dst_infos[ dst ]