code review 11921043: go.crypto/ssh: add workaround for broken port forwarding in

ssh/tcpip.go

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package ssh
 
 import (
         "errors"
         "fmt"
         "io"
@@ skipping 26 matching lines @@
 
 // Automatic port allocation is broken with OpenSSH before 6.0. See
 // also https://bugzilla.mindrot.org/show_bug.cgi?id=2017.  In
 // particular, OpenSSH 5.9 sends a channelOpenMsg with port number 0,
 // rather than the actual port number. This means you can never open
 // two different listeners with auto allocated ports. We work around
 // this by trying explicit ports until we succeed.
 
 const openSSHPrefix = "OpenSSH_"
 
-func autoPortListenBroken(versionStr string) bool {
+// isBrokenOpenSSHVersion returns true if the given version string
+// specifies a version of OpenSSH that is known to have a bug in port
+// forwarding.
+func isBrokenOpenSSHVersion(versionStr string) bool {
         i := strings.Index(versionStr, openSSHPrefix)
         if i < 0 {
                 return false
         }
         i += len(openSSHPrefix)
         j := i
         for ; j < len(versionStr); j++ {
-                if versionStr[j] < '0' && versionStr[j] > '9' {
+                if versionStr[j] < '0' || versionStr[j] > '9' {
                         break
                 }
         }
+        fmt.Printf("V %q", versionStr[i:j])

[agl1, 2013/07/26 18:38:06]

Looks like debugging - will remove before landing.

         version, _ := strconv.Atoi(versionStr[i:j])
         return version < 6
 }
 
+// autoPortListenWorkaround simulates automatic port allocation by
+// trying random ports repeatedly.
 func (c *ClientConn) autoPortListenWorkaround(laddr *net.TCPAddr) (net.Listener, error) {
         var sshListener net.Listener
         var err error
         const tries = 10
         for i := 0; i < tries; i++ {
                 addr := *laddr
                 addr.Port = 1024 + rand.Intn(60000)
                 sshListener, err = c.ListenTCP(&addr)
                 if err == nil {
                         laddr.Port = addr.Port
                         return sshListener, err
                 }
         }
         return nil, fmt.Errorf("ssh: listen on random port failed after %d tries: %v", tries, err)
 }
 
 // ListenTCP requests the remote peer open a listening socket
 // on laddr. Incoming connections will be available by calling
 // Accept on the returned net.Listener.
 func (c *ClientConn) ListenTCP(laddr *net.TCPAddr) (net.Listener, error) {
-        if laddr.Port == 0 && autoPortListenBroken(c.serverVersion) {
+        if laddr.Port == 0 && isBrokenOpenSSHVersion(c.serverVersion) {
                 return c.autoPortListenWorkaround(laddr)
         }
 
         m := channelForwardMsg{
                 "tcpip-forward",
                 true, // sendGlobalRequest waits for a reply
                 laddr.IP.String(),
                 uint32(laddr.Port),
         }
         // send message
@@ skipping 241 matching lines @@
 // with Timeout() == true.
 func (t *tcpChanConn) SetReadDeadline(deadline time.Time) error {
         return errors.New("ssh: tcpChan: deadline not supported")
 }
 
 // SetWriteDeadline exists to satisfy the net.Conn interface
 // but is not implemented by this type.  It always returns an error.
 func (t *tcpChanConn) SetWriteDeadline(deadline time.Time) error {
         return errors.New("ssh: tcpChan: deadline not supported")
 }