Remove dependency on transport.Net from client

Remove dependency on transport.Net from client

client.go

@@ -10,7 +10,6 @@ import (
 
  "github.com/pion/logging"
  "github.com/pion/stun"
- "github.com/pion/transport/vnet"
  "github.com/pion/turn/v2/internal/client"
  "github.com/pion/turn/v2/internal/proto"
 )
@@ -33,39 +32,35 @@ const (
 
 // ClientConfig is a bag of config parameters for Client.
 type ClientConfig struct {
- STUNServerAddr string // STUN server address (e.g. "stun.abc.com:3478")
- TURNServerAddr string // TURN server address (e.g. "turn.abc.com:3478")
+ STUNServerAddr net.Addr // STUN server address
+ TURNServerAddr net.Addr // TURN server address
  Username string
  Password string
  Realm string
  Software string
  RTO time.Duration
  Conn net.PacketConn // Listening socket (net.PacketConn)
  LoggerFactory logging.LoggerFactory
- Net *vnet.Net
 }
 
 // Client is a STUN server client
 type Client struct {
- conn net.PacketConn // read-only
- stunServ net.Addr // read-only
- turnServ net.Addr // read-only
- stunServStr string // read-only, used for de-multiplexing
- turnServStr string // read-only, used for de-multiplexing
- username stun.Username // read-only
- password string // read-only
- realm stun.Realm // read-only
- integrity stun.MessageIntegrity // read-only
- software stun.Software // read-only
- trMap *client.TransactionMap // thread-safe
- rto time.Duration // read-only
- relayedConn *client.UDPConn // protected by mutex ***
- allocTryLock client.TryLock // thread-safe
- listenTryLock client.TryLock // thread-safe
- net *vnet.Net // read-only
- mutex sync.RWMutex // thread-safe
- mutexTrMap sync.Mutex // thread-safe
- log logging.LeveledLogger // read-only
+ conn net.PacketConn // read-only
+ stunServerAddr net.Addr // read-only
+ turnServerAddr net.Addr // read-only
+ username stun.Username // read-only
+ password string // read-only
+ realm stun.Realm // read-only
+ integrity stun.MessageIntegrity // read-only
+ software stun.Software // read-only
+ trMap *client.TransactionMap // thread-safe
+ rto time.Duration // read-only
+ relayedConn *client.UDPConn // protected by mutex ***
+ allocTryLock client.TryLock // thread-safe
+ listenTryLock client.TryLock // thread-safe
+ mutex sync.RWMutex // thread-safe
+ mutexTrMap sync.Mutex // thread-safe
+ log logging.LeveledLogger // read-only
 }
 
 // NewClient returns a new Client instance. listeningAddress is the address and port to listen on, default "0.0.0.0:0"
@@ -81,66 +76,35 @@ func NewClient(config *ClientConfig) (*Client, error) {
  return nil, errNilConn
  }
 
- if config.Net == nil {
- config.Net = vnet.NewNet(nil) // defaults to native operation
- } else if config.Net.IsVirtual() {
- log.Warn("vnet is enabled")
- }
-
- var stunServ, turnServ net.Addr
- var stunServStr, turnServStr string
- var err error
- if len(config.STUNServerAddr) > 0 {
- log.Debugf("resolving %s", config.STUNServerAddr)
- stunServ, err = config.Net.ResolveUDPAddr("udp4", config.STUNServerAddr)
- if err != nil {
- return nil, err
- }
- stunServStr = stunServ.String()
- log.Debugf("stunServ: %s", stunServStr)
- }
- if len(config.TURNServerAddr) > 0 {
- log.Debugf("resolving %s", config.TURNServerAddr)
- turnServ, err = config.Net.ResolveUDPAddr("udp4", config.TURNServerAddr)
- if err != nil {
- return nil, err
- }
- turnServStr = turnServ.String()
- log.Debugf("turnServ: %s", turnServStr)
- }
-
  rto := defaultRTO
  if config.RTO > 0 {
  rto = config.RTO
  }
 
  c := &Client{
- conn: config.Conn,
- stunServ: stunServ,
- turnServ: turnServ,
- stunServStr: stunServStr,
- turnServStr: turnServStr,
- username: stun.NewUsername(config.Username),
- password: config.Password,
- realm: stun.NewRealm(config.Realm),
- software: stun.NewSoftware(config.Software),
- net: config.Net,
- trMap: client.NewTransactionMap(),
- rto: rto,
- log: log,
+ conn: config.Conn,
+ stunServerAddr: config.STUNServerAddr,
+ turnServerAddr: config.TURNServerAddr,
+ username: stun.NewUsername(config.Username),
+ password: config.Password,
+ realm: stun.NewRealm(config.Realm),
+ software: stun.NewSoftware(config.Software),
+ trMap: client.NewTransactionMap(),
+ rto: rto,
+ log: log,
  }
 
  return c, nil
 }
 
 // TURNServerAddr return the TURN server address
 func (c *Client) TURNServerAddr() net.Addr {
- return c.turnServ
+ return c.turnServerAddr
 }
 
 // STUNServerAddr return the STUN server address
 func (c *Client) STUNServerAddr() net.Addr {
- return c.stunServ
+ return c.stunServerAddr
 }
 
 // Username returns username
