code review 4607052: os.Error API: don't export os.ErrorString, use os.NewEr...

src/pkg/crypto/tls/handshake_client.go

 // Copyright 2009 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 tls
 
 import (
         "crypto"
         "crypto/rsa"
         "crypto/subtle"
@@ skipping 22 matching lines @@
         }
 
         t := uint32(c.config.time())
         hello.random[0] = byte(t >> 24)
         hello.random[1] = byte(t >> 16)
         hello.random[2] = byte(t >> 8)
         hello.random[3] = byte(t)
         _, err := io.ReadFull(c.config.rand(), hello.random[4:])
         if err != nil {
                 c.sendAlert(alertInternalError)
-                return os.ErrorString("short read from Rand")
+                return os.NewError("short read from Rand")
         }
 
         finishedHash.Write(hello.marshal())
         c.writeRecord(recordTypeHandshake, hello.marshal())
 
         msg, err := c.readHandshake()
         if err != nil {
                 return err
         }
         serverHello, ok := msg.(*serverHelloMsg)
         if !ok {
                 return c.sendAlert(alertUnexpectedMessage)
         }
         finishedHash.Write(serverHello.marshal())
 
         vers, ok := mutualVersion(serverHello.vers)
         if !ok {
                 return c.sendAlert(alertProtocolVersion)
         }
         c.vers = vers
         c.haveVers = true
 
         if serverHello.compressionMethod != compressionNone {
                 return c.sendAlert(alertUnexpectedMessage)
         }
 
         if !hello.nextProtoNeg && serverHello.nextProtoNeg {
                 c.sendAlert(alertHandshakeFailure)
-                return os.ErrorString("server advertised unrequested NPN")
+                return os.NewError("server advertised unrequested NPN")
         }
 
         suite, suiteId := mutualCipherSuite(c.config.cipherSuites(), serverHello.cipherSuite)
         if suite == nil {
                 return c.sendAlert(alertHandshakeFailure)
         }
 
         msg, err = c.readHandshake()
         if err != nil {
                 return err
         }
         certMsg, ok := msg.(*certificateMsg)
         if !ok || len(certMsg.certificates) == 0 {
                 return c.sendAlert(alertUnexpectedMessage)
         }
         finishedHash.Write(certMsg.marshal())
 
         certs := make([]*x509.Certificate, len(certMsg.certificates))
         for i, asn1Data := range certMsg.certificates {
                 cert, err := x509.ParseCertificate(asn1Data)
                 if err != nil {
                         c.sendAlert(alertBadCertificate)
-                        return os.ErrorString("failed to parse certificate from server: " + err.String())
+                        return os.NewError("failed to parse certificate from server: " + err.String())
                 }
                 certs[i] = cert
         }
 
         // If we don't have a root CA set configured then anything is accepted.
         // TODO(rsc): Find certificates for OS X 10.6.
         if c.config.RootCAs != nil {
                 opts := x509.VerifyOptions{
                         Roots:         c.config.RootCAs,
                         CurrentTime:   c.config.time(),
@@ skipping 200 matching lines @@
         for _, s := range serverProtos {
                 for _, c := range clientProtos {
                         if s == c {
                                 return s, false
                         }
                 }
         }
 
         return clientProtos[0], true
 }