github.com/sberex/go-sberex@v1.8.2-0.20181113200658-ed96ac38f7d7/whisper/whisperv6/peer.go (about) 1 // This file is part of the go-sberex library. The go-sberex library is 2 // free software: you can redistribute it and/or modify it under the terms 3 // of the GNU Lesser General Public License as published by the Free 4 // Software Foundation, either version 3 of the License, or (at your option) 5 // any later version. 6 // 7 // The go-sberex library is distributed in the hope that it will be useful, 8 // but WITHOUT ANY WARRANTY; without even the implied warranty of 9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser 10 // General Public License <http://www.gnu.org/licenses/> for more details. 11 12 package whisperv6 13 14 import ( 15 "fmt" 16 "math" 17 "sync" 18 "time" 19 20 "github.com/Sberex/go-sberex/common" 21 "github.com/Sberex/go-sberex/log" 22 "github.com/Sberex/go-sberex/p2p" 23 "github.com/Sberex/go-sberex/rlp" 24 set "gopkg.in/fatih/set.v0" 25 ) 26 27 // Peer represents a whisper protocol peer connection. 28 type Peer struct { 29 host *Whisper 30 peer *p2p.Peer 31 ws p2p.MsgReadWriter 32 33 trusted bool 34 powRequirement float64 35 bloomMu sync.Mutex 36 bloomFilter []byte 37 fullNode bool 38 39 known *set.Set // Messages already known by the peer to avoid wasting bandwidth 40 41 quit chan struct{} 42 } 43 44 // newPeer creates a new whisper peer object, but does not run the handshake itself. 45 func newPeer(host *Whisper, remote *p2p.Peer, rw p2p.MsgReadWriter) *Peer { 46 return &Peer{ 47 host: host, 48 peer: remote, 49 ws: rw, 50 trusted: false, 51 powRequirement: 0.0, 52 known: set.New(), 53 quit: make(chan struct{}), 54 bloomFilter: makeFullNodeBloom(), 55 fullNode: true, 56 } 57 } 58 59 // start initiates the peer updater, periodically broadcasting the whisper packets 60 // into the network. 61 func (peer *Peer) start() { 62 go peer.update() 63 log.Trace("start", "peer", peer.ID()) 64 } 65 66 // stop terminates the peer updater, stopping message forwarding to it. 67 func (peer *Peer) stop() { 68 close(peer.quit) 69 log.Trace("stop", "peer", peer.ID()) 70 } 71 72 // handshake sends the protocol initiation status message to the remote peer and 73 // verifies the remote status too. 74 func (peer *Peer) handshake() error { 75 // Send the handshake status message asynchronously 76 errc := make(chan error, 1) 77 go func() { 78 pow := peer.host.MinPow() 79 powConverted := math.Float64bits(pow) 80 bloom := peer.host.BloomFilter() 81 errc <- p2p.SendItems(peer.ws, statusCode, ProtocolVersion, powConverted, bloom) 82 }() 83 84 // Fetch the remote status packet and verify protocol match 85 packet, err := peer.ws.ReadMsg() 86 if err != nil { 87 return err 88 } 89 if packet.Code != statusCode { 90 return fmt.Errorf("peer [%x] sent packet %x before status packet", peer.ID(), packet.Code) 91 } 92 s := rlp.NewStream(packet.Payload, uint64(packet.Size)) 93 _, err = s.List() 94 if err != nil { 95 return fmt.Errorf("peer [%x] sent bad status message: %v", peer.ID(), err) 96 } 97 peerVersion, err := s.Uint() 98 if err != nil { 99 return fmt.Errorf("peer [%x] sent bad status message (unable to decode version): %v", peer.ID(), err) 100 } 101 if peerVersion != ProtocolVersion { 102 return fmt.Errorf("peer [%x]: protocol version mismatch %d != %d", peer.ID(), peerVersion, ProtocolVersion) 103 } 104 105 // only version is mandatory, subsequent parameters are optional 106 powRaw, err := s.Uint() 107 if err == nil { 108 pow := math.Float64frombits(powRaw) 109 if math.IsInf(pow, 0) || math.IsNaN(pow) || pow < 0.0 { 110 return fmt.Errorf("peer [%x] sent bad status message: invalid pow", peer.ID()) 111 } 112 peer.powRequirement = pow 113 114 var bloom []byte 115 err = s.Decode(&bloom) 116 if err == nil { 117 sz := len(bloom) 118 if sz != bloomFilterSize && sz != 0 { 119 return fmt.Errorf("peer [%x] sent bad status message: wrong bloom filter size %d", peer.ID(), sz) 120 } 121 peer.setBloomFilter(bloom) 122 } 123 } 124 125 if err := <-errc; err != nil { 126 return fmt.Errorf("peer [%x] failed to send status packet: %v", peer.ID(), err) 127 } 128 return nil 129 } 130 131 // update executes periodic operations on the peer, including message transmission 132 // and expiration. 133 func (peer *Peer) update() { 134 // Start the tickers for the updates 135 expire := time.NewTicker(expirationCycle) 136 transmit := time.NewTicker(transmissionCycle) 137 138 // Loop and transmit until termination is requested 139 for { 140 select { 141 case <-expire.C: 142 peer.expire() 143 144 case <-transmit.C: 145 if err := peer.broadcast(); err != nil { 146 log.Trace("broadcast failed", "reason", err, "peer", peer.ID()) 147 return 148 } 149 150 case <-peer.quit: 151 return 152 } 153 } 154 } 155 156 // mark marks an envelope known to the peer so that it won't be sent back. 157 func (peer *Peer) mark(envelope *Envelope) { 158 peer.known.Add(envelope.Hash()) 159 } 160 161 // marked checks if an envelope is already known to the remote peer. 162 func (peer *Peer) marked(envelope *Envelope) bool { 163 return peer.known.Has(envelope.Hash()) 164 } 165 166 // expire iterates over all the known envelopes in the host and removes all 167 // expired (unknown) ones from the known list. 168 func (peer *Peer) expire() { 169 unmark := make(map[common.Hash]struct{}) 170 peer.known.Each(func(v interface{}) bool { 171 if !peer.host.isEnvelopeCached(v.(common.Hash)) { 172 unmark[v.(common.Hash)] = struct{}{} 173 } 174 return true 175 }) 176 // Dump all known but no longer cached 177 for hash := range unmark { 178 peer.known.Remove(hash) 179 } 180 } 181 182 // broadcast iterates over the collection of envelopes and transmits yet unknown 183 // ones over the network. 184 func (peer *Peer) broadcast() error { 185 envelopes := peer.host.Envelopes() 186 bundle := make([]*Envelope, 0, len(envelopes)) 187 for _, envelope := range envelopes { 188 if !peer.marked(envelope) && envelope.PoW() >= peer.powRequirement && peer.bloomMatch(envelope) { 189 bundle = append(bundle, envelope) 190 } 191 } 192 193 if len(bundle) > 0 { 194 // transmit the batch of envelopes 195 if err := p2p.Send(peer.ws, messagesCode, bundle); err != nil { 196 return err 197 } 198 199 // mark envelopes only if they were successfully sent 200 for _, e := range bundle { 201 peer.mark(e) 202 } 203 204 log.Trace("broadcast", "num. messages", len(bundle)) 205 } 206 return nil 207 } 208 209 // ID returns a peer's id 210 func (peer *Peer) ID() []byte { 211 id := peer.peer.ID() 212 return id[:] 213 } 214 215 func (peer *Peer) notifyAboutPowRequirementChange(pow float64) error { 216 i := math.Float64bits(pow) 217 return p2p.Send(peer.ws, powRequirementCode, i) 218 } 219 220 func (peer *Peer) notifyAboutBloomFilterChange(bloom []byte) error { 221 return p2p.Send(peer.ws, bloomFilterExCode, bloom) 222 } 223 224 func (peer *Peer) bloomMatch(env *Envelope) bool { 225 peer.bloomMu.Lock() 226 defer peer.bloomMu.Unlock() 227 return peer.fullNode || bloomFilterMatch(peer.bloomFilter, env.Bloom()) 228 } 229 230 func (peer *Peer) setBloomFilter(bloom []byte) { 231 peer.bloomMu.Lock() 232 defer peer.bloomMu.Unlock() 233 peer.bloomFilter = bloom 234 peer.fullNode = isFullNode(bloom) 235 if peer.fullNode && peer.bloomFilter == nil { 236 peer.bloomFilter = makeFullNodeBloom() 237 } 238 } 239 240 func makeFullNodeBloom() []byte { 241 bloom := make([]byte, bloomFilterSize) 242 for i := 0; i < bloomFilterSize; i++ { 243 bloom[i] = 0xFF 244 } 245 return bloom 246 }