girl 0.81.0 → 0.86.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c03f23d6ce85424ec557285d47ce226a1ee91372c24c517d0b15b7391dc13cf6
-  data.tar.gz: 7219e443eee2a40403d1280ab42154045247080601b71736ddd3af751bb62357
+  metadata.gz: 48f438a56f35bb4fd0fbb76e57f08b5ea1a6e8890b8a2b7542881b1f69e89461
+  data.tar.gz: 8ad2943b900e91f8a6e29306fe29249d467374f738261daadaaa429961370206
 SHA512:
-  metadata.gz: ea3a13ec0c20daec401b2128255c11a5d6c8908e34abc9ebe24f21f410cdffe59ba406f49fba48ca8b3d2b21d69d45d2c7c6a1a098239c708b499948aa768b5a
-  data.tar.gz: cc448ee54e1f2c98da438f95edb6cacd5d498785633f9c9711a762c7ef48b8faca1a03dd4d5304f34eb1b75a990525e352d81dcc1d7478ce7c052b2116c29c65
+  metadata.gz: 98512a3678ebde91bff827995447765c57c558f885313d05ecd8c831e85354a9ea81beb5ff038c18787b1bd0c15fe88317b85a3b6e84458a5709bcf59b027fff
+  data.tar.gz: 263aff6f7b79025d5404f6b6e4a68b01dfa899df0af4556b0085f72e9bb3227d6423be77e3c1cd12445fb1c9727c426be9750a9f7cea72d112b72c59702917a7

data/girl.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['qqtakafan@gmail.com']
 
   spec.summary       = %q{妹子}
