From: Matt Joiner Date: Wed, 8 Nov 2017 04:00:18 +0000 (+1100) Subject: Move some code around X-Git-Tag: v1.0.0~340 X-Git-Url: http://www.git.stargrave.org/?a=commitdiff_plain;h=7eb62eec0df0f58b192e96f90470a890287da4dd;p=btrtrc.git Move some code around --- diff --git a/client.go b/client.go index 47d3b54b..1779c289 100644 --- a/client.go +++ b/client.go @@ -2,10 +2,8 @@ package torrent import ( "bufio" - "bytes" "context" "crypto/rand" - "encoding/hex" "errors" "expvar" "fmt" @@ -711,187 +709,6 @@ func (cl *Client) incomingPeerPort() int { return port } -// Convert a net.Addr to its compact IP representation. Either 4 or 16 bytes -// per "yourip" field of http://www.bittorrent.org/beps/bep_0010.html. -func addrCompactIP(addr net.Addr) (string, error) { - host, _, err := net.SplitHostPort(addr.String()) - if err != nil { - return "", err - } - ip := net.ParseIP(host) - if v4 := ip.To4(); v4 != nil { - if len(v4) != 4 { - panic(v4) - } - return string(v4), nil - } - return string(ip.To16()), nil -} - -func handshakeWriter(w io.Writer, bb <-chan []byte, done chan<- error) { - var err error - for b := range bb { - _, err = w.Write(b) - if err != nil { - break - } - } - done <- err -} - -type ( - peerExtensionBytes [8]byte - peerID [20]byte -) - -func (pex *peerExtensionBytes) SupportsExtended() bool { - return pex[5]&0x10 != 0 -} - -func (pex *peerExtensionBytes) SupportsDHT() bool { - return pex[7]&0x01 != 0 -} - -func (pex *peerExtensionBytes) SupportsFast() bool { - return pex[7]&0x04 != 0 -} - -type handshakeResult struct { - peerExtensionBytes - peerID - metainfo.Hash -} - -// ih is nil if we expect the peer to declare the InfoHash, such as when the -// peer initiated the connection. Returns ok if the handshake was successful, -// and err if there was an unexpected condition other than the peer simply -// abandoning the handshake. -func handshake(sock io.ReadWriter, ih *metainfo.Hash, peerID [20]byte, extensions peerExtensionBytes) (res handshakeResult, ok bool, err error) { - // Bytes to be sent to the peer. Should never block the sender. - postCh := make(chan []byte, 4) - // A single error value sent when the writer completes. - writeDone := make(chan error, 1) - // Performs writes to the socket and ensures posts don't block. - go handshakeWriter(sock, postCh, writeDone) - - defer func() { - close(postCh) // Done writing. - if !ok { - return - } - if err != nil { - panic(err) - } - // Wait until writes complete before returning from handshake. - err = <-writeDone - if err != nil { - err = fmt.Errorf("error writing: %s", err) - } - }() - - post := func(bb []byte) { - select { - case postCh <- bb: - default: - panic("mustn't block while posting") - } - } - - post([]byte(pp.Protocol)) - post(extensions[:]) - if ih != nil { // We already know what we want. - post(ih[:]) - post(peerID[:]) - } - var b [68]byte - _, err = io.ReadFull(sock, b[:68]) - if err != nil { - err = nil - return - } - if string(b[:20]) != pp.Protocol { - return - } - missinggo.CopyExact(&res.peerExtensionBytes, b[20:28]) - missinggo.CopyExact(&res.Hash, b[28:48]) - missinggo.CopyExact(&res.peerID, b[48:68]) - peerExtensions.Add(hex.EncodeToString(res.peerExtensionBytes[:]), 1) - - // TODO: Maybe we can just drop peers here if we're not interested. This - // could prevent them trying to reconnect, falsely believing there was - // just a problem. - if ih == nil { // We were waiting for the peer to tell us what they wanted. - post(res.Hash[:]) - post(peerID[:]) - } - - ok = true - return -} - -// Wraps a raw connection and provides the interface we want for using the -// connection in the message loop. -type deadlineReader struct { - nc net.Conn - r io.Reader -} - -func (r deadlineReader) Read(b []byte) (int, error) { - // Keep-alives should be received every 2 mins. Give a bit of gracetime. - err := r.nc.SetReadDeadline(time.Now().Add(150 * time.Second)) - if err != nil { - return 0, fmt.Errorf("error setting read deadline: %s", err) - } - return r.r.Read(b) -} - -func handleEncryption( - rw io.ReadWriter, - skeys mse.SecretKeyIter, - policy EncryptionPolicy, -) ( - ret io.ReadWriter, - headerEncrypted bool, - cryptoMethod uint32, - err error, -) { - if !policy.ForceEncryption { - var protocol [len(pp.Protocol)]byte - _, err = io.ReadFull(rw, protocol[:]) - if err != nil { - return - } - rw = struct { - io.Reader - io.Writer - }{ - io.MultiReader(bytes.NewReader(protocol[:]), rw), - rw, - } - if string(protocol[:]) == pp.Protocol { - ret = rw - return - } - } - headerEncrypted = true - ret, err = mse.ReceiveHandshake(rw, skeys, func(provides uint32) uint32 { - cryptoMethod = func() uint32 { - switch { - case policy.ForceEncryption: - return mse.CryptoMethodRC4 - case policy.DisableEncryption: - return mse.CryptoMethodPlaintext - case policy.PreferNoEncryption && provides&mse.CryptoMethodPlaintext != 0: - return mse.CryptoMethodPlaintext - default: - return mse.DefaultCryptoSelector(provides) - } - }() - return cryptoMethod - }) - return -} - func (cl *Client) initiateHandshakes(c *connection, t *Torrent) (ok bool, err error) { if c.headerEncrypted { var rw io.ReadWriter diff --git a/handshake.go b/handshake.go new file mode 100644 index 00000000..b79b5fd6 --- /dev/null +++ b/handshake.go @@ -0,0 +1,180 @@ +package torrent + +import ( + "bytes" + "encoding/hex" + "fmt" + "io" + "net" + "time" + + pp "github.com/anacrolix/torrent/peer_protocol" + + "github.com/anacrolix/missinggo" + "github.com/anacrolix/torrent/metainfo" + "github.com/anacrolix/torrent/mse" +) + +func handshakeWriter(w io.Writer, bb <-chan []byte, done chan<- error) { + var err error + for b := range bb { + _, err = w.Write(b) + if err != nil { + break + } + } + done <- err +} + +type ( + peerExtensionBytes [8]byte + peerID [20]byte +) + +func (pex *peerExtensionBytes) SupportsExtended() bool { + return pex[5]&0x10 != 0 +} + +func (pex *peerExtensionBytes) SupportsDHT() bool { + return pex[7]&0x01 != 0 +} + +func (pex *peerExtensionBytes) SupportsFast() bool { + return pex[7]&0x04 != 0 +} + +type handshakeResult struct { + peerExtensionBytes + peerID + metainfo.Hash +} + +// ih is nil if we expect the peer to declare the InfoHash, such as when the +// peer initiated the connection. Returns ok if the handshake was successful, +// and err if there was an unexpected condition other than the peer simply +// abandoning the handshake. +func handshake(sock io.ReadWriter, ih *metainfo.Hash, peerID [20]byte, extensions peerExtensionBytes) (res handshakeResult, ok bool, err error) { + // Bytes to be sent to the peer. Should never block the sender. + postCh := make(chan []byte, 4) + // A single error value sent when the writer completes. + writeDone := make(chan error, 1) + // Performs writes to the socket and ensures posts don't block. + go handshakeWriter(sock, postCh, writeDone) + + defer func() { + close(postCh) // Done writing. + if !ok { + return + } + if err != nil { + panic(err) + } + // Wait until writes complete before returning from handshake. + err = <-writeDone + if err != nil { + err = fmt.Errorf("error writing: %s", err) + } + }() + + post := func(bb []byte) { + select { + case postCh <- bb: + default: + panic("mustn't block while posting") + } + } + + post([]byte(pp.Protocol)) + post(extensions[:]) + if ih != nil { // We already know what we want. + post(ih[:]) + post(peerID[:]) + } + var b [68]byte + _, err = io.ReadFull(sock, b[:68]) + if err != nil { + err = nil + return + } + if string(b[:20]) != pp.Protocol { + return + } + missinggo.CopyExact(&res.peerExtensionBytes, b[20:28]) + missinggo.CopyExact(&res.Hash, b[28:48]) + missinggo.CopyExact(&res.peerID, b[48:68]) + peerExtensions.Add(hex.EncodeToString(res.peerExtensionBytes[:]), 1) + + // TODO: Maybe we can just drop peers here if we're not interested. This + // could prevent them trying to reconnect, falsely believing there was + // just a problem. + if ih == nil { // We were waiting for the peer to tell us what they wanted. + post(res.Hash[:]) + post(peerID[:]) + } + + ok = true + return +} + +// Wraps a raw connection and provides the interface we want for using the +// connection in the message loop. +type deadlineReader struct { + nc net.Conn + r io.Reader +} + +func (r deadlineReader) Read(b []byte) (int, error) { + // Keep-alives should be received every 2 mins. Give a bit of gracetime. + err := r.nc.SetReadDeadline(time.Now().Add(150 * time.Second)) + if err != nil { + return 0, fmt.Errorf("error setting read deadline: %s", err) + } + return r.r.Read(b) +} + +func handleEncryption( + rw io.ReadWriter, + skeys mse.SecretKeyIter, + policy EncryptionPolicy, +) ( + ret io.ReadWriter, + headerEncrypted bool, + cryptoMethod uint32, + err error, +) { + if !policy.ForceEncryption { + var protocol [len(pp.Protocol)]byte + _, err = io.ReadFull(rw, protocol[:]) + if err != nil { + return + } + rw = struct { + io.Reader + io.Writer + }{ + io.MultiReader(bytes.NewReader(protocol[:]), rw), + rw, + } + if string(protocol[:]) == pp.Protocol { + ret = rw + return + } + } + headerEncrypted = true + ret, err = mse.ReceiveHandshake(rw, skeys, func(provides uint32) uint32 { + cryptoMethod = func() uint32 { + switch { + case policy.ForceEncryption: + return mse.CryptoMethodRC4 + case policy.DisableEncryption: + return mse.CryptoMethodPlaintext + case policy.PreferNoEncryption && provides&mse.CryptoMethodPlaintext != 0: + return mse.CryptoMethodPlaintext + default: + return mse.DefaultCryptoSelector(provides) + } + }() + return cryptoMethod + }) + return +} diff --git a/misc.go b/misc.go index 9d26738c..6ff47775 100644 --- a/misc.go +++ b/misc.go @@ -2,6 +2,7 @@ package torrent import ( "errors" + "net" "github.com/anacrolix/torrent/metainfo" pp "github.com/anacrolix/torrent/peer_protocol" @@ -85,3 +86,20 @@ func chunkIndexSpec(index int, pieceLength, chunkSize pp.Integer) chunkSpec { func connLessTrusted(l, r *connection) bool { return l.netGoodPiecesDirtied() < r.netGoodPiecesDirtied() } + +// Convert a net.Addr to its compact IP representation. Either 4 or 16 bytes +// per "yourip" field of http://www.bittorrent.org/beps/bep_0010.html. +func addrCompactIP(addr net.Addr) (string, error) { + host, _, err := net.SplitHostPort(addr.String()) + if err != nil { + return "", err + } + ip := net.ParseIP(host) + if v4 := ip.To4(); v4 != nil { + if len(v4) != 4 { + panic(v4) + } + return string(v4), nil + } + return string(ip.To16()), nil +}