@ -1,15 +1,11 @@
package p2p
import (
"bufio"
"bytes"
"encoding/binary"
"errors"
"fmt"
"io"
"io/ioutil"
"math/big"
"net"
"sync"
"sync/atomic"
"time"
@ -138,140 +134,6 @@ func (rw *lockedRW) WriteMsg(msg Msg) error {
return rw . wrapped . WriteMsg ( msg )
}
// frameRW is a MsgReadWriter that reads and writes devp2p message frames.
// As required by the interface, ReadMsg and WriteMsg can be called from
// multiple goroutines.
type frameRW struct {
net . Conn // make Conn methods available. be careful.
bufconn * bufio . ReadWriter
// this channel is used to 'lend' bufconn to a caller of ReadMsg
// until the message payload has been consumed. the channel
// receives a value when EOF is reached on the payload, unblocking
// a pending call to ReadMsg.
rsync chan struct { }
// this mutex guards writes to bufconn.
writeMu sync . Mutex
}
func newFrameRW ( conn net . Conn , timeout time . Duration ) * frameRW {
rsync := make ( chan struct { } , 1 )
rsync <- struct { } { }
return & frameRW {
Conn : conn ,
bufconn : bufio . NewReadWriter ( bufio . NewReader ( conn ) , bufio . NewWriter ( conn ) ) ,
rsync : rsync ,
}
}
var magicToken = [ ] byte { 34 , 64 , 8 , 145 }
func ( rw * frameRW ) WriteMsg ( msg Msg ) error {
rw . writeMu . Lock ( )
defer rw . writeMu . Unlock ( )
rw . SetWriteDeadline ( time . Now ( ) . Add ( msgWriteTimeout ) )
if err := writeMsg ( rw . bufconn , msg ) ; err != nil {
return err
}
return rw . bufconn . Flush ( )
}
func writeMsg ( w io . Writer , msg Msg ) error {
// TODO: handle case when Size + len(code) + len(listhdr) overflows uint32
code := ethutil . Encode ( uint32 ( msg . Code ) )
listhdr := makeListHeader ( msg . Size + uint32 ( len ( code ) ) )
payloadLen := uint32 ( len ( listhdr ) ) + uint32 ( len ( code ) ) + msg . Size
start := make ( [ ] byte , 8 )
copy ( start , magicToken )
binary . BigEndian . PutUint32 ( start [ 4 : ] , payloadLen )
for _ , b := range [ ] [ ] byte { start , listhdr , code } {
if _ , err := w . Write ( b ) ; err != nil {
return err
}
}
_ , err := io . CopyN ( w , msg . Payload , int64 ( msg . Size ) )
return err
}
func makeListHeader ( length uint32 ) [ ] byte {
if length < 56 {
return [ ] byte { byte ( length + 0xc0 ) }
}
enc := big . NewInt ( int64 ( length ) ) . Bytes ( )
lenb := byte ( len ( enc ) ) + 0xf7
return append ( [ ] byte { lenb } , enc ... )
}
func ( rw * frameRW ) ReadMsg ( ) ( msg Msg , err error ) {
<- rw . rsync // wait until bufconn is ours
rw . SetReadDeadline ( time . Now ( ) . Add ( frameReadTimeout ) )
// read magic and payload size
start := make ( [ ] byte , 8 )
if _ , err = io . ReadFull ( rw . bufconn , start ) ; err != nil {
return msg , err
}
if ! bytes . HasPrefix ( start , magicToken ) {
return msg , fmt . Errorf ( "bad magic token %x" , start [ : 4 ] )
}
size := binary . BigEndian . Uint32 ( start [ 4 : ] )
// decode start of RLP message to get the message code
posr := & postrack { rw . bufconn , 0 }
s := rlp . NewStream ( posr )
if _ , err := s . List ( ) ; err != nil {
return msg , err
}
msg . Code , err = s . Uint ( )
if err != nil {
return msg , err
}
msg . Size = size - posr . p
rw . SetReadDeadline ( time . Now ( ) . Add ( payloadReadTimeout ) )
if msg . Size <= wholePayloadSize {
// msg is small, read all of it and move on to the next message.
pbuf := make ( [ ] byte , msg . Size )
if _ , err := io . ReadFull ( rw . bufconn , pbuf ) ; err != nil {
return msg , err
}
rw . rsync <- struct { } { } // bufconn is available again
msg . Payload = bytes . NewReader ( pbuf )
} else {
// lend bufconn to the caller until it has
// consumed the payload. eofSignal will send a value
// on rw.rsync when EOF is reached.
pr := & eofSignal { rw . bufconn , msg . Size , rw . rsync }
msg . Payload = pr
}
return msg , nil
}
// postrack wraps an rlp.ByteReader with a position counter.
type postrack struct {
r rlp . ByteReader
p uint32
}
func ( r * postrack ) Read ( buf [ ] byte ) ( int , error ) {
n , err := r . r . Read ( buf )
r . p += uint32 ( n )
return n , err
}
func ( r * postrack ) ReadByte ( ) ( byte , error ) {
b , err := r . r . ReadByte ( )
if err == nil {
r . p ++
}
return b , err
}
// eofSignal wraps a reader with eof signaling. the eof channel is
// closed when the wrapped reader returns an error or when count bytes
// have been read.
Felix Lange
10 years ago