girl 9.1.3 → 9.1.5

data/lib/girl/proxy_worker.rb

@@ -6,12 +6,11 @@ module Girl
       redir_host,
       redir_port,
       memd_port,
-      relayd_host,
-      relayd_port,
       tspd_host,
       tspd_port,
       proxyd_host,
       proxyd_port,
+      bigd_port,
       nameservers,
       im,
       directs,
@@ -26,18 +25,10 @@ module Girl
       h_p1_close,
       h_p2_close,
       h_p2_traffic,
-      h_p1_overflow,
-      h_p1_underhalf,
-      h_p2_overflow,
-      h_p2_underhalf,
       h_query,
       h_response,
       h_src_close,
       h_traffic,
-      h_src_overflow,
-      h_src_underhalf,
-      h_dst_overflow,
-      h_dst_underhalf,
       expire_connecting,
       expire_long_after,
       expire_proxy_after,
@@ -45,38 +36,36 @@ module Girl
       expire_short_after,
       is_debug,
       is_client_fastopen,
-      is_server_fastopen )
-
+      is_server_fastopen)
       @proxyd_host = proxyd_host
       @proxyd_addr = Socket.sockaddr_in(proxyd_port, proxyd_host)
+      @bigd_addr = Socket.sockaddr_in(bigd_port, proxyd_host)
       @nameserver_addrs = nameservers.map{|n| Socket.sockaddr_in(53, n)}
       @im = im
       @directs = directs
       @remotes = remotes
       @local_ips = Socket.ip_address_list.select{|info| info.ipv4?}.map{|info| info.ip_address}
       @update_roles = [:dns, :dst, :mem, :p1, :src, :rsv] # 参与淘汰的角色
-      @updates_limit = 1007  # 淘汰池上限，1015(mac) - info, infod, memd, proxy, redir, relayd, rsvd, tspd
+      @updates_limit = 1008  # 淘汰池上限，1015(mac) - [info infod memd proxy redir rsvd tspd]
       @eliminate_count = 0   # 淘汰次数
       @reads = []            # 读池
       @writes = []           # 写池
-      @roles = {}            # sock =>  :dns / :dst / :girl / :infod / :mem / :memd / :p1 / :proxy / :redir / :relay / :relayd / :rsv / :rsvd / :src / :tspd
+      @roles = {}            # sock =>  :big / :dns / :dst / :infod / :mem / :memd / :p1 / :proxy / :redir / :rsv / :rsvd / :src / :tspd
       @updates = {}          # sock => updated_at
-      @proxy_infos = {}      # proxy => {:is_syn :paused_p1s :paused_srcs :rbuff :recv_at :wbuff}
+      @proxy_infos = {}      # proxy => {:is_syn :rbuff :recv_at :wbuff}
+      @big_infos = {}        # big => {:is_syn :overflowing :rbuff :recv_at :wbuff}
       @mem_infos = {}        # mem => {:wbuff}
-      @relay_infos = {}      # relay => {:addrinfo :closing :girl :overflowing :wbuff}
-      @girl_infos = {}       # girl => {:closing :connected :is_syn :overflowing :relay :wbuff}
-      @src_infos = {}        # src => {:addrinfo :closing :destination_domain :destination_port :dst :is_connect :overflowing :proxy_proto :proxy_type :rbuff :src_id :wbuff}
+      @src_infos = {}        # src => {:addrinfo :closing :destination_domain :destination_port :dst :in :is_big :is_connect :overflowing :proxy_proto :proxy_type :rbuff :src_id :wbuff}
       @dst_infos = {}        # dst => {:closing :connected :domain :ip :overflowing :port :src :wbuff}
       @dns_infos = {}        # dns => {:domain :src}
       @rsv_infos = {}        # rsv => {:addrinfo :domain :type}
       @near_infos = {}       # near_id => {:addrinfo :created_at :domain :id :type}
-      @resolv_caches = {}    # domain => [ip, created_at]
+      @resolv_caches = {}    # domain => [ip created_at]
       @is_direct_caches = {} # ip => true / false
-      @response_caches = {}  # domain => [response, created_at, ip, is_remote]
-      @response6_caches = {} # domain => [response, created_at, ip, is_remote]
-      @p1_infos = {}         # p1 => {:closing :connected :overflowing :p2_id :wbuff}
+      @response_caches = {}  # domain => [response created_at ip is_remote]
+      @response6_caches = {} # domain => [response created_at ip is_remote]
+      @p1_infos = {}         # p1 => {:closing :connected :in :is_big :overflowing :p2_id :wbuff}
       @appd_addr = Socket.sockaddr_in(appd_port, appd_host)
-
       @head_len = head_len
       @h_a_new_source = h_a_new_source
       @h_a_new_p2 = h_a_new_p2
@@ -85,18 +74,10 @@ module Girl
       @h_p1_close = h_p1_close
       @h_p2_close = h_p2_close
       @h_p2_traffic = h_p2_traffic
-      @h_p1_overflow = h_p1_overflow
-      @h_p1_underhalf = h_p1_underhalf
-      @h_p2_overflow = h_p2_overflow
-      @h_p2_underhalf = h_p2_underhalf
       @h_query = h_query
       @h_response = h_response
       @h_src_close = h_src_close
       @h_traffic = h_traffic
-      @h_src_overflow = h_src_overflow
-      @h_src_underhalf = h_src_underhalf
-      @h_dst_overflow = h_dst_overflow
-      @h_dst_underhalf = h_dst_underhalf
       @expire_connecting = expire_connecting
       @expire_long_after = expire_long_after
       @expire_proxy_after = expire_proxy_after
@@ -105,14 +86,13 @@ module Girl
       @is_debug = is_debug
       @is_client_fastopen = is_client_fastopen
       @is_server_fastopen = is_server_fastopen
-
       new_a_redir(redir_host, redir_port)
       new_a_infod(redir_port)
       new_a_memd(memd_port)
-      new_a_relayd(relayd_host, relayd_port)
       new_a_rsvd(tspd_host, tspd_port)
       new_a_tspd(tspd_host, tspd_port)
       new_a_proxy
+      new_a_big
     end
 
     def looping
