refactor

diff --git a/Net.go b/Net.go
index 4005d58b46489d7721ffb4f023a12d4756deabe0..98c6378c9f44150f4d38988dbdfebee6df885b85 100644 (file)
--- a/Net.go
+++ b/Net.go
@@ -56,111 +56,261 @@ func (*netl) TestDial(network,address string, Timeout int) bool {
     return true
 }
 
-func (t *netl) Forward(targetaddr,targetnetwork *string, listenaddr string,Need_Accept bool) {
-    proxylistener, err := net.Listen("tcp", listenaddr + ":0")
-    if err != nil {
-        Logf().E("[part/Forward]Unable to listen, error:", err.Error())
-    }
-    const max = 1000
-    var accept_chan chan bool = make(chan bool,max)
-    t.RV = append(t.RV,proxylistener.Addr().(*net.TCPAddr).Port,accept_chan,err)
+// func (t *netl) Forward(targetaddr,targetnetwork *string, listenaddr string,Need_Accept bool) {
+//     proxylistener, err := net.Listen("tcp", listenaddr + ":0")
+//     if err != nil {
+//         Logf().E("[part/Forward]Unable to listen, error:", err.Error())
+//     }
+//     const max = 1000
+//     var accept_chan chan bool = make(chan bool,max)
+//     t.RV = append(t.RV,proxylistener.Addr().(*net.TCPAddr).Port,accept_chan,err)
 
-    defer proxylistener.Close()
+//     defer proxylistener.Close()
 
-    tcpBridge2 := func (a, b net.Conn) {
+//     tcpBridge2 := func (a, b net.Conn) {
     
-        fin:=make(chan bool,1)
-        var wg sync.WaitGroup
+//         fin:=make(chan bool,1)
+//         var wg sync.WaitGroup
     
-        wg.Add(2)
-        go func(){
-            defer func() {
-                a.Close()
-                b.Close()
-                fin <- true
-                wg.Done()
-            }()
+//         wg.Add(2)
+//         go func(){
+//             defer func() {
+//                 a.Close()
+//                 b.Close()
+//                 fin <- true
+//                 wg.Done()
+//             }()
     
-            buf := make([]byte, 20480)
+//             buf := make([]byte, 20480)
             
-            for {
-                select {
-                case <-fin:
-                    return;
-                default:
-                    n, err := a.Read(buf)
+//             for {
+//                 select {
+//                 case <-fin:
+//                     return;
+//                 default:
+//                     n, err := a.Read(buf)
             
-                    if err != nil {return}
-                    b.Write(buf[:n])
-                }
-            }
-        }()
+//                     if err != nil {return}
+//                     b.Write(buf[:n])
+//                 }
+//             }
+//         }()
         
-        go func(){
-            defer func() {
-                a.Close()
-                b.Close()
-                fin <- true
-                wg.Done()
-            }()
+//         go func(){
+//             defer func() {
+//                 a.Close()
+//                 b.Close()
+//                 fin <- true
+//                 wg.Done()
+//             }()
     
-            buf := make([]byte, 20480)
+//             buf := make([]byte, 20480)
             
-            for {
-                select {
-                case <-fin:
-                    return;
-                default:
-                    n, err := b.Read(buf)
+//             for {
+//                 select {
+//                 case <-fin:
+//                     return;
+//                 default:
+//                     n, err := b.Read(buf)
             
-                    if err != nil {return}
-                    a.Write(buf[:n])
-                }
-            }
-        }()
+//                     if err != nil {return}
+//                     a.Write(buf[:n])
+//                 }
+//             }
+//         }()
     
-        wg.Wait()
-    }
+//         wg.Wait()
+//     }
 
-    for {
+//     for {
 
-        proxyconn, err := proxylistener.Accept()
-        if err != nil {
-            Logf().E("[part/Forward]Unable to accept a request:", err.Error())
-            continue
-        }
+//         proxyconn, err := proxylistener.Accept()
+//         if err != nil {
+//             Logf().E("[part/Forward]Unable to accept a request:", err.Error())
+//             continue
+//         }
         
-        if Need_Accept {
-            if len(accept_chan) == max {
-                Logf().E("[part/Forward] accept channel full.Skip")
-                <- accept_chan 
-            }
-            accept_chan <- true
+//         if Need_Accept {
+//             if len(accept_chan) == max {
+//                 Logf().E("[part/Forward] accept channel full.Skip")
+//                 <- accept_chan 
+//             }
+//             accept_chan <- true
+//         }
+//         if *targetaddr == "" || *targetnetwork == "" {
+//             proxyconn.Close()
+//             Logf().I("[part/Forward]Stop!", *targetaddr, *targetnetwork)
+//             break
+//         }
+
+//         retry := 0
+//         for {
+//             targetconn, err := net.Dial(*targetnetwork, *targetaddr)
+//             if err != nil {
+//                 Logf().E("[part/Forward]Unable to connect:", *targetaddr, err.Error())
+//                 retry += 1
+//                 if retry >= 2 {proxyconn.Close();break}
+//                 time.Sleep(time.Duration(1)*time.Millisecond)
+//                 continue
+//             }    
+
+//             go tcpBridge2(proxyconn,targetconn)
+//             break
+//         }
+//     }
+
+// }
+
+const (
+    ErrorMsg = iota
+    AcceptMsg
+    PortMsg
+)
+
+//when Type is ErrorMsg, Msg is set to error
+//when Type is AcceptMsg, Msg is set to nil
+//when Type is PortMsg, Msg is set to Listen Port(int)
+type ForwardMsg struct {
+    Type int
+    Msg interface{}
+}
+
+func Forward(targetaddr,targetnetwork *string, listenaddr string) (close func(),msg_chan chan ForwardMsg) {
+    //初始化消息通道
+    msg_chan = make(chan ForwardMsg, 1000)
+
+    //尝试监听
+    listener, err := net.Listen("tcp", listenaddr + ":0")
+    if err != nil {
+        select{
+        default:;
+        case msg_chan <- ForwardMsg{
+            Type: ErrorMsg,
+            Msg: err,
+        }:;
         }
-        if *targetaddr == "" || *targetnetwork == "" {
-            proxyconn.Close()
-            Logf().I("[part/Forward]Stop!", *targetaddr, *targetnetwork)
-            break
+        return
+    }
+
+    //初始化关闭方法
+    close = func(){ 
+        *targetaddr, *targetnetwork = "", ""
+        listener.Close()
+    }
+    
+    //返回监听端口
+    select{
+    default:;
+    case msg_chan <- ForwardMsg{
+        Type: PortMsg,
+        Msg: listener.Addr().(*net.TCPAddr).Port,
+    }:;
+    }
+
+    //开始准备转发
+    go func(listener net.Listener, targetaddr,targetnetwork *string, msg_chan chan ForwardMsg){
+        defer close(msg_chan)
+        defer listener.Close()
+
+        //tcp 桥
+        tcpBridge2 := func (a, b net.Conn) {
+        
+            fin:=make(chan bool,1)
+            var wg sync.WaitGroup
+        
+            wg.Add(2)
+            go func(){
+                defer func() {
+                    a.Close()
+                    b.Close()
+                    fin <- true
+                    wg.Done()
+                }()
+        
+                buf := make([]byte, 20480)
+                
+                for {
+                    select {
+                    case <-fin:
+                        return;
+                    default:
+                        n, err := a.Read(buf)
+                
+                        if err != nil {return}
+                        b.Write(buf[:n])
+                    }
+                }
+            }()
+            
+            go func(){
+                defer func() {
+                    a.Close()
+                    b.Close()
+                    fin <- true
+                    wg.Done()
+                }()
+        
+                buf := make([]byte, 20480)
+                
+                for {
+                    select {
+                    case <-fin:
+                        return;
+                    default:
+                        n, err := b.Read(buf)
+                
+                        if err != nil {return}
+                        a.Write(buf[:n])
+                    }
+                }
+            }()
+        
+            wg.Wait()
         }
 
-        retry := 0
         for {
+            proxyconn, err := listener.Accept()
+            if err != nil {
+                //返回Accept错误
+                select{
+                default:;
+                case msg_chan <- ForwardMsg{
+                    Type: ErrorMsg,
+                    Msg: err,
+                }:;
+                }
+                continue
+            }
+            
+            //返回Accept
+            select{
+            default:;
+            case msg_chan <- ForwardMsg{
+                Type: AcceptMsg,
+            }:;
+            }
+    
+            if *targetaddr == "" || *targetnetwork == "" {break}
+    
             targetconn, err := net.Dial(*targetnetwork, *targetaddr)
             if err != nil {
-                Logf().E("[part/Forward]Unable to connect:", *targetaddr, err.Error())
-                retry += 1
-                if retry >= 2 {proxyconn.Close();break}
-                time.Sleep(time.Duration(1)*time.Millisecond)
+                select{
+                default:;
+                case msg_chan <- ForwardMsg{
+                    Type: ErrorMsg,
+                    Msg: err,
+                }:;
+                }
+                proxyconn.Close()
                 continue
-            }    
-
+            }
+    
             go tcpBridge2(proxyconn,targetconn)
-            break
         }
-    }
-
+    }(listener, targetaddr, targetnetwork, msg_chan)
 }
 
+
 func (this *netl) GetLocalDns() error {
        if runtime.GOOS == "windows" {
                cmd := exec.Command("nslookup","127.0.0.1")
@@ -204,3 +354,15 @@ func (this *netl) GetLocalDns() error {
 
        return errors.New("1")
 }
+
+func MasterDomain(url string) (string,error){
+    if u,e := url.Parse(url);e != nil {
+        return "",e
+    } else {
+        host := u.Hostname()
+        list := strings.SplitAfter(host, ".")
+        if len(list) < 2 {return "",errors.new("invalid domain:"+host)}
+        return strings.Join(list[len(list)-2:], "."),nil
+    }
+    return "",nil
+}

diff --git a/Port.go b/Port.go
deleted file mode 100644 (file)
index 4c9b046..0000000
--- a/Port.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package part
-
-import (
-       // "net"
-)
-
-type port struct {}
-
-var (
-       port_map map[string]int = make(map[string]int)
-       port_buf chan bool = make(chan bool,1)
-)
-
-func Port() (*port) {
-       return &port{}
-}
-
-func (p *port) Get(key string) int {
-       if p,ok := port_map[key]; ok {return p} 
-       return p.New(key)
-}
-
-func (*port) Del(key string) {
-       delete(port_map,key)
-}
-
-func (*port) Set(key string,l int) int {
-       port_buf<-true
-       defer func(){
-               <-port_buf
-       }()
-       port_map[key] = l
-       return l
-}
-
-func (*port) New(key string) int {
-       port_buf<-true
-       defer func(){
-               <-port_buf
-       }()
-       if p := Sys().GetFreePort();p != 0{
-               Logf().I("New port with key:",key,p)
-               port_map[key] = p
-               return p
-       }
-
-       Logf().E("cant get free port with key:",key)
-       return 0
-}
\ No newline at end of file

diff --git a/buf/map.go b/buf/map.go
deleted file mode 100644 (file)
index 3d19ec2..0000000
--- a/buf/map.go
+++ /dev/null
@@ -1,46 +0,0 @@
-package part
-
-import (
-       "os"
-       "github.com/thedevsaddam/gojsonq/v2"
-)
-
-type Map struct {
-       B map[string]interface{}
-}
-
-func New() *Map {
-       b := new(Map)
-       b.B = make(map[string]interface{})
-       return b
-} 
-
-func (i *Map) Get(key string) (interface{},bool) {
-       v,ok := i.B[key]
-       return v,ok
-}
-
-func (i *Map) Set(key string,val interface{}) bool {
-       switch val.(type) {
-       case string,bool,int,float64:
-               i.B[key] = val
-               return true
-       default:
-       }
-       return false
-}
-
-func (i *Map) Save(Source string) error {
-       js := gojsonq.New().FromInterface(i.B)
-       fileObj,err := os.OpenFile(Source,os.O_RDWR|os.O_EXCL,0644)
-       if err != nil {return err}
-       defer fileObj.Close()
-       js.Writer(fileObj)
-       return nil
-}
-
-func (i *Map) Load(Source string) {
-       if b := gojsonq.New().File(Source).Get();b != nil{
-               i.B = b.(map[string]interface {})
-       }
-}
\ No newline at end of file

diff --git a/map/map.go b/map/map.go
new file mode 100644 (file)
index 0000000..64f6b7f
--- /dev/null
+++ b/map/map.go
@@ -0,0 +1,24 @@
+package part
+
+import (
+       "sync"
+)
+
+type Map struct{
+       m sync.Map
+       New func()interface{}
+}
+
+func (m *Map) Get(key interface{})interface{}{
+       if val,ok := m.Load(key);ok{return val}
+       return m.Set(key, m.New())
+}
+
+func (m *Map) Del(key interface{}){
+       m.Delete(key)
+}
+
+func (m *Map) Set(key interface{},val interface{})interface{}{
+       m.Store(key, val)
+       return val
+}
\ No newline at end of file

diff --git a/map/Map.go b/sync/Map.go
similarity index 100%
rename from map/Map.go
rename to sync/Map.go

diff --git a/map/Map_test.go b/sync/Map_test.go
similarity index 100%
rename from map/Map_test.go
rename to sync/Map_test.go