func (cl *Client) acceptConnections(l net.Listener, utp bool) {
for {
cl.waitAccept()
conn, err := l.Accept()
conn = pproffd.WrapNetConn(conn)
if cl.closed.IsSet() {
if conn != nil {
conn.Close()
}
return
}
if err != nil {
log.Print(err)
// I think something harsher should happen here? Our accept
// routine just f****d off.
return
}
if utp {
acceptUTP.Add(1)
} else {
acceptTCP.Add(1)
}
cl.mu.RLock()
reject := cl.badPeerIPPort(
missinggo.AddrIP(conn.RemoteAddr()),
missinggo.AddrPort(conn.RemoteAddr()))
cl.mu.RUnlock()
if reject {
acceptReject.Add(1)
conn.Close()
continue
}
go cl.incomingConnection(conn, utp)
}
}
func (c *udpClient) Connect() (err error) {
if c.connected() {
return nil
}
c.connectionId = connectRequestConnectionId
if c.socket == nil {
hmp := missinggo.SplitHostMaybePort(c.url.Host)
if hmp.NoPort {
hmp.NoPort = false
hmp.Port = 80
}
c.socket, err = net.Dial("udp", hmp.String())
if err != nil {
return
}
c.socket = pproffd.WrapNetConn(c.socket)
}
b, err := c.request(ActionConnect, nil, nil)
if err != nil {
return
}
var res ConnectionResponse
err = readBody(b, &res)
if err != nil {
return
}
c.connectionId = res.ConnectionId
c.connectionIdReceived = time.Now()
return
}
func (cl *Client) dialTCP(addr string, t *Torrent) (c net.Conn, err error) {
c, err = net.DialTimeout("tcp", addr, cl.dialTimeout(t))
if err == nil {
c.(*net.TCPConn).SetLinger(0)
}
c = pproffd.WrapNetConn(c)
return
}
// A zero timeout is no timeout. This will fallback onto the write ack
// timeout.
func (s *Socket) DialTimeout(addr string, timeout time.Duration) (nc net.Conn, err error) {
netAddr, err := s.resolveAddr(addr)
if err != nil {
return
}
mu.Lock()
c := s.newConn(netAddr)
c.recv_id = s.newConnID(resolvedAddrStr(netAddr.String()))
c.send_id = c.recv_id + 1
if logLevel >= 1 {
log.Printf("dial registering addr: %s", netAddr.String())
}
if !s.registerConn(c.recv_id, resolvedAddrStr(netAddr.String()), c) {
err = errors.New("couldn't register new connection")
log.Println(c.recv_id, netAddr.String())
for k, c := range s.conns {
log.Println(k, c, c.age())
}
log.Printf("that's %d connections", len(s.conns))
}
mu.Unlock()
if err != nil {
return
}
connErr := make(chan error, 1)
go func() {
connErr <- c.connect()
}()
var timeoutCh <-chan time.Time
if timeout != 0 {
timeoutCh = time.After(timeout)
}
select {
case err = <-connErr:
case <-timeoutCh:
err = errTimeout
}
if err != nil {
mu.Lock()
c.destroy(errors.New("dial timeout"))
mu.Unlock()
return
}
mu.Lock()
c.updateCanWrite()
mu.Unlock()
nc = pproffd.WrapNetConn(c)
return
}