@@ -126,12 +106,12 @@ module Girl
           role = @roles[sock]
 
           case role
+          when :big
+            read_big(sock)
           when :dns
             read_dns(sock)
           when :dst
             read_dst(sock)
-          when :girl
-            read_girl(sock)
           when :infod
             read_infod(sock)
           when :mem
@@ -144,10 +124,6 @@ module Girl
             read_proxy(sock)
           when :redir
             read_redir(sock)
-          when :relay
-            read_relay(sock)
-          when :relayd
-            read_relayd(sock)
           when :rsv
             read_rsv(sock)
           when :rsvd
@@ -165,18 +141,16 @@ module Girl
           role = @roles[sock]
 
           case role
+          when :big
+            write_big(sock)
           when :dst
             write_dst(sock)
-          when :girl
-            write_girl(sock)
           when :mem
             write_mem(sock)
           when :p1
             write_p1(sock)
           when :proxy
             write_proxy(sock)
-          when :relay
-            write_relay(sock)
           when :src
             write_src(sock)
           else
@@ -195,46 +169,48 @@ module Girl
 
     private
 
-    def add_dst_wbuff(dst, data)
-      return if dst.nil? || dst.closed? || data.nil? || data.empty?
-      dst_info = @dst_infos[dst]
-      dst_info[:wbuff] << data
-      bytesize = dst_info[:wbuff].bytesize
+    def add_big_wbuff(data)
+      return if @big.closed? || data.nil? || data.empty?
+      big_info = @big_infos[@big]
+      big_info[:wbuff] << data
+      bytesize = big_info[:wbuff].bytesize
 
       if bytesize >= CLOSE_ABOVE
-        puts "close overflow dst #{dst_info[:domain]}"
-        close_dst(dst)
+        puts "close overflow big"
+        close_big(@big)
         return
       end
 
-      if !dst_info[:overflowing] && (bytesize >= WBUFF_LIMIT)
-        puts "dst overflow pause src #{dst_info[:domain]}"
-        @reads.delete(dst_info[:src])
-        dst_info[:overflowing] = true
+      if !big_info[:overflowing] && (bytesize >= WBUFF_LIMIT)
+        puts "big overflow"
+        big_info[:overflowing] = true
       end
 
-      add_write(dst)
+      add_write(@big)
+      big_info[:overflowing]
     end
 
-    def add_girl_wbuff(girl, data)
-      return if girl.nil? || girl.closed? || data.nil? || data.empty?
-      girl_info = @girl_infos[girl]
-      girl_info[:wbuff] << data
-      bytesize = girl_info[:wbuff].bytesize
+    def add_dst_wbuff(dst, data)
+      return if dst.nil? || dst.closed? || data.nil? || data.empty?
+      dst_info = @dst_infos[dst]
+      dst_info[:wbuff] << data
+      bytesize = dst_info[:wbuff].bytesize
+      domain = dst_info[:domain]
 
       if bytesize >= CLOSE_ABOVE
-        puts "close overflow girl"
-        close_girl(girl)
+        puts "close overflow dst #{domain}"
+        close_dst(dst)
         return
       end
 
-      if !girl_info[:overflowing] && (bytesize >= WBUFF_LIMIT)
-        puts "girl overflow pause relay"
-        @reads.delete(girl_info[:relay])
-        girl_info[:overflowing] = true
+      if !dst_info[:overflowing] && (bytesize >= WBUFF_LIMIT)
+        puts "dst overflow #{domain}"
+        dst_info[:overflowing] = true
+        puts "pause src"
+        @reads.delete(dst_info[:src])
       end
 
-      add_write(girl)
+      add_write(dst)
     end
 
     def add_mem_wbuff(mem, data)
@@ -258,10 +234,13 @@ module Girl
       end
 
       if !p1_info[:overflowing] && (bytesize >= WBUFF_LIMIT)
-        puts "add h_p1_overflow #{p2_id}"
-        msg = "#{@h_p1_overflow}#{[p2_id].pack('Q>')}"
-        add_proxy_wbuff(pack_a_chunk(msg))
+        puts "p1 overflow #{p2_id}"
         p1_info[:overflowing] = true
+
+        if @big
+          puts 'pause big'
+          @reads.delete(@big)
+        end
       end
 
       add_write(p1)
@@ -295,27 +274,6 @@ module Girl
       set_update(sock) if @update_roles.include?(role)
     end
 
-    def add_relay_wbuff(relay, data)
-      return if relay.nil? || relay.closed? || data.nil? || data.empty?
-      relay_info = @relay_infos[relay]
-      relay_info[:wbuff] << data
-      bytesize = relay_info[:wbuff].bytesize
-
-      if bytesize >= CLOSE_ABOVE
-        puts "close overflow relay #{relay_info[:addrinfo].ip_unpack.inspect}"
-        close_relay(relay)
-        return
-      end
-
-      if !relay_info[:overflowing] && (bytesize >= WBUFF_LIMIT)
-        puts "relay overflow pause girl #{relay_info[:addrinfo].ip_unpack.inspect}"
-        @reads.delete(relay_info[:girl])
-        relay_info[:overflowing] = true
-      end
-
-      add_write(relay)
-    end
-
     def add_socks5_conn_reply(src)
       # +----+-----+-------+------+----------+----------+
       # |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
@@ -354,16 +312,16 @@ module Girl
       end
 
       if !src_info[:overflowing] && (bytesize >= WBUFF_LIMIT)
+        puts "src overflow #{src_id} #{domain}"
+        src_info[:overflowing] = true
+
         if src_info[:proxy_type] == :direct
-          puts "src overflow pause dst #{src_id} #{domain}"
+          puts "pause dst"
           @reads.delete(src_info[:dst])
         elsif src_info[:proxy_type] == :remote
-          puts "add h_src_overflow #{src_id} #{domain}"
-          msg = "#{@h_src_overflow}#{[src_id].pack('Q>')}"
-          add_proxy_wbuff(pack_a_chunk(msg))
+          puts "pause big"
+          @reads.delete(@big)
         end
-
-        src_info[:overflowing] = true
       end
 
       add_write(src)
@@ -394,15 +352,6 @@ module Girl
       end
     end
 
