github.com/database64128/shadowsocks-go@v1.7.0/http/stream_test.go (about)

     1  package http
     2  
     3  import (
     4  	"net/netip"
     5  	"testing"
     6  
     7  	"github.com/database64128/shadowsocks-go/conn"
     8  	"github.com/database64128/shadowsocks-go/direct"
     9  	"github.com/database64128/shadowsocks-go/pipe"
    10  	"github.com/database64128/shadowsocks-go/zerocopy"
    11  	"go.uber.org/zap"
    12  )
    13  
    14  func TestHttpStreamReadWriter(t *testing.T) {
    15  	logger, err := zap.NewDevelopment()
    16  	if err != nil {
    17  		t.Fatal(err)
    18  	}
    19  	defer logger.Sync()
    20  
    21  	pl, pr := pipe.NewDuplexPipe()
    22  
    23  	clientTargetAddr := conn.AddrFromIPPort(netip.AddrPortFrom(netip.IPv6Unspecified(), 53))
    24  
    25  	var (
    26  		c                *direct.DirectStreamReadWriter
    27  		s                *direct.DirectStreamReadWriter
    28  		serverTargetAddr conn.Addr
    29  		cerr, serr       error
    30  	)
    31  
    32  	ctrlCh := make(chan struct{})
    33  
    34  	go func() {
    35  		c, cerr = NewHttpStreamClientReadWriter(pl, clientTargetAddr)
    36  		ctrlCh <- struct{}{}
    37  	}()
    38  
    39  	go func() {
    40  		s, serverTargetAddr, serr = NewHttpStreamServerReadWriter(pr, logger)
    41  		ctrlCh <- struct{}{}
    42  	}()
    43  
    44  	<-ctrlCh
    45  	<-ctrlCh
    46  	if cerr != nil {
    47  		t.Fatal(cerr)
    48  	}
    49  	if serr != nil {
    50  		t.Fatal(serr)
    51  	}
    52  
    53  	if !clientTargetAddr.Equals(serverTargetAddr) {
    54  		t.Errorf("Target address mismatch: c: %s, s: %s", clientTargetAddr, serverTargetAddr)
    55  	}
    56  
    57  	zerocopy.ReadWriterTestFunc(t, c, s)
    58  }
    59  
    60  func testHostHeaderToDomainPort(t *testing.T, host, expectedDomain string, expectedPort uint16) {
    61  	addr, err := hostHeaderToAddr(host)
    62  	if err != nil {
    63  		t.Errorf("Failed to parse %s: %s", host, err)
    64  	}
    65  	if domain := addr.Domain(); domain != expectedDomain {
    66  		t.Errorf("Expected domain %s, got %s", expectedDomain, domain)
    67  	}
    68  	if port := addr.Port(); port != expectedPort {
    69  		t.Errorf("Expected port %d, got %d", expectedPort, port)
    70  	}
    71  }
    72  
    73  func testHostHeaderToIPPort(t *testing.T, host string, expectedAddrPort netip.AddrPort) {
    74  	addr, err := hostHeaderToAddr(host)
    75  	if err != nil {
    76  		t.Errorf("Failed to parse %s: %s", host, err)
    77  	}
    78  	if addrPort := addr.IPPort(); addrPort != expectedAddrPort {
    79  		t.Errorf("Expected addrPort %s, got %s", expectedAddrPort, addrPort)
    80  	}
    81  }
    82  
    83  func testHostHeaderToError(t *testing.T, host string, expectedErr error) {
    84  	_, err := hostHeaderToAddr(host)
    85  	if err != expectedErr {
    86  		t.Errorf("Expected error %s, got %s", expectedErr, err)
    87  	}
    88  }
    89  
    90  func TestHostHeaderToAddr(t *testing.T) {
    91  	testHostHeaderToDomainPort(t, "example.com", "example.com", 80)
    92  	testHostHeaderToDomainPort(t, "example.com:443", "example.com", 443)
    93  
    94  	addr4 := netip.AddrFrom4([4]byte{1, 1, 1, 1})
    95  	testHostHeaderToIPPort(t, "1.1.1.1", netip.AddrPortFrom(addr4, 80))
    96  	testHostHeaderToIPPort(t, "1.1.1.1:443", netip.AddrPortFrom(addr4, 443))
    97  
    98  	addr6 := netip.AddrFrom16([16]byte{0x26, 0x06, 0x47, 0x00, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11})
    99  	testHostHeaderToIPPort(t, "[2606:4700:4700::1111]", netip.AddrPortFrom(addr6, 80))
   100  	testHostHeaderToIPPort(t, "[2606:4700:4700::1111]:443", netip.AddrPortFrom(addr6, 443))
   101  
   102  	testHostHeaderToError(t, "", errEmptyHostHeader)
   103  }