1// Copyright 2009 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package time
6
7import (
8	"errors"
9	"internal/syscall/windows/registry"
10	"runtime"
11	"syscall"
12)
13
14//go:generate go run genzabbrs.go -output zoneinfo_abbrs_windows.go
15
16// TODO(rsc): Fall back to copy of zoneinfo files.
17
18// BUG(brainman,rsc): On Windows, the operating system does not provide complete
19// time zone information.
20// The implementation assumes that this year's rules for daylight savings
21// time apply to all previous and future years as well.
22
23// matchZoneKey checks if stdname and dstname match the corresponding key
24// values "MUI_Std" and MUI_Dlt" or "Std" and "Dlt" (the latter down-level
25// from Vista) in the kname key stored under the open registry key zones.
26func matchZoneKey(zones registry.Key, kname string, stdname, dstname string) (matched bool, err2 error) {
27	k, err := registry.OpenKey(zones, kname, registry.READ)
28	if err != nil {
29		return false, err
30	}
31	defer k.Close()
32
33	var std, dlt string
34	if err = registry.LoadRegLoadMUIString(); err == nil {
35		// Try MUI_Std and MUI_Dlt first, fallback to Std and Dlt if *any* error occurs
36		std, err = k.GetMUIStringValue("MUI_Std")
37		if err == nil {
38			dlt, err = k.GetMUIStringValue("MUI_Dlt")
39		}
40	}
41	if err != nil { // Fallback to Std and Dlt
42		if std, _, err = k.GetStringValue("Std"); err != nil {
43			return false, err
44		}
45		if dlt, _, err = k.GetStringValue("Dlt"); err != nil {
46			return false, err
47		}
48	}
49
50	if std != stdname {
51		return false, nil
52	}
53	if dlt != dstname && dstname != stdname {
54		return false, nil
55	}
56	return true, nil
57}
58
59// toEnglishName searches the registry for an English name of a time zone
60// whose zone names are stdname and dstname and returns the English name.
61func toEnglishName(stdname, dstname string) (string, error) {
62	k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones`, registry.ENUMERATE_SUB_KEYS|registry.QUERY_VALUE)
63	if err != nil {
64		return "", err
65	}
66	defer k.Close()
67
68	names, err := k.ReadSubKeyNames(-1)
69	if err != nil {
70		return "", err
71	}
72	for _, name := range names {
73		matched, err := matchZoneKey(k, name, stdname, dstname)
74		if err == nil && matched {
75			return name, nil
76		}
77	}
78	return "", errors.New(`English name for time zone "` + stdname + `" not found in registry`)
79}
80
81// extractCAPS extracts capital letters from description desc.
82func extractCAPS(desc string) string {
83	var short []rune
84	for _, c := range desc {
85		if 'A' <= c && c <= 'Z' {
86			short = append(short, rune(c))
87		}
88	}
89	return string(short)
90}
91
92// abbrev returns the abbreviations to use for the given zone z.
93func abbrev(z *syscall.Timezoneinformation) (std, dst string) {
94	stdName := syscall.UTF16ToString(z.StandardName[:])
95	a, ok := abbrs[stdName]
96	if !ok {
97		dstName := syscall.UTF16ToString(z.DaylightName[:])
98		// Perhaps stdName is not English. Try to convert it.
99		englishName, err := toEnglishName(stdName, dstName)
100		if err == nil {
101			a, ok = abbrs[englishName]
102			if ok {
103				return a.std, a.dst
104			}
105		}
106		// fallback to using capital letters
107		return extractCAPS(stdName), extractCAPS(dstName)
108	}
109	return a.std, a.dst
110}
111
112// pseudoUnix returns the pseudo-Unix time (seconds since Jan 1 1970 *LOCAL TIME*)
113// denoted by the system date+time d in the given year.
114// It is up to the caller to convert this local time into a UTC-based time.
115func pseudoUnix(year int, d *syscall.Systemtime) int64 {
116	// Windows specifies daylight savings information in "day in month" format:
117	// d.Month is month number (1-12)
118	// d.DayOfWeek is appropriate weekday (Sunday=0 to Saturday=6)
119	// d.Day is week within the month (1 to 5, where 5 is last week of the month)
120	// d.Hour, d.Minute and d.Second are absolute time
121	day := 1
122	t := Date(year, Month(d.Month), day, int(d.Hour), int(d.Minute), int(d.Second), 0, UTC)
123	i := int(d.DayOfWeek) - int(t.Weekday())
124	if i < 0 {
125		i += 7
126	}
127	day += i
128	if week := int(d.Day) - 1; week < 4 {
129		day += week * 7
130	} else {
131		// "Last" instance of the day.
132		day += 4 * 7
133		if day > daysIn(Month(d.Month), year) {
134			day -= 7
135		}
136	}
137	return t.sec + int64(day-1)*secondsPerDay + internalToUnix
138}
139
140func initLocalFromTZI(i *syscall.Timezoneinformation) {
141	l := &localLoc
142
143	nzone := 1
144	if i.StandardDate.Month > 0 {
145		nzone++
146	}
147	l.zone = make([]zone, nzone)
148
149	stdname, dstname := abbrev(i)
150
151	std := &l.zone[0]
152	std.name = stdname
153	if nzone == 1 {
154		// No daylight savings.
155		std.offset = -int(i.Bias) * 60
156		l.cacheStart = alpha
157		l.cacheEnd = omega
158		l.cacheZone = std
159		l.tx = make([]zoneTrans, 1)
160		l.tx[0].when = l.cacheStart
161		l.tx[0].index = 0
162		return
163	}
164
165	// StandardBias must be ignored if StandardDate is not set,
166	// so this computation is delayed until after the nzone==1
167	// return above.
168	std.offset = -int(i.Bias+i.StandardBias) * 60
169
170	dst := &l.zone[1]
171	dst.name = dstname
172	dst.offset = -int(i.Bias+i.DaylightBias) * 60
173	dst.isDST = true
174
175	// Arrange so that d0 is first transition date, d1 second,
176	// i0 is index of zone after first transition, i1 second.
177	d0 := &i.StandardDate
178	d1 := &i.DaylightDate
179	i0 := 0
180	i1 := 1
181	if d0.Month > d1.Month {
182		d0, d1 = d1, d0
183		i0, i1 = i1, i0
184	}
185
186	// 2 tx per year, 100 years on each side of this year
187	l.tx = make([]zoneTrans, 400)
188
189	t := Now().UTC()
190	year := t.Year()
191	txi := 0
192	for y := year - 100; y < year+100; y++ {
193		tx := &l.tx[txi]
194		tx.when = pseudoUnix(y, d0) - int64(l.zone[i1].offset)
195		tx.index = uint8(i0)
196		txi++
197
198		tx = &l.tx[txi]
199		tx.when = pseudoUnix(y, d1) - int64(l.zone[i0].offset)
200		tx.index = uint8(i1)
201		txi++
202	}
203}
204
205var usPacific = syscall.Timezoneinformation{
206	Bias: 8 * 60,
207	StandardName: [32]uint16{
208		'P', 'a', 'c', 'i', 'f', 'i', 'c', ' ', 'S', 't', 'a', 'n', 'd', 'a', 'r', 'd', ' ', 'T', 'i', 'm', 'e',
209	},
210	StandardDate: syscall.Systemtime{Month: 11, Day: 1, Hour: 2},
211	DaylightName: [32]uint16{
212		'P', 'a', 'c', 'i', 'f', 'i', 'c', ' ', 'D', 'a', 'y', 'l', 'i', 'g', 'h', 't', ' ', 'T', 'i', 'm', 'e',
213	},
214	DaylightDate: syscall.Systemtime{Month: 3, Day: 2, Hour: 2},
215	DaylightBias: -60,
216}
217
218var aus = syscall.Timezoneinformation{
219	Bias: -10 * 60,
220	StandardName: [32]uint16{
221		'A', 'U', 'S', ' ', 'E', 'a', 's', 't', 'e', 'r', 'n', ' ', 'S', 't', 'a', 'n', 'd', 'a', 'r', 'd', ' ', 'T', 'i', 'm', 'e',
222	},
223	StandardDate: syscall.Systemtime{Month: 4, Day: 1, Hour: 3},
224	DaylightName: [32]uint16{
225		'A', 'U', 'S', ' ', 'E', 'a', 's', 't', 'e', 'r', 'n', ' ', 'D', 'a', 'y', 'l', 'i', 'g', 'h', 't', ' ', 'T', 'i', 'm', 'e',
226	},
227	DaylightDate: syscall.Systemtime{Month: 10, Day: 1, Hour: 2},
228	DaylightBias: -60,
229}
230
231func initTestingZone() {
232	initLocalFromTZI(&usPacific)
233}
234
235func initAusTestingZone() {
236	initLocalFromTZI(&aus)
237}
238
239func initLocal() {
240	var i syscall.Timezoneinformation
241	if _, err := syscall.GetTimeZoneInformation(&i); err != nil {
242		localLoc.name = "UTC"
243		return
244	}
245	initLocalFromTZI(&i)
246}
247
248func loadLocation(name string) (*Location, error) {
249	z, err := loadZoneFile(runtime.GOROOT()+`\lib\time\zoneinfo.zip`, name)
250	if err != nil {
251		return nil, err
252	}
253	z.name = name
254	return z, nil
255}
256
257func forceZipFileForTesting(zipOnly bool) {
258	// We only use the zip file anyway.
259}
260