-    def check_expire_girls
-      now = Time.new
-
-      @girl_infos.select{|girl, info| info[:connected] ? (now.to_i - @updates[girl].to_i >= @expire_long_after) : (now.to_i - @updates[girl].to_i >= @expire_connecting)}.each do |girl, _|
-        puts "expire girl" if @is_debug
-        close_girl(girl)
-      end
-    end
-
     def check_expire_mems
       now = Time.new
 
@@ -430,15 +379,6 @@ module Girl
       end
     end
 
-    def check_expire_relays
-      now = Time.new
-
-      @relay_infos.select{|relay, _| now.to_i - @updates[relay].to_i >= @expire_long_after}.each do |relay, info|
-        puts "expire relay #{info[:addrinfo].ip_unpack.inspect}" if @is_debug
-        close_relay(relay)
-      end
-    end
-
     def check_expire_rsvs
       now = Time.new
 
@@ -457,11 +397,24 @@ module Girl
       end
     end
 
+    def close_big(big)
+      return if big.nil? || big.closed?
+      close_sock(big)
+      big_info = @big_infos.delete(big)
+      puts "close big"
+      big_info
+    end
+
     def close_dns(dns)
       return nil if dns.nil? || dns.closed?
       close_sock(dns)
       dns_info = @dns_infos.delete(dns)
-      puts "close dns #{dns_info[:domain]}" if @is_debug
+
+      if dns_info
+        domain = dns_info[:domain]
+        puts "close dns #{domain}" if @is_debug
+      end
+
       dns_info
     end
 
@@ -469,18 +422,14 @@ module Girl
       return nil if dst.nil? || dst.closed?
       close_sock(dst)
       dst_info = @dst_infos.delete(dst)
-      puts "close dst #{dst_info[:domain]}" if @is_debug
-      set_src_closing(dst_info[:src]) if dst_info
-      dst_info
-    end
 
-    def close_girl(girl)
-      return nil if girl.nil? || girl.closed?
-      close_sock(girl)
-      girl_info = @girl_infos.delete(girl)
-      puts "close girl" if @is_debug
-      set_relay_closing(girl_info[:relay]) if girl_info
-      girl_info
+      if dst_info
+        domain = dst_info[:domain]
+        puts "close dst #{domain}" if @is_debug
+        set_src_closing(dst_info[:src])
+      end
+
+      dst_info
     end
 
     def close_mem(mem)
@@ -494,9 +443,7 @@ module Girl
       close_sock(p1)
       p1_info = @p1_infos.delete(p1)
 
-      unless @proxy.closed?
-        proxy_info = @proxy_infos[@proxy]
-        proxy_info[:paused_p1s].delete(p1)
+      if p1_info
         p2_id = p1_info[:p2_id]
         puts "add h_p1_close #{p2_id}"
         msg = "#{@h_p1_close}#{[p2_id].pack('Q>')}"
@@ -516,20 +463,16 @@ module Girl
       proxy_info
     end
 
-    def close_relay(relay)
-      return nil if relay.nil? || relay.closed?
-      close_sock(relay)
-      relay_info = @relay_infos.delete(relay)
-      puts "close relay" if @is_debug
-      set_girl_closing(relay_info[:girl]) if relay_info
-      relay_info
-    end
-
     def close_rsv(rsv)
       return nil if rsv.nil? || rsv.closed?
       close_sock(rsv)
       rsv_info = @rsv_infos.delete(rsv)
-      puts "close rsv #{rsv_info[:domain]}" if @is_debug
+
+      if rsv_info
+        domain = rsv_info[:domain]
+        puts "close rsv #{domain}" if @is_debug
+      end
+
       rsv_info
     end
 
@@ -546,23 +489,50 @@ module Girl
       return nil if src.nil? || src.closed?
       close_sock(src)
       src_info = @src_infos.delete(src)
-      src_id = src_info[:src_id]
-      domain = src_info[:destination_domain]
-      puts "close src #{domain}" if @is_debug
 
-      if src_info[:proxy_type] == :direct
-        set_dst_closing(src_info[:dst])
-      elsif (src_info[:proxy_type] == :remote) && !@proxy.closed?
-        proxy_info = @proxy_infos[@proxy]
-        proxy_info[:paused_srcs].delete(src)
-        puts "add h_src_close #{src_id}" if @is_debug
-        msg = "#{@h_src_close}#{[src_id].pack('Q>')}"
-        add_proxy_wbuff(pack_a_chunk(msg))
+      if src_info
+        src_id = src_info[:src_id]
+        domain = src_info[:destination_domain]
+        proxy_type = src_info[:proxy_type]
+        puts "close src #{domain}" if @is_debug
+
+        if proxy_type == :direct
+          set_dst_closing(src_info[:dst])
+        elsif proxy_type == :remote
+          puts "add h_src_close #{src_id}" if @is_debug
+          msg = "#{@h_src_close}#{[src_id].pack('Q>')}"
+          add_proxy_wbuff(pack_a_chunk(msg))
+        end
       end
 
       src_info
     end
 
+    def deal_big_msg(data)
+      return if data.nil? || data.empty? || @big.closed?
+      big_info = @big_infos[@big]
+      now = Time.new
+      big_info[:recv_at] = now
+      h = data[0]
+
+      case h
+      when @h_p2_traffic
+        return if data.bytesize < 9
+        p2_id = data[1, 8].unpack('Q>').first
+        data = data[9..-1]
+        # puts "big got h_p2_traffic #{p2_id} #{data.bytesize}" if @is_debug
+        p1, _ = @p1_infos.find{|_, info| info[:p2_id] == p2_id}
+        add_p1_wbuff(p1, data)
+      when @h_traffic
+        return if data.bytesize < 9
+        src_id = data[1, 8].unpack('Q>').first
+        data = data[9..-1]
+        # puts "big got h_traffic #{src_id} #{data.bytesize}" if @is_debug
+        src, _ = @src_infos.find{|_, info| info[:src_id] == src_id}
+        add_src_wbuff(src, data)
+      end
+    end
+
     def deal_msg(data)
       return if data.nil? || data.empty? || @proxy.closed?
       proxy_info = @proxy_infos[@proxy]
