windows: fix filetime conversions and deprecate Nanoseconds

Filetime.Nanoseconds() has a major drawback: the returned int64 is too
small to represent Filetime's zero value (January 1, 1601) in terms of
nanoseconds since Epoch (00:00:00 UTC, January 1, 1970); MinInt64 only dates
back to year 1677.

This has real-life implications, e.g., some Windows sub systems
(Perflib, to name one) create registry keys with the last write time
property set to zero. In this case, ModTime() reports an
underflow-affected value of 2185-07-22T00:34:33.709551+01:00.

This commit deprecates Nanoseconds() in favor of the new Unix() that
returns a well-known pair of seconds and nanoseconds thus is capable to
cover the full range of Filetime values. ModTime() uses Unix()
accordingly to produce correct time.Time values again. Additionally,
ModTimeZero() provides a convenient way to check for a last write
time value of zero in analogy to time.Time.IsZero(); no need to specify
January 1, 1601 manually.

Author: gremat

windows/registry/key.go

@@ -26,6 +26,8 @@ import (
 	"runtime"
 	"syscall"
 	"time"
+
+	"golang.org/x/sys/windows"
 )
 
 const (
@@ -193,18 +195,23 @@ type KeyInfo struct {
 	ValueCount      uint32
 	MaxValueNameLen uint32 // size of the key's longest value name, in Unicode characters, not including the terminating zero byte
 	MaxValueLen     uint32 // longest data component among the key's values, in bytes
-	lastWriteTime   syscall.Filetime
+	lastWriteTime   windows.Filetime
 }
 
 // ModTime returns the key's last write time.
 func (ki *KeyInfo) ModTime() time.Time {
-	return time.Unix(0, ki.lastWriteTime.Nanoseconds())
+	return time.Unix(ki.lastWriteTime.Unix())
+}
+
+// ModTimeZero reports whether the key's last write time is zero.
+func (ki *KeyInfo) ModTimeZero() bool {
+	return ki.lastWriteTime.LowDateTime == 0 && ki.lastWriteTime.HighDateTime == 0
 }
 
 // Stat retrieves information about the open key k.
 func (k Key) Stat() (*KeyInfo, error) {
 	var ki KeyInfo
-	err := syscall.RegQueryInfoKey(syscall.Handle(k), nil, nil, nil,
+	err := windows.RegQueryInfoKey(windows.Handle(k), nil, nil, nil,
 		&ki.SubKeyCount, &ki.MaxSubKeyLen, nil, &ki.ValueCount,
 		&ki.MaxValueNameLen, &ki.MaxValueLen, nil, &ki.lastWriteTime)
 	if err != nil {

windows/syscall_windows.go

@@ -738,7 +738,7 @@ func Ftruncate(fd Handle, length int64) (err error) {
 func Gettimeofday(tv *Timeval) (err error) {
 	var ft Filetime
 	GetSystemTimeAsFileTime(&ft)
-	*tv = NsecToTimeval(ft.Nanoseconds())
+	*tv = FiletimeToTimeval(ft)
 	return nil
 }
 
@@ -771,8 +771,8 @@ func Utimes(path string, tv []Timeval) (err error) {
 		return e
 	}
 	defer CloseHandle(h)
-	a := NsecToFiletime(tv[0].Nanoseconds())
-	w := NsecToFiletime(tv[1].Nanoseconds())
+	a := TimevalToFiletime(tv[0])
+	w := TimevalToFiletime(tv[1])
 	return SetFileTime(h, nil, &a, &w)
 }
 

windows/types_windows.go

@@ -763,10 +763,33 @@ func (tv *Timeval) Nanoseconds() int64 {
 	return (int64(tv.Sec)*1e6 + int64(tv.Usec)) * 1e3
 }
 
+func TimevalToFiletime(tv Timeval) Filetime {
+	// Convert to 100-nanosecond intervals
+	hsec := uint64(tv.Sec)*1e7 + uint64(tv.Usec)/100
+	// Change starting time to January 1, 1601
+	// Note: No overflow here (11644473600*1e7 < math.MaxUint64/1e2)
+	hsec += 116444736000000000
+	// Split into high / low.
+	return Filetime{
+		LowDateTime:  uint32(hsec & 0xffffffff),
+		HighDateTime: uint32(hsec >> 32 & 0xffffffff),
+	}
+}
+
+// NsecToTimeval converts a nanosecond value nsec to a Timeval tv. The result is
+// undefined if the nanosecond value cannot be represented by a Timeval (values
+// equivalent to dates before the year 1901 or after the year 2038).
 func NsecToTimeval(nsec int64) (tv Timeval) {
-	tv.Sec = int32(nsec / 1e9)
-	tv.Usec = int32(nsec % 1e9 / 1e3)
-	return
+	// Ignore overflow (math.MaxInt64/1e9 > math.MaxInt32)
+	sec := int32(nsec / 1e9)
+	usec := int32(nsec % 1e9 / 1e3)
+	if usec < 0 {
+		usec += 1e6
+		sec--
+	}
+	tv.Sec = sec
+	tv.Usec = usec
+	return tv
 }
 
 type Overlapped struct {
@@ -789,22 +812,48 @@ type Filetime struct {
 	HighDateTime uint32
 }
 
-// Nanoseconds returns Filetime ft in nanoseconds
+// Unix returns ft in seconds and nanoseconds
 // since Epoch (00:00:00 UTC, January 1, 1970).
-func (ft *Filetime) Nanoseconds() int64 {
+func (ft *Filetime) Unix() (sec, nsec int64) {
 	// 100-nanosecond intervals since January 1, 1601
-	nsec := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime)
-	// change starting time to the Epoch (00:00:00 UTC, January 1, 1970)
-	nsec -= 116444736000000000
-	// convert into nanoseconds
-	nsec *= 100
-	return nsec
+	hsec := uint64(ft.HighDateTime)<<32 + uint64(ft.LowDateTime)
+	// Convert _before_ gauging; the nanosecond difference between Epoch (00:00:00
+	// UTC, January 1, 1970) and Filetime's zero offset (January 1, 1601) is out
+	// of bounds for int64: -11644473600*1e7*1e2 < math.MinInt64
+	sec = int64(hsec/1e7) - 11644473600
+	nsec = int64(hsec%1e7) * 100
+	return sec, nsec
+}
+
+// Nanoseconds returns ft in nanoseconds since Epoch (00:00:00 UTC,
+// January 1, 1970). The result is undefined if the Filetime cannot be
+// represented by an int64 (values equivalent to dates before the year
+// 1677 or after the year 2262). Note that this explicitly excludes the
+// zero value of Filetime, which is equivalent to January 1, 1601.
+//
+// Deprecated: use Unix instead, which returns both seconds and
+// nanoseconds thus covers the full available range of Filetime.
+func (ft *Filetime) Nanoseconds() int64 {
+	sec, nsec := ft.Unix()
+	return (sec*1e9 + nsec)
+}
+
+// FiletimeToTimeval converts a Filetime ft to a Timeval tv. The result is
+// undefined if the Filetime cannot be represented by a Timeval (values
+// equivalent to dates before the year 1901 or after the year 2038).
+func FiletimeToTimeval(ft Filetime) (tv Timeval) {
+	sec, nsec := ft.Unix()
+	// Ignore overflow (math.MaxUint64*1e2/1e9 > math.MaxInt32)
+	tv.Sec = int32(sec)
+	tv.Usec = int32(nsec / 1e3)
+	return tv
 }
 
 func NsecToFiletime(nsec int64) (ft Filetime) {
 	// convert into 100-nanosecond
 	nsec /= 100
 	// change starting time to January 1, 1601
+	// note: no overflow here (11644473600*1e7 < math.MaxInt64/1e1)
 	nsec += 116444736000000000
 	// split into high / low
 	ft.LowDateTime = uint32(nsec & 0xffffffff)