code review 15080043: time: fix ParseDuration overflow when given more than 9...

src/pkg/time/format.go

 // Copyright 2010 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 time
 
 import "errors"
 
 // These are predefined layouts for use in Time.Format and Time.Parse.
 // The reference time used in the layouts is:
@@ skipping 1186 matching lines @@
 
                 // Consume (\.[0-9]*)?
                 post := false
                 if s != "" && s[0] == '.' {
                         s = s[1:]
                         pl := len(s)
                         x, s, err = leadingInt(s)
                         if err != nil {
                                 return 0, errors.New("time: invalid duration " + orig)
                         }
-                        scale := int64(1)

[rsc, 2013/10/18 17:26:36]

might as well do 1.0 (float64).
the int64 is good for 19 digits, the float64 is good for 22 digits, and the
float64 will degrade much better.

[minux1, 2013/10/20 01:20:45]

i originally used int64 because if scale can be represented in int64,
leadingInt(s) above would already give errors.

but then further testing that giving 19 digits after the decimal point is ok,
but even the int in amd64 can't handle it (so the issue is not specific to 386
anymore).

i also changed the test so that it would fail on amd64 without the fix.

+                        scale := 1.0
                         for n := pl - len(s); n > 0; n-- {
                                 scale *= 10
                         }
-                        g += float64(x) / float64(scale)
+                        g += float64(x) / scale
                         post = pl != len(s)
                 }
                 if !pre && !post {
                         // no digits (e.g. ".s" or "-.s")
                         return 0, errors.New("time: invalid duration " + orig)
                 }
 
                 // Consume unit.
                 i := 0
                 for ; i < len(s); i++ {
@@ skipping 13 matching lines @@
                 }
 
                 f += g * unit
         }
 
         if neg {
                 f = -f
         }
         return Duration(f), nil
 }