@@ -582,8 +552,6 @@ module Girl
         puts "got h_dst_close #{src_id}" if @is_debug
         src, _ = @src_infos.find{|_, info| info[:src_id] == src_id}
         set_src_closing(src)
-      when @h_heartbeat
-        puts "got h_heartbeat" if @is_debug
       when @h_p2_close
         return if data.bytesize < 9
         p2_id = data[1, 8].unpack('Q>').first
@@ -594,22 +562,8 @@ module Girl
         return if data.bytesize < 9
         p2_id = data[1, 8].unpack('Q>').first
         data = data[9..-1]
-        # puts "got h_p2_traffic #{p2_id} #{data.bytesize}" if @is_debug
         p1, _ = @p1_infos.find{|_, info| info[:p2_id] == p2_id}
         add_p1_wbuff(p1, data)
-      when @h_p2_overflow
-        return if data.bytesize < 9
-        p2_id = data[1, 8].unpack('Q>').first
-        puts "got h_p2_overflow pause p1 #{p2_id}"
-        p1, _ = @p1_infos.find{|_, info| info[:p2_id] == p2_id}
-        @reads.delete(p1)
-        proxy_info[:paused_p1s].delete(p1)
-      when @h_p2_underhalf
-        return if data.bytesize < 9
-        p2_id = data[1, 8].unpack('Q>').first
-        puts "got h_p2_underhalf #{p2_id}"
-        p1, _ = @p1_infos.find{|_, info| info[:p2_id] == p2_id}
-        add_read(p1)
       when @h_response
         return if data.bytesize < 3
         near_id = data[1, 8].unpack('Q>').first
@@ -643,22 +597,8 @@ module Girl
         return if data.bytesize < 9
         src_id = data[1, 8].unpack('Q>').first
         data = data[9..-1]
-        # puts "got h_traffic #{src_id} #{data.bytesize}" if @is_debug
         src, _ = @src_infos.find{|_, info| info[:src_id] == src_id}
         add_src_wbuff(src, data)
-      when @h_dst_overflow
-        return if data.bytesize < 9
-        src_id = data[1, 8].unpack('Q>').first
-        puts "got h_dst_overflow pause src #{src_id}"
-        src, _ = @src_infos.find{|_, info| info[:src_id] == src_id}
-        @reads.delete(src)
-        proxy_info[:paused_srcs].delete(src)
-      when @h_dst_underhalf
-        return if data.bytesize < 9
-        src_id = data[1, 8].unpack('Q>').first
-        puts "got h_dst_underhalf #{src_id}"
-        src, _ = @src_infos.find{|_, info| info[:src_id] == src_id}
-        add_read(src)
       end
     end
 
@@ -708,7 +648,7 @@ module Girl
       domain = src_info[:destination_domain]
       port = src_info[:destination_port]
 
-      if @local_ips.include?(ip) && [@redir_port, @relayd_port, @tspd_port].include?(port)
+      if @local_ips.include?(ip) && [@redir_port, @tspd_port].include?(port)
         puts "ignore #{ip}:#{port}"
         close_src(src)
         return
@@ -742,6 +682,39 @@ module Girl
       end
     end
 
+    def new_a_big
+      big = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      big.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+      if @is_client_fastopen
+        big.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_FASTOPEN, 5)
+      else
+        begin
+          big.connect_nonblock(@bigd_addr)
+        rescue IO::WaitWritable
+        rescue Exception => e
+          puts "connect bigd #{e.class}"
+          big.close
+          return
+        end
+      end
+
+      puts "big im #{@im}"
+      chars = []
+      @head_len.times{chars << rand(256)}
+      head = "#{chars.pack('C*')}#{[@im.bytesize].pack('C')}#{@im}"
+      @big = big
+      @big_infos[big] = {
+        is_syn: @is_client_fastopen,
+        overflowing: false,
+        rbuff: '',
+        recv_at: Time.new,
+        wbuff: head
+      }
+      add_read(big, :big)
+      add_write(big)
+    end
+
     def new_a_dst(ip, src)
       return if src.nil? || src.closed?
       src_info = @src_infos[src]
@@ -770,7 +743,7 @@ module Girl
         return
       end
 
