123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242 |
- // 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 time
- import (
- "errors"
- "internal/syscall/windows/registry"
- "runtime"
- "syscall"
- )
- var zoneSources = []string{
- runtime.GOROOT() + "/lib/time/zoneinfo.zip",
- }
- // TODO(rsc): Fall back to copy of zoneinfo files.
- // BUG(brainman,rsc): On Windows, the operating system does not provide complete
- // time zone information.
- // The implementation assumes that this year's rules for daylight savings
- // time apply to all previous and future years as well.
- // matchZoneKey checks if stdname and dstname match the corresponding key
- // values "MUI_Std" and MUI_Dlt" or "Std" and "Dlt" (the latter down-level
- // from Vista) in the kname key stored under the open registry key zones.
- func matchZoneKey(zones registry.Key, kname string, stdname, dstname string) (matched bool, err2 error) {
- k, err := registry.OpenKey(zones, kname, registry.READ)
- if err != nil {
- return false, err
- }
- defer k.Close()
- var std, dlt string
- if err = registry.LoadRegLoadMUIString(); err == nil {
- // Try MUI_Std and MUI_Dlt first, fallback to Std and Dlt if *any* error occurs
- std, err = k.GetMUIStringValue("MUI_Std")
- if err == nil {
- dlt, err = k.GetMUIStringValue("MUI_Dlt")
- }
- }
- if err != nil { // Fallback to Std and Dlt
- if std, _, err = k.GetStringValue("Std"); err != nil {
- return false, err
- }
- if dlt, _, err = k.GetStringValue("Dlt"); err != nil {
- return false, err
- }
- }
- if std != stdname {
- return false, nil
- }
- if dlt != dstname && dstname != stdname {
- return false, nil
- }
- return true, nil
- }
- // toEnglishName searches the registry for an English name of a time zone
- // whose zone names are stdname and dstname and returns the English name.
- func toEnglishName(stdname, dstname string) (string, error) {
- k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones`, registry.ENUMERATE_SUB_KEYS|registry.QUERY_VALUE)
- if err != nil {
- return "", err
- }
- defer k.Close()
- names, err := k.ReadSubKeyNames()
- if err != nil {
- return "", err
- }
- for _, name := range names {
- matched, err := matchZoneKey(k, name, stdname, dstname)
- if err == nil && matched {
- return name, nil
- }
- }
- return "", errors.New(`English name for time zone "` + stdname + `" not found in registry`)
- }
- // extractCAPS extracts capital letters from description desc.
- func extractCAPS(desc string) string {
- var short []rune
- for _, c := range desc {
- if 'A' <= c && c <= 'Z' {
- short = append(short, c)
- }
- }
- return string(short)
- }
- // abbrev returns the abbreviations to use for the given zone z.
- func abbrev(z *syscall.Timezoneinformation) (std, dst string) {
- stdName := syscall.UTF16ToString(z.StandardName[:])
- a, ok := abbrs[stdName]
- if !ok {
- dstName := syscall.UTF16ToString(z.DaylightName[:])
- // Perhaps stdName is not English. Try to convert it.
- englishName, err := toEnglishName(stdName, dstName)
- if err == nil {
- a, ok = abbrs[englishName]
- if ok {
- return a.std, a.dst
- }
- }
- // fallback to using capital letters
- return extractCAPS(stdName), extractCAPS(dstName)
- }
- return a.std, a.dst
- }
- // pseudoUnix returns the pseudo-Unix time (seconds since Jan 1 1970 *LOCAL TIME*)
- // denoted by the system date+time d in the given year.
- // It is up to the caller to convert this local time into a UTC-based time.
- func pseudoUnix(year int, d *syscall.Systemtime) int64 {
- // Windows specifies daylight savings information in "day in month" format:
- // d.Month is month number (1-12)
- // d.DayOfWeek is appropriate weekday (Sunday=0 to Saturday=6)
- // d.Day is week within the month (1 to 5, where 5 is last week of the month)
- // d.Hour, d.Minute and d.Second are absolute time
- day := 1
- t := Date(year, Month(d.Month), day, int(d.Hour), int(d.Minute), int(d.Second), 0, UTC)
- i := int(d.DayOfWeek) - int(t.Weekday())
- if i < 0 {
- i += 7
- }
- day += i
- if week := int(d.Day) - 1; week < 4 {
- day += week * 7
- } else {
- // "Last" instance of the day.
- day += 4 * 7
- if day > daysIn(Month(d.Month), year) {
- day -= 7
- }
- }
- return t.sec() + int64(day-1)*secondsPerDay + internalToUnix
- }
- func initLocalFromTZI(i *syscall.Timezoneinformation) {
- l := &localLoc
- l.name = "Local"
- nzone := 1
- if i.StandardDate.Month > 0 {
- nzone++
- }
- l.zone = make([]zone, nzone)
- stdname, dstname := abbrev(i)
- std := &l.zone[0]
- std.name = stdname
- if nzone == 1 {
- // No daylight savings.
- std.offset = -int(i.Bias) * 60
- l.cacheStart = alpha
- l.cacheEnd = omega
- l.cacheZone = std
- l.tx = make([]zoneTrans, 1)
- l.tx[0].when = l.cacheStart
- l.tx[0].index = 0
- return
- }
- // StandardBias must be ignored if StandardDate is not set,
- // so this computation is delayed until after the nzone==1
- // return above.
- std.offset = -int(i.Bias+i.StandardBias) * 60
- dst := &l.zone[1]
- dst.name = dstname
- dst.offset = -int(i.Bias+i.DaylightBias) * 60
- dst.isDST = true
- // Arrange so that d0 is first transition date, d1 second,
- // i0 is index of zone after first transition, i1 second.
- d0 := &i.StandardDate
- d1 := &i.DaylightDate
- i0 := 0
- i1 := 1
- if d0.Month > d1.Month {
- d0, d1 = d1, d0
- i0, i1 = i1, i0
- }
- // 2 tx per year, 100 years on each side of this year
- l.tx = make([]zoneTrans, 400)
- t := Now().UTC()
- year := t.Year()
- txi := 0
- for y := year - 100; y < year+100; y++ {
- tx := &l.tx[txi]
- tx.when = pseudoUnix(y, d0) - int64(l.zone[i1].offset)
- tx.index = uint8(i0)
- txi++
- tx = &l.tx[txi]
- tx.when = pseudoUnix(y, d1) - int64(l.zone[i0].offset)
- tx.index = uint8(i1)
- txi++
- }
- }
- var usPacific = syscall.Timezoneinformation{
- Bias: 8 * 60,
- StandardName: [32]uint16{
- 'P', 'a', 'c', 'i', 'f', 'i', 'c', ' ', 'S', 't', 'a', 'n', 'd', 'a', 'r', 'd', ' ', 'T', 'i', 'm', 'e',
- },
- StandardDate: syscall.Systemtime{Month: 11, Day: 1, Hour: 2},
- DaylightName: [32]uint16{
- 'P', 'a', 'c', 'i', 'f', 'i', 'c', ' ', 'D', 'a', 'y', 'l', 'i', 'g', 'h', 't', ' ', 'T', 'i', 'm', 'e',
- },
- DaylightDate: syscall.Systemtime{Month: 3, Day: 2, Hour: 2},
- DaylightBias: -60,
- }
- var aus = syscall.Timezoneinformation{
- Bias: -10 * 60,
- StandardName: [32]uint16{
- 'A', 'U', 'S', ' ', 'E', 'a', 's', 't', 'e', 'r', 'n', ' ', 'S', 't', 'a', 'n', 'd', 'a', 'r', 'd', ' ', 'T', 'i', 'm', 'e',
- },
- StandardDate: syscall.Systemtime{Month: 4, Day: 1, Hour: 3},
- DaylightName: [32]uint16{
- 'A', 'U', 'S', ' ', 'E', 'a', 's', 't', 'e', 'r', 'n', ' ', 'D', 'a', 'y', 'l', 'i', 'g', 'h', 't', ' ', 'T', 'i', 'm', 'e',
- },
- DaylightDate: syscall.Systemtime{Month: 10, Day: 1, Hour: 2},
- DaylightBias: -60,
- }
- func initLocal() {
- var i syscall.Timezoneinformation
- if _, err := syscall.GetTimeZoneInformation(&i); err != nil {
- localLoc.name = "UTC"
- return
- }
- initLocalFromTZI(&i)
- }
|