socket.go

   1 package torrent
   2
   3 import (
   4         "context"
   5         "fmt"
   6         "net"
   7         "strconv"
   8         "strings"
   9
  10         "github.com/anacrolix/missinggo"
  11 )
  12
  13 type dialer interface {
  14         dial(_ context.Context, addr string) (net.Conn, error)
  15 }
  16
  17 type socket interface {
  18         net.Listener
  19         dialer
  20 }
  21
  22 func listen(network, addr string) (socket, error) {
  23         if isTcpNetwork(network) {
  24                 return listenTcp(network, addr)
  25         } else if isUtpNetwork(network) {
  26                 return listenUtp(network, addr)
  27         } else {
  28                 panic(fmt.Sprintf("unknown network %q", network))
  29         }
  30 }
  31
  32 func isTcpNetwork(s string) bool {
  33         return strings.Contains(s, "tcp")
  34 }
  35
  36 func isUtpNetwork(s string) bool {
  37         return strings.Contains(s, "utp") || strings.Contains(s, "udp")
  38 }
  39
  40 func listenTcp(network, address string) (s socket, err error) {
  41         l, err := net.Listen(network, address)
  42         if err != nil {
  43                 return
  44         }
  45         return tcpSocket{l}, nil
  46 }
  47
  48 type tcpSocket struct {
  49         net.Listener
  50 }
  51
  52 func (me tcpSocket) dial(ctx context.Context, addr string) (net.Conn, error) {
  53         return net.Dial(me.Addr().Network(), addr)
  54 }
  55
  56 func setPort(addr string, port int) string {
  57         host, _, err := net.SplitHostPort(addr)
  58         if err != nil {
  59                 panic(err)
  60         }
  61         return net.JoinHostPort(host, strconv.FormatInt(int64(port), 10))
  62 }
  63
  64 func listenAll(networks []string, addr string) ([]socket, error) {
  65         if len(networks) == 0 {
  66                 return nil, nil
  67         }
  68         for {
  69                 ss, retry, err := listenAllRetry(networks, addr)
  70                 if !retry {
  71                         return ss, err
  72                 }
  73         }
  74 }
  75
  76 func listenAllRetry(networks []string, addr string) (ss []socket, retry bool, err error) {
  77         _, port, err := missinggo.ParseHostPort(addr)
  78         if err != nil {
  79                 err = fmt.Errorf("error parsing addr: %s", err)
  80                 return
  81         }
  82         ss = make([]socket, 1, len(networks))
  83         ss[0], err = listen(networks[0], addr)
  84         if err != nil {
  85                 return nil, false, fmt.Errorf("first listen: %s", err)
  86         }
  87         defer func() {
  88                 if err != nil || retry {
  89                         for _, s := range ss {
  90                                 s.Close()
  91                         }
  92                         ss = nil
  93                 }
  94         }()
  95         restAddr := setPort(addr, missinggo.AddrPort(ss[0].Addr()))
  96         for _, n := range networks[1:] {
  97                 s, err := listen(n, restAddr)
  98                 if err != nil {
  99                         return ss,
 100                                 missinggo.IsAddrInUse(err) && port == 0,
 101                                 fmt.Errorf("subsequent listen: %s", err)
 102                 }
 103                 ss = append(ss, s)
 104         }
 105         return
 106 }
 107
 108 func listenUtp(network, addr string) (s socket, err error) {
 109         us, err := NewUtpSocket(network, addr)
 110         if err != nil {
 111                 return
 112         }
 113         return utpSocketSocket{us, network}, nil
 114 }
 115
 116 type utpSocketSocket struct {
 117         utpSocket
 118         network string
 119 }
 120
 121 func (me utpSocketSocket) dial(ctx context.Context, addr string) (net.Conn, error) {
 122         return me.utpSocket.DialContext(ctx, me.network, addr)
 123 }