github.com/ipfans/trojan-go@v0.11.0/tunnel/router/router_test.go (about)

     1  package router
     2  
     3  import (
     4  	"context"
     5  	"net"
     6  	"strconv"
     7  	"strings"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/ipfans/trojan-go/common"
    12  	"github.com/ipfans/trojan-go/config"
    13  	"github.com/ipfans/trojan-go/test/util"
    14  	"github.com/ipfans/trojan-go/tunnel"
    15  )
    16  
    17  type MockClient struct{}
    18  
    19  func (m *MockClient) DialConn(address *tunnel.Address, t tunnel.Tunnel) (tunnel.Conn, error) {
    20  	return nil, common.NewError("mockproxy")
    21  }
    22  
    23  func (m *MockClient) DialPacket(t tunnel.Tunnel) (tunnel.PacketConn, error) {
    24  	return MockPacketConn{}, nil
    25  }
    26  
    27  func (m MockClient) Close() error {
    28  	return nil
    29  }
    30  
    31  type MockPacketConn struct{}
    32  
    33  func (m MockPacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
    34  	panic("implement me")
    35  }
    36  
    37  func (m MockPacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
    38  	panic("implement me")
    39  }
    40  
    41  func (m MockPacketConn) Close() error {
    42  	panic("implement me")
    43  }
    44  
    45  func (m MockPacketConn) LocalAddr() net.Addr {
    46  	panic("implement me")
    47  }
    48  
    49  func (m MockPacketConn) SetDeadline(t time.Time) error {
    50  	panic("implement me")
    51  }
    52  
    53  func (m MockPacketConn) SetReadDeadline(t time.Time) error {
    54  	panic("implement me")
    55  }
    56  
    57  func (m MockPacketConn) SetWriteDeadline(t time.Time) error {
    58  	panic("implement me")
    59  }
    60  
    61  func (m MockPacketConn) WriteWithMetadata(bytes []byte, metadata *tunnel.Metadata) (int, error) {
    62  	return 0, common.NewError("mockproxy")
    63  }
    64  
    65  func (m MockPacketConn) ReadWithMetadata(bytes []byte) (int, *tunnel.Metadata, error) {
    66  	return 0, nil, common.NewError("mockproxy")
    67  }
    68  
    69  func TestRouter(t *testing.T) {
    70  	data := `
    71  router:
    72      enabled: true
    73      bypass: 
    74      - "regex:bypassreg(.*)"
    75      - "full:bypassfull"
    76      - "full:localhost"
    77      - "domain:bypass.com"
    78      block:
    79      - "regexp:blockreg(.*)"
    80      - "full:blockfull"
    81      - "domain:block.com"
    82      proxy:
    83      - "regexp:proxyreg(.*)"
    84      - "full:proxyfull"
    85      - "domain:proxy.com"
    86      - "cidr:192.168.1.1/16"
    87  `
    88  	ctx, err := config.WithYAMLConfig(context.Background(), []byte(data))
    89  	common.Must(err)
    90  	client, err := NewClient(ctx, &MockClient{})
    91  	common.Must(err)
    92  	_, err = client.DialConn(&tunnel.Address{
    93  		AddressType: tunnel.DomainName,
    94  		DomainName:  "proxy.com",
    95  		Port:        80,
    96  	}, nil)
    97  	if err.Error() != "mockproxy" {
    98  		t.Fatal(err)
    99  	}
   100  	_, err = client.DialConn(&tunnel.Address{
   101  		AddressType: tunnel.DomainName,
   102  		DomainName:  "proxyreg123456",
   103  		Port:        80,
   104  	}, nil)
   105  	if err.Error() != "mockproxy" {
   106  		t.Fatal(err)
   107  	}
   108  	_, err = client.DialConn(&tunnel.Address{
   109  		AddressType: tunnel.DomainName,
   110  		DomainName:  "proxyfull",
   111  		Port:        80,
   112  	}, nil)
   113  	if err.Error() != "mockproxy" {
   114  		t.Fatal(err)
   115  	}
   116  
   117  	_, err = client.DialConn(&tunnel.Address{
   118  		AddressType: tunnel.IPv4,
   119  		IP:          net.ParseIP("192.168.123.123"),
   120  		Port:        80,
   121  	}, nil)
   122  	if err.Error() != "mockproxy" {
   123  		t.Fatal(err)
   124  	}
   125  
   126  	_, err = client.DialConn(&tunnel.Address{
   127  		AddressType: tunnel.DomainName,
   128  		DomainName:  "block.com",
   129  		Port:        80,
   130  	}, nil)
   131  	if !strings.Contains(err.Error(), "block") {
   132  		t.Fatal("block??")
   133  	}
   134  	port, err := strconv.Atoi(util.HTTPPort)
   135  	common.Must(err)
   136  
   137  	_, err = client.DialConn(&tunnel.Address{
   138  		AddressType: tunnel.DomainName,
   139  		DomainName:  "localhost",
   140  		Port:        port,
   141  	}, nil)
   142  	if err != nil {
   143  		t.Fatal("dial http failed", err)
   144  	}
   145  
   146  	packet, err := client.DialPacket(nil)
   147  	common.Must(err)
   148  	buf := [10]byte{}
   149  	_, err = packet.WriteWithMetadata(buf[:], &tunnel.Metadata{
   150  		Address: &tunnel.Address{
   151  			AddressType: tunnel.DomainName,
   152  			DomainName:  "proxyfull",
   153  			Port:        port,
   154  		},
   155  	})
   156  	if err.Error() != "mockproxy" {
   157  		t.Fail()
   158  	}
   159  }