-  spec.description   = %q{while internet is evil, here's a girl.}
+  spec.description   = %q{escape evil.}
   spec.homepage      = 'https://github.com/takafan/girl'
   spec.license       = 'MIT'
 

data/lib/girl/head.rb

@@ -7,9 +7,10 @@ module Girl
   EXPIRE_NEW            = 10               # 创建之后多久没有流量进来，过期
   EXPIRE_AFTER          = 300              # 多久没有新流量，过期
   CHECK_EXPIRE_INTERVAL = 30               # 检查过期间隔
-  STATUS_INTERVAL       = 0.5              # 发送状态间隔
+  CHECK_STATUS_INTERVAL = 0.5              # 发送状态间隔
   SEND_STATUS_UNTIL     = 10               # 持续的告之对面状态，直到没有流量往来，持续多少秒
-  BREAK_SEND_MISS       = 10_000           # miss包个数上限，达到上限忽略要后面的段，可控碎片缓存
+  MISS_RANGE_LIMIT      = 500              # miss段上限，达到上限忽略要后面的段
+  RESENDING_LIMIT       = 5000             # 重传队列上限
   CONFUSE_UNTIL         = 5                # 混淆前几个包
   RESOLV_CACHE_EXPIRE   = 300              # dns查询结果缓存多久过期
   TUND_PORT             = 1

data/lib/girl/proxy.rb

@@ -108,7 +108,7 @@ module Girl
           raise "not found direct file #{ direct_path }"
         end
 
-        directs = ( [ Addrinfo.ip( proxyd_host ).ip_address ] + RESERVED_ROUTE.split( "\n" ) + IO.binread( direct_path ).split( "\n" ) ).map { | line | IPAddr.new( line.strip ) }
+        directs = ( RESERVED_ROUTE.split( "\n" ) + IO.binread( direct_path ).split( "\n" ) ).map { | line | IPAddr.new( line.strip ) }
       end
 
       remotes = []
@@ -170,6 +170,29 @@ module Girl
       puts "im #{ im }"
       puts "worker count #{ worker_count }"
 
+      names = %w[
+        PACK_SIZE
+        CHUNK_SIZE
+        WBUFFS_LIMIT
+        WMEMS_LIMIT
+        RESUME_BELOW
+        EXPIRE_NEW
+        EXPIRE_AFTER
+        CHECK_EXPIRE_INTERVAL
+        CHECK_STATUS_INTERVAL
+        SEND_STATUS_UNTIL
+        MISS_RANGE_LIMIT
+        RESENDING_LIMIT
+        CONFUSE_UNTIL
+        RESOLV_CACHE_EXPIRE
+      ]
+
+      len = names.map{ | name | name.size }.max
+
+      names.each do | name |
+        puts "#{ name.gsub( '_', ' ' ).ljust( len ) } #{ Girl.const_get( name ) }"
+      end
+
       if RUBY_PLATFORM.include?( 'linux' )
         $0 = title
         workers = []

data/lib/girl/proxy_worker.rb

@@ -152,7 +152,7 @@ module Girl
     def loop_check_status
       Thread.new do
         loop do
-          sleep STATUS_INTERVAL
+          sleep CHECK_STATUS_INTERVAL
 
           @mutex.synchronize do
             if @tun && !@tun.closed? && @tun_info[ :tund_addr ]
@@ -264,8 +264,10 @@ module Girl
     # deal with destination ip
     #
     def deal_with_destination_ip( src, ip_info )
-      if @directs.any? { | direct | direct.include?( ip_info.ip_address ) }
-        # ip命中直连列表，直连
+      src_info = @src_infos[ src ]
+
+      if ( @directs.any? { | direct | direct.include?( ip_info.ip_address ) } ) || ( ( src_info[ :destination_domain ] == @proxyd_host ) && ![ 80, 443 ].include?( src_info[ :destination_port ] ) )
+        # ip命中直连列表，或者访问远端非80/443端口，直连
         # puts "debug1 #{ ip_info.inspect } hit directs"
         new_a_dst( src, ip_info )
       else
@@ -1224,7 +1226,7 @@ module Girl
 
           tund_port = data[ 9, 2 ].unpack( 'n' ).first
 
-          # puts "debug1 got tund port #{ tund_port }"
+          puts "p#{ Process.pid } #{ Time.new } got tund port #{ tund_port }"
           tund_addr = Socket.sockaddr_in( tund_port, @proxyd_host )
           @tun_info[ :tund_addr ] = tund_addr
 
@@ -1289,36 +1291,36 @@ module Girl
           # 发miss
           if !src_ext[ :src ].closed? && ( src_ext[ :continue_dst_pack_id ] < relay_dst_pack_id )
             ranges = []
+            ignored = false
             curr_pack_id = src_ext[ :continue_dst_pack_id ] + 1
 
             src_ext[ :pieces ].keys.sort.each do | pack_id |
               if pack_id > curr_pack_id
                 ranges << [ curr_pack_id, pack_id - 1 ]
+
+                if ranges.size >= MISS_RANGE_LIMIT
+                  puts "p#{ Process.pid } #{ Time.new } break add miss range at #{ pack_id }"
+                  ignored = true
+                  break
+                end
               end
 
               curr_pack_id = pack_id + 1
             end
 
-            if curr_pack_id <= relay_dst_pack_id
+            if !ignored && ( curr_pack_id <= relay_dst_pack_id )
               ranges << [ curr_pack_id, relay_dst_pack_id ]
             end
 
-            pack_count = 0
             # puts "debug1 continue/relay #{ src_ext[ :continue_dst_pack_id ] }/#{ relay_dst_pack_id } send MISS #{ ranges.size }"
 
             ranges.each do | pack_id_begin, pack_id_end |
-              if pack_count >= BREAK_SEND_MISS
-                puts "p#{ Process.pid } #{ Time.new } break send miss at #{ pack_id_begin }"
-                break
-              end
-
               data2 = [ 0, MISS, dst_port, pack_id_begin, pack_id_end ].pack( 'Q>CnQ>Q>' )
               add_tun_ctlmsg( data2 )
-              pack_count += ( pack_id_end - pack_id_begin + 1 )
             end
           end
         when MISS
-          return if from_addr != @tun_info[ :tund_addr ]
+          return if ( from_addr != @tun_info[ :tund_addr ] ) || ( @tun_info[ :resendings ].size >= RESENDING_LIMIT )
 
           src_id, pack_id_begin, pack_id_end = data[ 9, 24 ].unpack( 'Q>Q>Q>' )
 
@@ -1329,7 +1331,7 @@ module Girl
             send_at = src_ext[ :send_ats ][ pack_id ]
 
             if send_at
-              break if now - send_at < STATUS_INTERVAL
+              break if now - send_at < CHECK_STATUS_INTERVAL
               @tun_info[ :resendings ] << [ src_id, pack_id ]
             end
           end

data/lib/girl/proxyd_worker.rb

@@ -144,7 +144,7 @@ module Girl
     def loop_check_status
       Thread.new do
         loop do
-          sleep STATUS_INTERVAL
+          sleep CHECK_STATUS_INTERVAL
 
           if @tunds.any?
             @mutex.synchronize do
@@ -418,15 +418,17 @@ module Girl
     ##
     # send data
     #
-    def send_data( tund, data, to_addr )
+    def send_data( sock, data, to_addr )
       begin
-        tund.sendmsg( data, 0, to_addr )
+        sock.sendmsg( data, 0, to_addr )
       rescue IO::WaitWritable, Errno::EINTR
         return false
       rescue Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ENETDOWN => e
-        puts "#{ Time.new } #{ e.class }, close tund"
-        close_tund( tund )
-        return false
+        if @roles[ sock ] == :tund
+          puts "#{ Time.new } #{ e.class }, close tund"
+          close_tund( sock )
+          return false
+        end
       end
 
       true
@@ -541,9 +543,7 @@ module Girl
       while @proxyd_ctlmsgs.any?
         to_addr, data = @proxyd_ctlmsgs.first
 
-        begin
-          proxyd.sendmsg( data, 0, to_addr )
-        rescue IO::WaitWritable, Errno::EINTR
+        unless send_data( proxyd, data, to_addr )
           return
         end
 
@@ -866,35 +866,37 @@ module Girl
           # 发miss
           if !dst_ext[ :dst ].closed? && ( dst_ext[ :continue_src_pack_id ] < relay_src_pack_id )
             ranges = []
+            ignored = false
             curr_pack_id = dst_ext[ :continue_src_pack_id ] + 1
 
             dst_ext[ :pieces ].keys.sort.each do | pack_id |
               if pack_id > curr_pack_id
                 ranges << [ curr_pack_id, pack_id - 1 ]
+
+                if ranges.size >= MISS_RANGE_LIMIT
+                  puts "p#{ Process.pid } #{ Time.new } break add miss range at #{ pack_id }"
+                  ignored = true
+                  break
+                end
               end
 
               curr_pack_id = pack_id + 1
             end
 
-            if curr_pack_id <= relay_src_pack_id
+            if !ignored && ( curr_pack_id <= relay_src_pack_id )
               ranges << [ curr_pack_id, relay_src_pack_id ]
             end
 
-            pack_count = 0
             # puts "debug1 continue/relay #{ dst_ext[ :continue_src_pack_id ] }/#{ relay_src_pack_id } send MISS #{ ranges.size }"
 
             ranges.each do | pack_id_begin, pack_id_end |
-              if pack_count >= BREAK_SEND_MISS
-                puts "p#{ Process.pid } #{ Time.new } break send miss at #{ pack_id_begin }"
-                break
-              end
-
               data2 = [ 0, MISS, src_id, pack_id_begin, pack_id_end ].pack( 'Q>CQ>Q>Q>' )
               add_tund_ctlmsg( tund, data2 )
-              pack_count += ( pack_id_end - pack_id_begin + 1 )
             end
           end
         when MISS
+          return if tund_info[ :resendings ].size >= RESENDING_LIMIT
+
           dst_local_port, pack_id_begin, pack_id_end = data[ 9, 18 ].unpack( 'nQ>Q>' )
 
           dst_ext = tund_info[ :dst_exts ][ dst_local_port ]
@@ -904,7 +906,7 @@ module Girl
             send_at = dst_ext[ :send_ats ][ pack_id ]
 
             if send_at
-              break if now - send_at < STATUS_INTERVAL
+              break if now - send_at < CHECK_STATUS_INTERVAL
               tund_info[ :resendings ] << [ dst_local_port, pack_id ]
             end
           end

data/lib/girl/udp.rb

@@ -17,25 +17,12 @@ module Girl
   class Udp
 
     def initialize( udpd_host, udpd_port = 3030, redir_port = 1313 )
-      ctlr, ctlw = IO.pipe
-
-      redir = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
-      redir.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-      redir.bind( Socket.sockaddr_in( redir_port, '0.0.0.0' ) )
-      puts "redir bound on #{ redir_port } #{ Time.new }"
-
-      @mutex = Mutex.new
       @udpd_host = udpd_host
       @udpd_addr = Socket.sockaddr_in( udpd_port, udpd_host )
-      @ctlw = ctlw
-      @redir = redir
-      @reads = [ ctlr, redir ]
+      @mutex = Mutex.new
+      @reads = []
       @writes = []
-      @closings = []
-      @roles = {
-        ctlr => :ctlr,   # :ctlr / :redir / :tun
-        redir => :redir
-      }
+      @roles = {}        # :dotr / :redir / :tun
       @redir_wbuffs = [] # [ src_addr data ] ...
       @tuns = {}         # [ orig_src_addr dst_addr ]=> tun
       @mappings = {}     # src_addr => [ orig_src_addr dst_addr ]
@@ -47,6 +34,10 @@ module Girl
                          #   rbuffs: []
                          #   wbuffs: []
                          #   last_traff_at: now
+      dotr, dotw = IO.pipe
+      @dotw = dotw
+      add_read( dotr, :dotr )
+      new_a_redir( redir_port )
     end
 
     def looping
@@ -56,23 +47,23 @@ module Girl
         rs, ws = IO.select( @reads, @writes )
 
         @mutex.synchronize do
-          rs.each do | sock |
+          ws.each do | sock |
             case @roles[ sock ]
-            when :ctlr
-              read_ctlr( sock )
             when :redir
-              read_redir( sock )
+              write_redir( sock )
             when :tun
-              read_tun( sock )
+              write_tun( sock )
             end
           end
 
-          ws.each do | sock |
+          rs.each do | sock |
             case @roles[ sock ]
+            when :dotr
+              read_dotr( sock )
             when :redir
-              write_redir( sock )
+              read_redir( sock )
             when :tun
-              write_tun( sock )
+              read_tun( sock )
             end
           end
         end
@@ -85,15 +76,176 @@ module Girl
 
     private
 
-    def read_ctlr( ctlr )
-      od_addr = ctlr.read( 32 )
-      tun = @tuns[ od_addr ]
+    def loop_expire
+      Thread.new do
+        loop do
+          sleep 30
 
-      if tun
-        add_closing( tun )
+          @mutex.synchronize do
+            need_trigger = false
+            now = Time.new
+
+            @tun_infos.each do | tun, tun_info |
+              # net.netfilter.nf_conntrack_udp_timeout_stream
+              if now - tun_info[ :last_traff_at ] > 180
+                set_is_closing( tun )
+                need_trigger = true
+              end
+            end
+
+            if need_trigger
+              next_tick
+            end
+          end
+        end
       end
     end
 
+    def new_a_redir( redir_port )
+      redir = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
+      redir.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
+      redir.bind( Socket.sockaddr_in( redir_port, '0.0.0.0' ) )
+      puts "redir bound on #{ redir_port } #{ Time.new }"
+      @redir = redir
+      add_read( redir, :redir )
+    end
+
+    def new_a_tun( orig_src_addr, dst_addr, src_addr )
+      tun = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
+      tun.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
+      tun.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
+
+      @tun_infos[ tun ] = {
+        orig_src_addr: orig_src_addr,
+        dst_addr: dst_addr,
+        src_addr: src_addr,
+        tund_addr: nil,
+        rbuffs: [],
+        wbuffs: [],
+        last_traff_at: Time.new,
+        is_closing: false
+      }
+
+      @tuns[ [ orig_src_addr, dst_addr ].join ] = tun
+      add_read( tun, :tun )
+
+      tun
+    end
+
+    def add_redir_wbuff( redir, to_addr, data )
+      @redir_wbuffs << [ to_addr, data ]
+      add_write( redir )
+    end
+
+    def add_tun_wbuff( tun, to_addr, data )
+      tun_info = @tun_infos[ tun ]
+
+      if to_addr
+        tun_info[ :wbuffs ] << [ to_addr, data ]
+        add_write( tun )
+      else
+        tun_info[ :rbuffs ] << data
+      end
+    end
+
+    def add_read( sock, role )
+      unless @reads.include?( sock )
+        @reads << sock
+      end
+
+      @roles[ sock ] = role
+    end
+
+    def add_write( sock )
+      unless @writes.include?( sock )
+        @writes << sock
+      end
+    end
+
+    def set_is_closing( tun )
+      if tun && !tun.closed?
+        # puts "debug1 set tun is closing"
+
+        tun_info = @tun_infos[ tun ]
+        tun_info[ :is_closing ] = true
+
+        @reads.delete( tun )
+        add_write( tun )
+      end
+    end
+
+    def send_data( sock, data, to_addr )
+      begin
+        sock.sendmsg( data, 0, to_addr )
+      rescue IO::WaitWritable, Errno::EINTR
+        return false
+      rescue Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ENETDOWN => e
+        if @roles[ sock ] == :tun
+          puts "#{ Time.new } #{ e.class }, close tun"
+          close_tun( sock )
+          return false
+        end
+      end
+
+      true
+    end
+
+    def close_tun( tun )
+      tun.close
+      @reads.delete( tun )
+      @writes.delete( tun )
+      @roles.delete( tun )
+      tun_info = @tun_infos.delete( tun )
+      @tuns.delete( [ tun_info[ :orig_src_addr ], tun_info[ :dst_addr ] ].join )
+
+      if @mappings.include?( tun_info[ :src_addr ] )
+        orig_src_addr, dst_addr, timeout, read_at = @mappings[ tun_info[ :src_addr ] ]
+
+        if orig_src_addr == tun_info[ :orig_src_addr ] && dst_addr == tun_info[ :dst_addr ]
+          @mappings.delete( tun_info[ :src_addr ] )
+        end
+      end
+    end
+
+    def write_redir( redir )
+      while @redir_wbuffs.any?
+        to_addr, data = @redir_wbuffs.first
+
+        unless send_data( redir, data, to_addr )
+          return
+        end
+
+        @redir_wbuffs.shift
+      end
+
+      @writes.delete( redir )
+    end
+
+    def write_tun( tun )
+      tun_info = @tun_infos[ tun ]
+
+      if tun_info[ :is_closing ]
+        close_tun( tun )
+        return
+      end
+
+      while tun_info[ :wbuffs ].any?
+        to_addr, data = tun_info[ :wbuffs ].first
+
+        unless send_data( tun, data, to_addr )
+          return
+        end
+
+        tun_info[ :wbuffs ].shift
+      end
+
+      @writes.delete( tun )
+    end
+
+    def read_dotr( dotr )
+      dotr.read( 1 )
+    end
+
     def read_redir( redir )
       data, addrinfo, rflags, *controls = redir.recvmsg
       src_addr = addrinfo.to_sockaddr
@@ -180,121 +332,5 @@ module Girl
       end
     end
 
-    def write_redir( redir )
-      if @redir_wbuffs.empty?
-        @writes.delete( redir )
-        return
-      end
-
-      src_addr, data = @redir_wbuffs.shift
-      redir.sendmsg( data, 0, src_addr )
-    end
-
-    def write_tun( tun )
-      if @closings.include?( tun )
-        close_tun( tun )
-        return
-      end
-
-      tun_info = @tun_infos[ tun ]
-
-      if tun_info[ :wbuffs ].empty?
-        @writes.delete( tun )
-        return
-      end
-
-      to_addr, data = tun_info[ :wbuffs ].shift
-      tun.sendmsg( data, 0, to_addr )
-    end
-
-    def add_redir_wbuff( redir, to_addr, data )
-      @redir_wbuffs << [ to_addr, data ]
-      add_write( redir )
-    end
-
-    def add_tun_wbuff( tun, to_addr, data )
-      tun_info = @tun_infos[ tun ]
-
-      if to_addr
-        tun_info[ :wbuffs ] << [ to_addr, data ]
-        add_write( tun )
-      else
-        tun_info[ :rbuffs ] << data
-      end
-    end
-
-    def add_write( sock )
-      unless @writes.include?( sock )
-        @writes << sock
-      end
-    end
-
-    def add_closing( tun )
-      unless @closings.include?( tun )
-        @closings << tun
-      end
-
-      add_write( tun )
-    end
-
-    def close_tun( tun )
-      tun.close
-      @reads.delete( tun )
-      @writes.delete( tun )
-      @closings.delete( tun )
-      @roles.delete( tun )
-      tun_info = @tun_infos.delete( tun )
-      @tuns.delete( [ tun_info[ :orig_src_addr ], tun_info[ :dst_addr ] ].join )
-
-      if @mappings.include?( tun_info[ :src_addr ] )
-        orig_src_addr, dst_addr, timeout, read_at = @mappings[ tun_info[ :src_addr ] ]
-
-        if orig_src_addr == tun_info[ :orig_src_addr ] && dst_addr == tun_info[ :dst_addr ]
-          @mappings.delete( tun_info[ :src_addr ] )
-        end
-      end
-    end
-
-    def new_a_tun( orig_src_addr, dst_addr, src_addr )
-      tun = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
-      tun.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-      tun.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
-
-      @tun_infos[ tun ] = {
-        orig_src_addr: orig_src_addr,
-        dst_addr: dst_addr,
-        src_addr: src_addr,
-        tund_addr: nil,
-        rbuffs: [],
-        wbuffs: [],
-        last_traff_at: Time.new
-      }
-
-      @tuns[ [ orig_src_addr, dst_addr ].join ] = tun
-      @roles[ tun ] = :tun
-      @reads << tun
-
-      tun
-    end
-
-    def loop_expire
-      Thread.new do
-        loop do
-          sleep 30
-
-          @mutex.synchronize do
-            now = Time.new
-
-            @tun_infos.values.each do | tun_info |
-              # net.netfilter.nf_conntrack_udp_timeout_stream
-              if now - tun_info[ :last_traff_at ] > 180
-                @ctlw.write( [ tun_info[ :orig_src_addr ], tun_info[ :dst_addr ] ].join )
-              end
-            end
-          end
-        end
-      end
-    end
-
   end
 end

data/lib/girl/udpd.rb

@@ -8,23 +8,10 @@ module Girl
   class Udpd
 
     def initialize( port = 3030 )
-      ctlr, ctlw = IO.pipe
-
-      udpd = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
-      udpd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-      udpd.bind( Socket.sockaddr_in( port, '0.0.0.0' ) )
-      puts "udpd bound on #{ port } #{ Time.new }"
-
       @mutex = Mutex.new
-      @ctlw = ctlw
-      @udpd = udpd
-      @reads = [ ctlr, udpd ]
+      @reads = []
       @writes = []
-      @closings = []
-      @roles = {
-        ctlr => :ctlr,  # :ctlr / :udpd / :tund
-        udpd => :udpd
-      }
+      @roles = {}       # :dotr / :udpd / :tund
       @udpd_wbuffs = [] # [ tun_addr ctlmsg ] ...
       @tunds = {}       # [ tun_ip_addr orig_src_addr ] => tund
       @tund_infos = {}  # tund => {}
@@ -37,6 +24,10 @@ module Girl
                         #   is_tunneleds: { [ tun_addr dst_addr ] => false }
                         #   unpaired_dst_rbuffs: { dst_addr => [] }
                         #   last_traff_at: now
+      dotr, dotw = IO.pipe
+      @dotw = dotw
+      add_read( dotr, :dotr )
+      new_a_udpd( port )
     end
 
     def looping
@@ -46,23 +37,23 @@ module Girl
         rs, ws = IO.select( @reads, @writes )
 
         @mutex.synchronize do
-          rs.each do | sock |
+          ws.each do | sock |
             case @roles[ sock ]
-            when :ctlr
-              read_ctlr( sock )
             when :udpd
-              read_udpd( sock )
+              write_udpd( sock )
             when :tund
-              read_tund( sock )
+              write_tund( sock )
             end
           end
 
-          ws.each do | sock |
+          rs.each do | sock |
             case @roles[ sock ]
+            when :dotr
+              read_dotr( sock )
             when :udpd
-              write_udpd( sock )
+              read_udpd( sock )
             when :tund
-              write_tund( sock )
+              read_tund( sock )
             end
           end
         end
@@ -75,13 +66,176 @@ module Girl
 
     private
 
-    def read_ctlr( ctlr )
-      to_addr = ctlr.read( 32 )
-      tund = @tunds[ to_addr ]
+    def loop_expire
+      Thread.new do
+        loop do
+          sleep 30
+
+          @mutex.synchronize do
+            need_trigger = false
+            now = Time.new
+
+            @tund_infos.each do | tund, tund_info |
+              # net.netfilter.nf_conntrack_udp_timeout_stream
+              if now - tund_info[ :last_traff_at ] > 180
+                set_is_closing( tund )
+                need_trigger = true
+              end
+            end
+
+            if need_trigger
+              next_tick
+            end
+          end
+        end
+      end
+    end
+
+    def new_a_udpd( port )
+      udpd = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
+      udpd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
+      udpd.bind( Socket.sockaddr_in( port, '0.0.0.0' ) )
+      puts "udpd bound on #{ port } #{ Time.new }"
+      @udpd = udpd
+      add_read( udpd, :udpd )
+    end
+
+    def pair_tund( tun_addr, tun_ip_addr, orig_src_addr, dst_addr )
+      from_addr = [ tun_ip_addr, orig_src_addr ].join
+      td_addr = [ tun_addr, dst_addr ].join
+      tund = @tunds[ from_addr ]
 
       if tund
-        add_closing( tund )
+        tund_info = @tund_infos[ tund ]
+        tund_info[ :dst_addrs ][ tun_addr ] = dst_addr
+        tund_info[ :tun_addrs ][ dst_addr ] = tun_addr
+        tund_info[ :is_tunneleds ][ td_addr ] = false
+      else
+        tund = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
+        tund.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
+        tund.setsockopt( Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1 )
+        tund.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
+        tund_port = tund.local_address.ip_unpack.last
+
+        @tund_infos[ tund ] = {
+          port: tund_port,
+          tun_ip_addr: tun_ip_addr,
+          orig_src_addr: orig_src_addr,
+          wbuffs: [],
+          dst_addrs: { tun_addr => dst_addr },
+          tun_addrs: { dst_addr => tun_addr },
+          is_tunneleds: { td_addr => false },
+          unpaired_dst_rbuffs: {},
+          last_traff_at: Time.new,
+          is_closing: false
+        }
+
+        @tunds[ from_addr ] = tund
+        add_read( tund, :tund )
+      end
+
+      tund
+    end
+
+    def add_tund_wbuff( tund, to_addr, data )
+      tund_info = @tund_infos[ tund ]
+      tund_info[ :wbuffs ] << [ to_addr, data ]
+
+      add_write( tund )
+    end
+
+    def add_read( sock, role )
+      unless @reads.include?( sock )
+        @reads << sock
+      end
+
+      @roles[ sock ] = role
+    end
+
+    def add_write( sock )
+      unless @writes.include?( sock )
+        @writes << sock
+      end
+    end
+
+    def set_is_closing( tund )
+      if tund && !tund.closed?
+        # puts "debug1 set tund is closing"
+
+        tund_info = @tund_infos[ tund ]
+        tund_info[ :is_closing ] = true
+
+        @reads.delete( tund )
+        add_write( tund )
+      end
+    end
+
+    def send_data( sock, data, to_addr )
+      begin
+        sock.sendmsg( data, 0, to_addr )
+      rescue IO::WaitWritable, Errno::EINTR
+        return false
+      rescue Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ENETDOWN => e
+        if @roles[ sock ] == :tund
+          puts "#{ Time.new } #{ e.class }, close tund"
+          close_tund( sock )
+          return false
+        end
+      end
+
+      true
+    end
+
+    def close_tund( tund )
+      tund.close
+      @reads.delete( tund )
+      @writes.delete( tund )
+      @roles.delete( tund )
+      tund_info = @tund_infos.delete( tund )
+      @tunds.delete( [ tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ] ].join )
+    end
+
+    def next_tick
+      @dotw.write( '.' )
+    end
+
+    def write_udpd( udpd )
+      while @udpd_wbuffs.any?
+        to_addr, data = @udpd_wbuffs.first
+
+        unless send_data( udpd, data, to_addr )
+          return
+        end
+
+        @udpd_wbuffs.shift
+      end
+
+      @writes.delete( udpd )
+    end
+
+    def write_tund( tund )
+      tund_info = @tund_infos[ tund ]
+
+      if tund_info[ :is_closing ]
+        close_tund( tund )
+        return
+      end
+
+      while tund_info[ :wbuffs ].any?
+        to_addr, data = tund_info[ :wbuffs ].first
+
+        unless send_data( tund, data, to_addr )
+          return
+        end
+
+        tund_info[ :wbuffs ].shift
       end
