runner/autorun.go

@@ -24,8 +24,8 @@ type LocalLookup struct {
 }
 
 func (look *LocalLookup) Lookup(IP netip.Addr, Port uint16, Proto api.PortProto) *network.AddressValue[netip.AddrPort] {
-	look.AdreessLock.Lock()
+	// look.AdreessLock.Lock()
-	defer look.AdreessLock.Unlock()
+	// defer look.AdreessLock.Unlock()
 	for _, tunnel := range look.Adreess {
 		if tunnel.PortType != Proto && tunnel.PortType != "both" {
 			continue

runner/tunnel_runner.go

@@ -53,13 +53,14 @@ func (self *TunnelRunner) Run() chan error {
 			if 30_000 < time.Now().UnixMilli()-lastControlUpdate {
 				lastControlUpdate = now
 				if _, err := tunnel.ReloadControlAddr(); err != nil {
+					<-time.After(time.Second * 3)
+					continue
 				}
 			}
-			fmt.Println("Reciving new connection")
 			if new_client := tunnel.Update(); new_client != nil {
 				fmt.Println("New TCP Client")
-				found := self.Lookup.Lookup(new_client.ConnectAddr.Addr(), new_client.ConnectAddr.Port(), api.PortProto("tcp"))
+				var found *network.AddressValue[netip.AddrPort]
-				if found == nil {
+				if found = self.Lookup.Lookup(new_client.ConnectAddr.Addr(), new_client.ConnectAddr.Port(), api.PortProto("tcp")); found == nil {
 					fmt.Println("could not find local address for connection")
 					continue
 				}
@@ -77,6 +78,7 @@ func (self *TunnelRunner) Run() chan error {
 					defer tunnel_conn.Dropper.Drop()
 
 					if local_conn, err = network.TcpSocket(self.TcpClients.UseSpecialLAN, new_client.PeerAddr, netip.AddrPortFrom(found.Value.Addr(), (new_client.ConnectAddr.Port()-found.FromPort)+found.Value.Port())); err != nil {
+						fmt.Println(err)
 						return
 					}
 					defer local_conn.Close()
@@ -95,29 +97,28 @@ func (self *TunnelRunner) Run() chan error {
 				}()
 			}
 		}
+		end <- nil
 	}()
 
-	// go func(){
+	go func() {
-	// 	udp := tunnel.UdpTunnel()
+		udp := tunnel.UdpTunnel()
-	// 	for self.KeepRunning.Load() {
+		for self.KeepRunning.Load() {
-	// 		buffer := make([]byte, 2048)
+			buffer := make([]byte, 2048)
-	// 		fmt.Println("udp rec")
+			fmt.Println("udp rec")
-	// 		rx, err := udp.ReceiveFrom(buffer)
+			rx, err := udp.ReceiveFrom(buffer)
-	// 		if err != nil {
+			if err != nil {
-	// 			fmt.Println(err)
+				fmt.Println(err)
-	// 			time.Sleep(time.Second)
+				time.Sleep(time.Second)
-	// 			continue
+				continue
-	// 		}
+			}
-	// 		if rx.ConfirmerdConnection {
+			if rx.ConfirmerdConnection {
-	// 			continue
+				continue
-	// 		}
+			}
-	// 		d,_:=json.MarshalIndent(rx, "", "  ")
+			bytes, flow := rx.ReceivedPacket.Bytes, rx.ReceivedPacket.Flow
-	// 		fmt.Printf("rx: %s\n", string(d))
+			if err := self.UdpClients.ForwardPacket(flow, buffer[:bytes]); err != nil {
-	// 		bytes, flow := rx.ReceivedPacket.Bytes, rx.ReceivedPacket.Flow
+				panic(err)
-	// 		if err := self.UdpClients.ForwardPacket(flow, buffer[:bytes]); err != nil {
+			}
-	// 			panic(err)
+		}
-	// 		}
+	}()
-	// 	}
-	// }()
 	return end
 }

tunnel/simple_tunnel.go

@@ -163,6 +163,7 @@ func (self *SimpleTunnel) Update() *proto.NewClient {
 					if err := self.udpTunnel.SetUdpTunnel(details); err != nil {
 						panic(err)
 					}
+					return self.Update()
 				} else if content.Unauthorized {
 					self.controlChannel.SetExpired()
 				} else if pong := content.Pong; pong != nil {

tunnel/udp_tunnel.go

@@ -84,10 +84,10 @@ func (udp *UdpTunnel) RequiresAuth() bool {
 
 func (udp *UdpTunnel) SetUdpTunnel(details *proto.UdpChannelDetails) error {
 	// LogDebug.Println("Updating Udp Tunnel")
-	udp.locker.Lock()
+	// udp.locker.Lock()
 	if current := udp.Details.Udp; current != nil {
 		if bytes.Equal(current.Token, details.Token) && current.TunnelAddr.Compare(details.TunnelAddr) == 0 {
-			udp.locker.Unlock()
+			// udp.locker.Unlock()
 			return nil
 		}
 		if current.TunnelAddr.Compare(details.TunnelAddr) != 0 {
@@ -99,7 +99,7 @@ func (udp *UdpTunnel) SetUdpTunnel(details *proto.UdpChannelDetails) error {
 	udp.Details.Udp = new(proto.UdpChannelDetails)
 	udp.Details.Udp.Token = details.Token
 	udp.Details.Udp.TunnelAddr = details.TunnelAddr
-	udp.locker.Unlock()
+	// udp.locker.Unlock()
 
 	return udp.SendToken(details)
 }
@@ -115,8 +115,8 @@ func (udp *UdpTunnel) ResendToken() (bool, error) {
 }
 
 func (udp *UdpTunnel) SendToken(details *proto.UdpChannelDetails) error {
-	udp.locker.RLock()
+	// udp.locker.RLock()
-	defer udp.locker.RUnlock()
+	// defer udp.locker.RUnlock()
 	if details.TunnelAddr.Addr().Is4() {
 		if _, err := udp.Udp4.WriteToUDPAddrPort(details.Token, details.TunnelAddr); err != nil {
 			return err
@@ -135,8 +135,8 @@ func (udp *UdpTunnel) SendToken(details *proto.UdpChannelDetails) error {
 }
 
 func (udp *UdpTunnel) GetSock() (*net.UDPConn, *netip.AddrPort, error) {
-	udp.locker.RLock()
+	// udp.locker.RLock()
-	defer udp.locker.RUnlock()
+	// defer udp.locker.RUnlock()
 
 	lock := udp.Details
 	if lock.Udp == nil {
@@ -166,8 +166,8 @@ func (Udp *UdpTunnel) Send(data []byte, Flow UdpFlow) (int, error) {
 }
 
 func (Udp *UdpTunnel) GetToken() ([]byte, error) {
-	Udp.locker.RLock()
+	// Udp.locker.RLock()
-	defer Udp.locker.RUnlock()
+	// defer Udp.locker.RUnlock()
 	lock := Udp.Details
 	if lock.Udp == nil {
 		return nil, fmt.Errorf("udp tunnel not connected")
@@ -185,8 +185,8 @@ type UdpTunnelRx struct {
 }
 
 func (Udp *UdpTunnel) ReceiveFrom(buff []byte) (*UdpTunnelRx, error) {
-	Udp.locker.RLock()
+	// Udp.locker.RLock()
-	defer Udp.locker.RUnlock()
+	// defer Udp.locker.RUnlock()
 
 	udp, tunnelAddr, err := Udp.GetSock()
 	if err != nil {