@@ -227,10 +191,10 @@ func (c *Client) SendBindingRequestTo(to net.Addr) (net.Addr, error) {
 
 // SendBindingRequest sends a new STUN request to the STUN server
 func (c *Client) SendBindingRequest() (net.Addr, error) {
- if c.stunServ == nil {
+ if c.stunServerAddr == nil {
  return nil, errSTUNServerAddressNotSet
  }
- return c.SendBindingRequestTo(c.stunServ)
+ return c.SendBindingRequestTo(c.stunServerAddr)
 }
 
 // Allocate sends a TURN allocation request to the given transport address
@@ -255,7 +219,7 @@ func (c *Client) Allocate() (net.PacketConn, error) {
  return nil, err
  }
 
- trRes, err := c.PerformTransaction(msg, c.turnServ, false)
+ trRes, err := c.PerformTransaction(msg, c.turnServerAddr, false)
  if err != nil {
  return nil, err
  }
@@ -289,7 +253,7 @@ func (c *Client) Allocate() (net.PacketConn, error) {
  return nil, err
  }
 
- trRes, err = c.PerformTransaction(msg, c.turnServ, false)
+ trRes, err = c.PerformTransaction(msg, c.turnServerAddr, false)
  if err != nil {
  return nil, err
  }
@@ -415,7 +379,7 @@ func (c *Client) HandleInbound(data []byte, from net.Addr) (bool, error) {
  return true, c.handleSTUNMessage(data, from)
  case proto.IsChannelData(data):
  return true, c.handleChannelData(data)
- case len(c.stunServStr) != 0 && from.String() == c.stunServStr:
+ case from.String() == c.stunServerAddr.String():
  // received from STUN server but it is not a STUN message
  return true, errNonSTUNMessage
  default:

client_test.go

@@ -9,7 +9,6 @@ import (
  "time"
 
  "github.com/pion/logging"
- "github.com/pion/transport/vnet"
  "github.com/stretchr/testify/assert"
 )
 
@@ -32,10 +31,14 @@ func createListeningTestClientWithSTUNServ(t *testing.T, loggerFactory logging.L
  conn, err := net.ListenPacket("udp4", "0.0.0.0:0")
  assert.NoError(t, err)
 
+ addr, err := net.ResolveUDPAddr("udp", "stun1.l.google.com:19302")
+ if err != nil {
+ t.Fatalf("failed to resolve: %s", err)
+ }
+
  c, err := NewClient(&ClientConfig{
- STUNServerAddr: "stun1.l.google.com:19302",
+ STUNServerAddr: addr,
  Conn: conn,
- Net: vnet.NewNet(nil),
  LoggerFactory: loggerFactory,
  })
  assert.NoError(t, err)
@@ -158,10 +161,15 @@ func TestClientNonceExpiration(t *testing.T) {
  conn, err := net.ListenPacket("udp4", "0.0.0.0:0")
  assert.NoError(t, err)
 
+ addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:3478")
+ if err != nil {
+ t.Fatalf("failed to resolve: %s", err)
+ }
+
  client, err := NewClient(&ClientConfig{
  Conn: conn,
- STUNServerAddr: "127.0.0.1:3478",
- TURNServerAddr: "127.0.0.1:3478",
+ STUNServerAddr: addr,
+ TURNServerAddr: addr,
  Username: "foo",
  Password: "pass",
  })

examples/turn-client/tcp/main.go

@@ -30,8 +30,13 @@ func main() {
  }
 
  // Dial TURN Server
- turnServerAddr := fmt.Sprintf("%s:%d", *host, *port)
- conn, err := net.Dial("tcp", turnServerAddr)
+ hostPort := fmt.Sprintf("%s:%d", *host, *port)
+ turnServerAddr, err := net.ResolveTCPAddr("tcp", hostPort)
+ if err != nil {
+ log.Fatalf("Failed to resolve %s: %s", hostPort, err)
+ }
+
+ conn, err := net.DialTCP("tcp", nil, turnServerAddr)
  if err != nil {
  log.Panicf("Failed to connect to TURN server: %s", err)
  }

examples/turn-client/udp/main.go

@@ -31,8 +31,14 @@ func main() {
 
  cred := strings.SplitN(*user, "=", 2)
 
+ hostPort := fmt.Sprintf("%s:%d", *host, *port)
+ turnServerAddr, err := net.ResolveUDPAddr("udp", hostPort)
+ if err != nil {
+ log.Fatalf("Failed to resolve %s: %s", hostPort, err)
+ }
+
  // TURN client won't create a local listening socket by itself.
- conn, err := net.ListenPacket("udp4", "0.0.0.0:0")
+ conn, err := net.ListenUDP("udp", nil)
  if err != nil {
  log.Panicf("Failed to listen: %s", err)
  }
@@ -42,8 +48,6 @@ func main() {
  }
  }()
 
- turnServerAddr := fmt.Sprintf("%s:%d", *host, *port)
-
  cfg := &turn.ClientConfig{
  STUNServerAddr: turnServerAddr,
  TURNServerAddr: turnServerAddr,

lt_cred_test.go

@@ -51,9 +51,14 @@ func TestNewLongTermAuthHandler(t *testing.T) {
  username, password, err := GenerateLongTermCredentials(sharedSecret, time.Minute)
  assert.NoError(t, err)
 
+ addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:3478")
+ if err != nil {
+ t.Fatalf("failed to resolve: %s", err)
+ }
+
  client, err := NewClient(&ClientConfig{
- STUNServerAddr: "0.0.0.0:3478",
- TURNServerAddr: "0.0.0.0:3478",
+ STUNServerAddr: addr,
+ TURNServerAddr: addr,
  Conn: conn,
  Username: username,
  Password: password,

server_test.go

@@ -266,11 +266,12 @@ func TestServerVNet(t *testing.T) {
  assert.NoError(t, lconn.Close())
  }()
 
+ stunAddr, _ := net.ResolveUDPAddr("udp", "1.2.3.4:3478")
+
  log.Debug("creating a client.")
  client, err := NewClient(&ClientConfig{
- STUNServerAddr: "1.2.3.4:3478",
+ STUNServerAddr: stunAddr,
  Conn: lconn,
- Net: v.netL0,
  LoggerFactory: loggerFactory,
  })
  assert.NoError(t, err, "should succeed")
@@ -296,14 +297,16 @@ func TestServerVNet(t *testing.T) {
  lconn, err := v.netL0.ListenPacket("udp4", "0.0.0.0:0")
  assert.NoError(t, err)
 
+ stunAddr, _ := v.netL0.ResolveUDPAddr("udp", "stun.pion.ly:3478")
+ turnAddr, _ := v.netL0.ResolveUDPAddr("udp", "turn.pion.ly:3478")
+
  log.Debug("creating a client.")
  client, err := NewClient(&ClientConfig{
- STUNServerAddr: "stun.pion.ly:3478",
- TURNServerAddr: "turn.pion.ly:3478",
+ STUNServerAddr: stunAddr,
+ TURNServerAddr: turnAddr,
  Username: "user",
  Password: "pass",
  Conn: lconn,
- Net: v.netL0,
  LoggerFactory: loggerFactory,
  })