addressed CR by @jbenet
Henry committed
Oct 16, 2014 at 14:07 UTC
0f47b9300554b78dddd714d521ed8b0de769d569
2 files changed
+31
-48
net/handshake/version.go
+6
-4
@@ -4,7 +4,9 @@ import (
4
"errors"
5
"fmt"
6
7
- "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/coreos/go-semver/semver"
7
+ updates "github.com/jbenet/go-ipfs/updates"
8
+
9
+ semver "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/coreos/go-semver/semver"
10
)
11
12
// currentVersion holds the current protocol version for a client running this code
@@ -18,9 +20,9 @@ func init() {
20
}
21
}
22
21
-// Current returns the current protocol version as a protobuf message
22
-func Current() *semver.Version {
23
- return currentVersion
23
+// CurrentHandshake returns the current protocol version as a protobuf message
24
+func CurrentHandshake() *Handshake1 {
25
+ return NewHandshake1(currentVersion.String(), "go-ipfs/"+updates.Version)
26
}
27
28
// ErrVersionMismatch is returned when two clients don't share a protocol version
net/swarm/conn.go
+25
-44
@@ -161,63 +161,44 @@ func (s *Swarm) connSecure(c *conn.Conn) error {
161
// connVersionExchange exchanges local and remote versions and compares them
162
// closes remote and returns an error in case of major difference
163
func (s *Swarm) connVersionExchange(remote *conn.Conn) error {
164
- var remoteVersion, myVersion *handshake.SemVer
165
- myVersion = handshake.Current()
164
+ var remoteHandshake, localHandshake *handshake.Handshake1
165
+ localHandshake = handshake.CurrentHandshake()
166
167
- // BUG(cryptix): do we need to use a NetMessage here?
168
- myVersionMsg, err := msg.FromObject(s.local, myVersion)
167
+ myVerBytes, err := proto.Marshal(localHandshake)
168
if err != nil {
170
- return fmt.Errorf("connVersionExchange: could not prepare local version: %q", err)
169
+ return err
170
}
171
173
- // buffered channel to send our version just once
174
- outBuf := make(chan []byte, 1)
175
- outBuf <- myVersionMsg.Data()
172
+ remote.Secure.Out <- myVerBytes
173
177
- var gotTheirs, sendMine bool
178
- for {
179
- if gotTheirs && sendMine {
180
- break
181
- }
174
+ log.Debug("Send my version(%s) [to = %s]", localHandshake, remote.Peer)
175
183
- select {
184
- case <-s.ctx.Done():
185
- // close Conn.
186
- remote.Close()
187
- return nil // BUG(cryptix): should this be an error?
188
-
189
- case <-remote.Closed:
190
- return errors.New("remote closed connection during version exchange")
191
-
192
- case our, ok := <-outBuf:
193
- if ok {
194
- remote.Secure.Out <- our
195
- sendMine = true
196
- close(outBuf) // only send local version once
197
- log.Debug("Send my version(%s) [to = %s]", myVersion, remote.Peer)
198
- }
176
+ select {
177
+ case <-s.ctx.Done():
178
+ return s.ctx.Err()
179
200
- case data, ok := <-remote.Secure.In:
201
- if !ok {
202
- return fmt.Errorf("Error retrieving from conn: %v", remote.Peer)
203
- }
180
+ case <-remote.Closed:
181
+ return errors.New("remote closed connection during version exchange")
182
205
- remoteVersion = new(handshake.SemVer)
206
- err = proto.Unmarshal(data, remoteVersion)
207
- if err != nil {
208
- s.Close()
209
- return fmt.Errorf("connSetup: could not decode remote version: %q", err)
210
- }
211
- gotTheirs = true
212
- log.Debug("Received remote version(%s) [from = %s]", remoteVersion, remote.Peer)
183
+ case data, ok := <-remote.Secure.In:
184
+ if !ok {
185
+ return fmt.Errorf("Error retrieving from conn: %v", remote.Peer)
186
+ }
187
214
- // BUG(cryptix): could add another case here to trigger resending our version
188
+ remoteHandshake = new(handshake.Handshake1)
189
+ err = proto.Unmarshal(data, remoteHandshake)
190
+ if err != nil {
191
+ s.Close()
192
+ return fmt.Errorf("connSetup: could not decode remote version: %q", err)
193
}
194
+
195
+ log.Debug("Received remote version(%s) [from = %s]", remoteHandshake, remote.Peer)
196
}
197
218
- if !handshake.Compatible(myVersion, remoteVersion) {
198
+ if err := handshake.Compatible(localHandshake, remoteHandshake); err != nil {
199
+ log.Info("%s (%s) incompatible version with %s (%s)", s.local, localHandshake, remote.Peer, remoteHandshake)
200
remote.Close()
220
- return handshake.ErrVersionMismatch
201
+ return err
202
}
203
204
log.Debug("[peer: %s] Version compatible", remote.Peer)