-      dst_info = {
+      @dst_infos[dst] = {
         closing: false,
         connected: false,
         domain: domain,
@@ -780,8 +753,6 @@ module Girl
         src: src,
         wbuff: ''
       }
-
-      @dst_infos[dst] = dst_info
       src_info[:proxy_type] = :direct
       src_info[:dst] = dst
 
@@ -805,45 +776,6 @@ module Girl
       end
     end
 
-    def new_a_girl(relay)
-      return if relay.nil? || relay.closed?
-      check_expire_girls
-
-      begin
-        girl = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-      rescue Exception => e
-        puts "new a girl #{e.class}"
-        close_girl(girl)
-        return
-      end
-
-      girl.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-
-      begin
-        girl.connect_nonblock(@proxyd_addr)
-      rescue IO::WaitWritable
-      rescue Exception => e
-        puts "girl connect proxyd #{e.class}"
-        girl.close
-        close_girl(girl)
-        return
-      end
-
-      girl_info = {
-        closing: false,
-        connected: false,
-        is_syn: @is_client_fastopen,
-        overflowing: false,
-        relay: relay,
-        wbuff: ''
-      }
-
-      @girl_infos[girl] = girl_info
-      add_read(girl, :girl)
-      add_write(girl)
-      girl
-    end
-
     def new_a_infod(infod_port)
       infod_host = '127.0.0.1'
       infod_addr = Socket.sockaddr_in(infod_port, infod_host)
@@ -891,15 +823,15 @@ module Girl
         return
       end
 
-      p1_info = {
+      @p1_infos[p1] = {
         closing: false,
         connected: false,
+        in: 0,
+        is_big: false,
         overflowing: false,
         p2_id: p2_id,
         wbuff: ''
       }
-
-      @p1_infos[p1] = p1_info
       add_read(p1, :p1)
       add_write(p1)
     end
@@ -921,25 +853,19 @@ module Girl
         end
       end
 
-      puts "im #{@im}"
+      puts "proxy im #{@im}"
       chars = []
       @head_len.times{chars << rand(256)}
       head = "#{chars.pack('C*')}#{[@im.bytesize].pack('C')}#{@im}"
-
-      proxy_info = {
+      @proxy = proxy
+      @proxy_infos[proxy] = {
         is_syn: @is_client_fastopen,
-        paused_p1s: [],
-        paused_srcs: [],
         rbuff: '',
-        recv_at: nil,
+        recv_at: Time.new,
         wbuff: head
       }
-
-      @proxy = proxy
-      @proxy_infos[proxy] = proxy_info
       add_read(proxy, :proxy)
       add_write(proxy)
-      proxy_info
     end
 
     def new_a_redir(redir_host, redir_port)
@@ -956,19 +882,6 @@ module Girl
       @redir_local_address = redir.local_address
     end
 
-    def new_a_relayd(relayd_host, relayd_port)
-      relayd = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-      relayd.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-      relayd.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
-      relayd.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1) if RUBY_PLATFORM.include?('linux')
-      relayd.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_FASTOPEN, BACKLOG) if @is_server_fastopen
-      relayd.bind(Socket.sockaddr_in(relayd_port, relayd_host))
-      relayd.listen(BACKLOG)
-      puts "relayd listen on #{relayd_host} #{relayd_port}"
-      add_read(relayd, :relayd)
-      @relayd_port = relayd_port
-    end
-
     def new_a_rsv(data, addrinfo, domain, type)
       check_expire_rsvs
       rsv = Socket.new(Socket::AF_INET, Socket::SOCK_DGRAM, 0)
@@ -981,13 +894,11 @@ module Girl
         return
       end
 
-      rsv_info = {
+      @rsv_infos[rsv] = {
         addrinfo: addrinfo,
         domain: domain,
         type: type
       }
-
-      @rsv_infos[rsv] = rsv_info
       add_read(rsv, :rsv)
     end
 
@@ -1023,7 +934,6 @@ module Girl
 
       loop do
         part = data[0, 65526]
-        # puts "add h_p2_traffic #{p2_id} #{part.bytesize}" if @is_debug
         msg = "#{@h_p2_traffic}#{[p2_id].pack('Q>')}#{part}"
         chunks << pack_a_chunk(msg)
         data = data[part.bytesize..-1]
@@ -1038,7 +948,6 @@ module Girl
 
       loop do
         part = data[0, 65526]
-        # puts "add h_traffic #{src_id} #{part.bytesize}" if @is_debug
         msg = "#{@h_traffic}#{[src_id].pack('Q>')}#{part}"
         chunks << pack_a_chunk(msg)
         data = data[part.bytesize..-1]
@@ -1048,6 +957,25 @@ module Girl
       chunks
     end
 
+    def read_big(big)
+      begin
+        data = big.read_nonblock(READ_SIZE)
+      rescue Errno::ENOTCONN => e
+        return
+      rescue Exception => e
+        puts "read big #{e.class}" if @is_debug
+        close_big(big)
+        return
+      end
+
+      set_update(big)
+      big_info = @big_infos[big]
+      data = "#{big_info[:rbuff]}#{data}"
+      msgs, part = decode_to_msgs(data)
+      msgs.each{|msg| deal_big_msg(msg)}
+      big_info[:rbuff] = part
+    end
+
     def read_dns(dns)
       begin
         data, addrinfo, rflags, *controls = dns.recvmsg
@@ -1089,33 +1017,17 @@ module Girl
       rescue Errno::ENOTCONN => e
         return
       rescue Exception => e
+        puts "read dst #{e.class}" if @is_debug
         close_dst(dst)
         return
       end
 
       set_update(dst)
       dst_info = @dst_infos[dst]
-      # puts "read dst #{dst_info[:domain]} #{data.bytesize}" if @is_debug
       src = dst_info[:src]
       add_src_wbuff(src, data)
     end
 
-    def read_girl(girl)
-      begin
-        data = girl.read_nonblock(READ_SIZE)
-      rescue Errno::ENOTCONN => e
-        return
-      rescue Exception => e
-        close_girl(girl)
-        return
-      end
-
-      set_update(girl)
-      girl_info = @girl_infos[girl]
-      relay = girl_info[:relay]
-      add_relay_wbuff(relay, data)
-    end
-
     def read_infod(infod)
       begin
         data, addrinfo, rflags, *controls = infod.recvmsg
@@ -1137,18 +1049,26 @@ module Girl
 
       case message_type
       when 'heartbeat'
-        if @proxy.closed?
+        new_a_proxy if @proxy.closed?
+        new_a_big if @big.closed?
+        proxy_info = @proxy_infos[@proxy]
+        
+        if Time.new.to_i - proxy_info[:recv_at].to_i >= @expire_proxy_after
+          puts "renew proxy"
+          close_proxy(@proxy)
           new_a_proxy
         else
-          proxy_info = @proxy_infos[@proxy]
+          add_proxy_wbuff(pack_a_chunk(@h_heartbeat))
+        end
 
-          if Time.new.to_i - proxy_info[:recv_at].to_i >= @expire_proxy_after
-            close_proxy(@proxy)
-            new_a_proxy
-          else
-            puts "heartbeat" if @is_debug
-            add_proxy_wbuff(pack_a_chunk(@h_heartbeat))
-          end
+        big_info = @big_infos[@big]
+
+        if Time.new.to_i - big_info[:recv_at].to_i >= @expire_proxy_after
+          puts "renew big"
+          close_big(@big)
+          new_a_big
+        else
+          add_big_wbuff(pack_a_chunk(@h_heartbeat))
         end
       end
     end
@@ -1186,9 +1106,8 @@ module Girl
           roles: @roles.size,
           updates: @updates.size,
           proxy_infos: @proxy_infos.size,
+          big_infos: @big_infos.size,
           mem_infos: @mem_infos.size,
-          relay_infos: @relay_infos.size,
-          girl_infos: @girl_infos.size,
           src_infos: @src_infos.size,
           dst_infos: @dst_infos.size,
           dns_infos: @dns_infos.size,
@@ -1232,31 +1151,42 @@ module Girl
       rescue Errno::ENOTCONN => e
         return
       rescue Exception => e
+        puts "read p1 #{e.class}" if @is_debug
         close_p1(p1)
         return
       end
 
       set_update(p1)
+      p1_info = @p1_infos[p1]
+      p1_info[:in] += data.bytesize
+      p2_id = p1_info[:p2_id]
 
-      if @proxy.closed?
-        close_p1(p1)
-        return
+      if !p1_info[:is_big] && (p1_info[:in] >= READ_SIZE)
+        puts "set p1 is big #{p2_id}"
+        p1_info[:is_big] = true
       end
 
-      p1_info = @p1_infos[p1]
-      p2_id = p1_info[:p2_id]
-      # puts "read p1 #{p2_id} #{data.bytesize}" if @is_debug
-      add_proxy_wbuff(pack_p2_traffic(p2_id, data))
+      data = pack_p2_traffic(p2_id, data)
+      
+      if p1_info[:is_big]
+        if @big.closed?
+          close_p1(p1)
+          return
+        end
 
-      unless @proxy.closed?
-        proxy_info = @proxy_infos[@proxy]
-        bytesize = proxy_info[:wbuff].bytesize
+        overflowing = add_big_wbuff(data)
 
-        if (bytesize >= WBUFF_LIMIT) && !proxy_info[:paused_p1s].include?(p1)
-          puts "proxy overflow pause p1 #{p2_id}"
+        if overflowing
+          puts "big overflowing pause p1 #{p2_id}"
           @reads.delete(p1)
-          proxy_info[:paused_p1s] << p1
         end
+      else
+        if @proxy.closed?
+          close_p1(p1)
+          return
+        end
+
+        add_proxy_wbuff(data)
       end
     end
 
@@ -1266,6 +1196,7 @@ module Girl
       rescue Errno::ENOTCONN => e
         return
       rescue Exception => e
+        puts "read proxy #{e.class}" if @is_debug
         close_proxy(proxy)
         return
       end
@@ -1273,7 +1204,6 @@ module Girl
       set_update(proxy)
       proxy_info = @proxy_infos[proxy]
       data = "#{proxy_info[:rbuff]}#{data}"
-
       msgs, part = decode_to_msgs(data)
       msgs.each{|msg| deal_msg(msg)}
       proxy_info[:rbuff] = part
@@ -1291,13 +1221,14 @@ module Girl
 
       puts "redir accept a src #{addrinfo.ip_unpack.inspect}" if @is_debug
       src_id = rand((2 ** 64) - 2) + 1
-
-      src_info = {
+      @src_infos[src] = {
         addrinfo: addrinfo,
         closing: false,
         destination_domain: nil,
         destination_port: nil,
         dst: nil,
+        in: 0,
+        is_big: false,
         is_connect: true,
         overflowing: false,
         proxy_proto: :uncheck, # :uncheck / :http / :socks5
@@ -1306,52 +1237,9 @@ module Girl
         src_id: src_id,
         wbuff: ''
       }
-
-      @src_infos[src] = src_info
       add_read(src, :src)
     end
 
-    def read_relay(relay)
-      begin
-        data = relay.read_nonblock(READ_SIZE)
-      rescue Errno::ENOTCONN => e
-        return
-      rescue Exception => e
-        close_relay(relay)
-        return
-      end
-
-      set_update(relay)
-      relay_info = @relay_infos[relay]
-      girl = relay_info[:girl]
-      add_girl_wbuff(girl, data)
-    end
-
-    def read_relayd(relayd)
-      check_expire_relays
-
-      begin
-        relay, addrinfo = relayd.accept_nonblock
-      rescue IO::WaitReadable, Errno::EINTR => e
-        puts "relayd accept #{e.class}"
-        return
-      end
-
-      puts "relayd accept a relay #{addrinfo.ip_unpack.inspect}"
-
-      relay_info = {
-        addrinfo: addrinfo,
-        closing: false,
-        girl: nil,
-        overflowing: false,
-        wbuff: ''
-      }
-
-      @relay_infos[relay] = relay_info
-      add_read(relay, :relay)
-      relay_info[:girl] = new_a_girl(relay)
-    end
-
     def read_rsv(rsv)
       begin
         data, addrinfo, rflags, *controls = rsv.recvmsg
@@ -1439,16 +1327,13 @@ module Girl
       if @remotes.any?{|r| domain.include?(r)}
         check_expire_nears
         near_id = rand((2 ** 64) - 2) + 1
-
-        near_info = {
+        @near_infos[near_id] = {
           addrinfo: addrinfo,
           created_at: Time.new,
           domain: domain,
           id: id,
           type: type
         }
-
-        @near_infos[near_id] = near_info
         puts "add h_query #{near_id} #{type} #{domain}" if @is_debug
         msg = "#{@h_query}#{[near_id, type].pack('Q>C')}#{domain}"
         add_proxy_wbuff(pack_a_chunk(msg))
@@ -1464,6 +1349,7 @@ module Girl
       rescue Errno::ENOTCONN => e
         return
       rescue Exception => e
+        puts "read src #{e.class}" if @is_debug
         close_src(src)
         return
       end
@@ -1607,18 +1493,36 @@ module Girl
           close_src(src)
         end
       when :remote
+        src_info[:in] += data.bytesize
         src_id = src_info[:src_id]
-        add_proxy_wbuff(pack_traffic(src_id, data))
+        domain = src_info[:destination_domain]
 
-        unless @proxy.closed?
-          proxy_info = @proxy_infos[@proxy]
-          bytesize = proxy_info[:wbuff].bytesize
+        if !src_info[:is_big] && (src_info[:in] >= READ_SIZE)
+          puts "set src is big #{src_id} #{domain}"
+          src_info[:is_big] = true
+        end
+
+        data = pack_traffic(src_id, data)
 
-          if (bytesize >= WBUFF_LIMIT) && !proxy_info[:paused_srcs].include?(src)
-            puts "proxy overflow pause src #{src_id} #{src_info[:destination_domain]}"
+        if src_info[:is_big]
+          if @big.closed?
+            close_src(src)
+            return
+          end
+
+          overflowing = add_big_wbuff(data)
+
+          if overflowing
+            puts "big overflowing pause src #{src_id} #{domain}"
             @reads.delete(src)
-            proxy_info[:paused_srcs] << src
           end
+        else
+          if @proxy.closed?
+            close_src(src)
+            return
+          end
+
+          add_proxy_wbuff(data)
         end
       when :direct
         dst = src_info[:dst]
@@ -1657,8 +1561,7 @@ module Girl
       dest_addrinfo = Addrinfo.new(dest_addr)
       dest_ip = dest_addrinfo.ip_address
       src_id = rand((2 ** 64) - 2) + 1
-
-      src_info = {
+      @src_infos[src] = {
         addrinfo: addrinfo,
         closing: false,
         destination_domain: dest_ip,
@@ -1672,8 +1575,6 @@ module Girl
         src_id: src_id,
         wbuff: ''
       }
-
-      @src_infos[src] = src_info
       add_read(src, :src)
       make_tunnel(dest_ip, src)
     end
@@ -1688,7 +1589,7 @@ module Girl
         return
       end
 
-      domain = "127.0.0.1" if domain == 'localhost'
+      domain =' 127.0.0.1' if domain == 'localhost'
 
       if domain =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}.\d{1,3}$/
         # ipv4
@@ -1734,12 +1635,10 @@ module Girl
         return
       end
 
-      dns_info = {
+      @dns_infos[dns] = {
         domain: domain,
         src: src
       }
-
-      @dns_infos[dns] = dns_info
       add_read(dns, :dns)
       src_info = @src_infos[src]
       src_info[:proxy_type] = :checking
@@ -1761,14 +1660,6 @@ module Girl
       add_write(dst)
     end
 
-    def set_girl_closing(girl)
-      return if girl.nil? || girl.closed?
-      girl_info = @girl_infos[girl]
-      return if girl_info.nil? || girl_info[:closing]
-      girl_info[:closing] = true
-      add_write(girl)
-    end
-
     def set_p1_closing(p1)
       return if p1.nil? || p1.closed?
       p1_info = @p1_infos[p1]
@@ -1777,14 +1668,6 @@ module Girl
       add_write(p1)
     end
 
-    def set_relay_closing(relay)
-      return if relay.nil? || relay.closed?
-      relay_info = @relay_infos[relay]
-      return if relay_info.nil? || relay_info[:closing]
-      relay_info[:closing] = true
-      add_write(relay)
-    end
-
     def set_remote(src)
       return if src.nil? || src.closed?
 
@@ -1842,14 +1725,10 @@ module Girl
             close_dns(_sock)
           when :dst
             close_dst(_sock)
-          when :girl
-            close_girl(_sock)
           when :mem
             close_mem(_sock)
           when :p1
             close_p1(_sock)
-          when :relay
-            close_relay(_sock)
           when :rsv
             close_rsv(_sock)
           when :src
@@ -1863,100 +1742,113 @@ module Girl
       end
     end
 
-    def write_dst(dst)
-      if dst.closed?
-        puts "write closed dst?"
+     def write_big(big)
+      big_info = @big_infos[big]
+
+      unless big_info
+        puts "big info not found delete big"
+        @writes.delete(big)
         return
       end
 
-      dst_info = @dst_infos[dst]
-      dst_info[:connected] = true
-      data = dst_info[:wbuff]
+      return if @writes.include?(@proxy)
+      
+      data = big_info[:wbuff]
 
       if data.empty?
-        if dst_info[:closing]
-          close_dst(dst)
-        else
-          @writes.delete(dst)
-        end
-
+        @writes.delete(big)
         return
       end
 
       begin
-        written = dst.write_nonblock(data)
+        if big_info[:is_syn]
+          written = big.sendmsg_nonblock(data, 536870912, @bigd_addr)
+          big_info[:is_syn] = false
+        else
+          written = big.write_nonblock(data)
+        end
       rescue Errno::EINPROGRESS
         return
       rescue Exception => e
-        close_dst(dst)
+        puts "write big #{e.class}" if @is_debug
+        close_big(big)
         return
       end
 
-      set_update(dst)
+      set_update(big)
       data = data[written..-1]
-      dst_info[:wbuff] = data
-      bytesize = dst_info[:wbuff].bytesize
+      big_info[:wbuff] = data
 
-      if dst_info[:overflowing] && (bytesize < RESUME_BELOW)
-        puts "dst underhalf #{dst_info[:domain]}"
-        add_read(dst_info[:src])
-        dst_info[:overflowing] = false
+      if big_info[:wbuff].empty? && big_info[:overflowing]
+        puts "big empty"
+        big_info[:overflowing] = false
+
+        @src_infos.select{|_, info| info[:is_big]}.each do |src, info|
+          puts "resume src #{info[:src_id]} #{info[:destination_domain]}"
+          add_read(src)
+        end
+
+        @p1_infos.select{|_, info| info[:is_big]}.each do |p1, info|
+          puts "resume p1 #{info[:p2_id]}"
+          add_read(p1)
+        end
       end
     end
 
-    def write_girl(girl)
-      if girl.closed?
-        puts "write closed girl?"
+    def write_dst(dst)
+      dst_info = @dst_infos[dst]
+
+      unless dst_info
+        puts "dst info not found delete dst"
+        @writes.delete(dst)
         return
       end
 
-      girl_info = @girl_infos[girl]
-      girl_info[:connected] = true
-      data = girl_info[:wbuff]
+      dst_info[:connected] = true
+      data = dst_info[:wbuff]
 
       if data.empty?
-        if girl_info[:closing]
-          close_girl(girl)
+        if dst_info[:closing]
+          close_dst(dst)
         else
-          @writes.delete(girl)
+          @writes.delete(dst)
         end
 
         return
       end
 
       begin
-        if girl_info[:is_syn]
-          written = girl.sendmsg_nonblock(data, 536870912, @proxyd_addr)
-          girl_info[:is_syn] = false
-        else
-          written = girl.write_nonblock(data)
-        end
+        written = dst.write_nonblock(data)
       rescue Errno::EINPROGRESS
         return
       rescue Exception => e
-        close_girl(girl)
+        puts "write dst #{e.class}" if @is_debug
+        close_dst(dst)
         return
       end
 
-      set_update(girl)
+      set_update(dst)
       data = data[written..-1]
-      girl_info[:wbuff] = data
-      bytesize = girl_info[:wbuff].bytesize
+      dst_info[:wbuff] = data
+      domain = dst_info[:domain]
 
-      if girl_info[:overflowing] && (bytesize < RESUME_BELOW)
-        puts "girl underhalf"
-        add_read(girl_info[:relay])
-        girl_info[:overflowing] = false
+      if dst_info[:overflowing] && dst_info[:wbuff].empty?
+        puts "dst empty #{domain}"
+        dst_info[:overflowing] = false
+        puts "resume src"
+        add_read(dst_info[:src])
       end
     end
 
     def write_mem(mem)
-      if mem.closed?
-        puts "write closed mem?"
+      mem_info = @mem_infos[mem]
+
+      unless mem_info
+        puts "mem info not found delete mem"
+        @writes.delete(mem)
         return
       end
 
-      mem_info = @mem_infos[mem]
       data = mem_info[:wbuff]
 
       if data.empty?
@@ -1980,12 +1872,14 @@ module Girl
     end
 
     def write_p1(p1)
-      if p1.closed?
-        puts "write closed p1?"
+      p1_info = @p1_infos[p1]
+
+      unless p1_info
+        puts "p1 info not found delete p1"
+        @writes.delete(p1)
         return
       end
 
-      p1_info = @p1_infos[p1]
       p1_info[:connected] = true
       data = p1_info[:wbuff]
 
@@ -2004,6 +1898,7 @@ module Girl
       rescue Errno::EINPROGRESS
         return
       rescue Exception => e
+        puts "write p1 #{e.class}" if @is_debug
         close_p1(p1)
         return
       end
@@ -2011,24 +1906,25 @@ module Girl
       set_update(p1)
       data = data[written..-1]
       p1_info[:wbuff] = data
-      bytesize = p1_info[:wbuff].bytesize
+      p2_id = p1_info[:p2_id]
 
-      if p1_info[:overflowing] && (bytesize < RESUME_BELOW)
-        p2_id = p1_info[:p2_id]
-        puts "add h_p1_underhalf #{p2_id}"
-        msg = "#{@h_p1_underhalf}#{[p2_id].pack('Q>')}"
-        add_proxy_wbuff(pack_a_chunk(msg))
+      if p1_info[:overflowing] && p1_info[:wbuff].empty?
+        puts "p1 empty #{p2_id}"
         p1_info[:overflowing] = false
+        puts "resume big"
+        add_read(@big)
       end
     end
 
     def write_proxy(proxy)
-      if proxy.closed?
-        puts "write closed proxy?"
+      proxy_info = @proxy_infos[proxy]
+
+      unless proxy_info
+        puts "proxy info not found delete proxy"
+        @writes.delete(proxy)
         return
       end
 
-      proxy_info = @proxy_infos[proxy]
       data = proxy_info[:wbuff]
 
       if data.empty?
@@ -2054,30 +1950,17 @@ module Girl
       set_update(proxy)
       data = data[written..-1]
       proxy_info[:wbuff] = data
-      bytesize = proxy_info[:wbuff].bytesize
-
-      if bytesize < RESUME_BELOW
-        if proxy_info[:paused_srcs].any?
-          puts "proxy underhalf resume srcs #{proxy_info[:paused_srcs].size}"
-          proxy_info[:paused_srcs].each{|src| add_read(src)}
-          proxy_info[:paused_srcs].clear
-        end
-
-        if proxy_info[:paused_p1s].any?
-          puts "proxy underhalf resume p1s #{proxy_info[:paused_p1s].size}"
-          proxy_info[:paused_p1s].each{|p1| add_read(p1)}
-          proxy_info[:paused_p1s].clear
-        end
-      end
     end
 
     def write_src(src)
-      if src.closed?
-        puts "write closed src?"
+      src_info = @src_infos[src]
+
+      unless src_info
+        puts "src info not found delete src"
+        @writes.delete(src)
         return
       end
 
-      src_info = @src_infos[src]
       data = src_info[:wbuff]
 
       if data.empty?
@@ -2095,6 +1978,7 @@ module Girl
       rescue Errno::EINPROGRESS
         return
       rescue Exception => e
+        puts "write src #{e.class}" if @is_debug
         close_src(src)
         return
       end
@@ -2102,62 +1986,20 @@ module Girl
       set_update(src)
       data = data[written..-1]
       src_info[:wbuff] = data
-      bytesize = src_info[:wbuff].bytesize
 
-      if src_info[:overflowing] && (bytesize < RESUME_BELOW)
+      if src_info[:wbuff].empty? && src_info[:overflowing]
         src_id = src_info[:src_id]
         domain = src_info[:destination_domain]
+        puts "src empty #{src_id} #{domain}"
+        src_info[:overflowing] = false
 
         if src_info[:proxy_type] == :direct
-          puts "src underhalf #{src_id} #{domain}"
+          puts "resume dst"
           add_read(src_info[:dst])
         else
-          puts "add h_src_underhalf #{src_id} #{domain}"
-          msg = "#{@h_src_underhalf}#{[src_id].pack('Q>')}"
-          add_proxy_wbuff(pack_a_chunk(msg))
-        end
-
-        src_info[:overflowing] = false
-      end
-    end
-
-    def write_relay(relay)
-      if relay.closed?
-        puts "write closed relay?"
-        return
-      end
-
-      relay_info = @relay_infos[relay]
-      data = relay_info[:wbuff]
-
-      if data.empty?
-        if relay_info[:closing]
-          close_relay(relay)
-        else
-          @writes.delete(relay)
+          puts "resume big"
+          add_read(@big)
         end
-
-        return
-      end
-
-      begin
-        written = relay.write_nonblock(data)
-      rescue Errno::EINPROGRESS
-        return
-      rescue Exception => e
-        close_relay(relay)
-        return
-      end
-
-      set_update(relay)
-      data = data[written..-1]
-      relay_info[:wbuff] = data
-      bytesize = relay_info[:wbuff].bytesize
-
-      if relay_info[:overflowing] && (bytesize < RESUME_BELOW)
-        puts "relay underhalf"
-        add_read(relay_info[:girl])
-        relay_info[:overflowing] = false
       end
     end