+
+      @writes.delete( tund )
+    end
+
+    def read_dotr( dotr )
+      dotr.read( 1 )
     end
 
     def read_udpd( udpd )
@@ -168,119 +322,5 @@ module Girl
       end
     end
 
-    def write_udpd( udpd )
-      if @udpd_wbuffs.empty?
-        @writes.delete( udpd )
-        return
-      end
-
-      tun_addr, ctlmsg = @udpd_wbuffs.shift
-      udpd.sendmsg( ctlmsg, 0, tun_addr )
-    end
-
-    def write_tund( tund )
-      if @closings.include?( tund )
-        close_tund( tund )
-        return
-      end
-
-      tund_info = @tund_infos[ tund ]
-
-      if tund_info[ :wbuffs ].empty?
-        @writes.delete( tund )
-        return
-      end
-
-      to_addr, data = tund_info[ :wbuffs ].shift
-      tund.sendmsg( data, 0, to_addr )
-    end
-
-    def add_tund_wbuff( tund, to_addr, data )
-      tund_info = @tund_infos[ tund ]
-      tund_info[ :wbuffs ] << [ to_addr, data ]
-
-      add_write( tund )
-    end
-
-    def add_write( sock )
-      unless @writes.include?( sock )
-        @writes << sock
-      end
-    end
-
-    def add_closing( tund )
-      unless @closings.include?( tund )
-        @closings << tund
-      end
-
-      add_write( tund )
-    end
-
-    def close_tund( tund )
-      tund.close
-      @reads.delete( tund )
-      @writes.delete( tund )
-      @closings.delete( tund )
-      @roles.delete( tund )
-      tund_info = @tund_infos.delete( tund )
-      @tunds.delete( [ tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ] ].join )
-    end
-
-    def pair_tund( tun_addr, tun_ip_addr, orig_src_addr, dst_addr )
-      from_addr = [ tun_ip_addr, orig_src_addr ].join
-      td_addr = [ tun_addr, dst_addr ].join
-      tund = @tunds[ from_addr ]
-
-      if tund
-        tund_info = @tund_infos[ tund ]
-        tund_info[ :dst_addrs ][ tun_addr ] = dst_addr
-        tund_info[ :tun_addrs ][ dst_addr ] = tun_addr
-        tund_info[ :is_tunneleds ][ td_addr ] = false
-      else
-        tund = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
-        tund.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-        tund.setsockopt( Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1 )
-        tund.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
-        tund_port = tund.local_address.ip_unpack.last
-
-        @tund_infos[ tund ] = {
-          port: tund_port,
-          tun_ip_addr: tun_ip_addr,
-          orig_src_addr: orig_src_addr,
-          wbuffs: [],
-          dst_addrs: { tun_addr => dst_addr },
-          tun_addrs: { dst_addr => tun_addr },
-          is_tunneleds: { td_addr => false },
-          unpaired_dst_rbuffs: {},
-          last_traff_at: Time.new
-        }
-
-        @roles[ tund ] = :tund
-        @reads << tund
-        @tunds[ from_addr ] = tund
-      end
-
-      tund
-    end
-
-    def loop_expire
-      Thread.new do
-        loop do
-          sleep 30
-
-          @mutex.synchronize do
-            now = Time.new
-
-            @tund_infos.values.each do | tund_info |
-              # net.netfilter.nf_conntrack_udp_timeout_stream
-              if now - tund_info[ :last_traff_at ] > 180
-                @ctlw.write( [ tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ] ].join )
-              end
-            end
-          end
-        end
-      end
-    end
-
   end
 end

data/lib/girl/version.rb

@@ -1,3 +1,3 @@
 module Girl
-  VERSION = '0.81.0'.freeze
+  VERSION = '0.86.0'.freeze
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: girl
 version: !ruby/object:Gem::Version
-  version: 0.81.0
+  version: 0.86.0
 platform: ruby
 authors:
 - takafan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-27 00:00:00.000000000 Z
+date: 2020-09-18 00:00:00.000000000 Z
 dependencies: []
-description: while internet is evil, here's a girl.
+description: escape evil.
 email:
 - qqtakafan@gmail.com
 executables: []