| // 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. |
| |
| // Parse "zoneinfo" time zone file. |
| // This is a fairly standard file format used on OS X, Linux, BSD, Sun, and others. |
| // See tzfile(5), https://en.wikipedia.org/wiki/Zoneinfo, |
| // and ftp://munnari.oz.au/pub/oldtz/ |
| |
| package time |
| |
| import ( |
| "errors" |
| "runtime" |
| "syscall" |
| ) |
| |
| // registerLoadFromEmbeddedTZData is called by the time/tzdata package, |
| // if it is imported. |
| func registerLoadFromEmbeddedTZData(f func(string) (string, error)) { |
| loadFromEmbeddedTZData = f |
| } |
| |
| // loadFromEmbeddedTZData is used to load a specific tzdata file |
| // from tzdata information embedded in the binary itself. |
| // This is set when the time/tzdata package is imported, |
| // via registerLoadFromEmbeddedTzdata. |
| var loadFromEmbeddedTZData func(zipname string) (string, error) |
| |
| // maxFileSize is the max permitted size of files read by readFile. |
| // As reference, the zoneinfo.zip distributed by Go is ~350 KB, |
| // so 10MB is overkill. |
| const maxFileSize = 10 << 20 |
| |
| type fileSizeError string |
| |
| func (f fileSizeError) Error() string { |
| return "time: file " + string(f) + " is too large" |
| } |
| |
| // Copies of io.Seek* constants to avoid importing "io": |
| const ( |
| seekStart = 0 |
| seekCurrent = 1 |
| seekEnd = 2 |
| ) |
| |
| // Simple I/O interface to binary blob of data. |
| type dataIO struct { |
| p []byte |
| error bool |
| } |
| |
| func (d *dataIO) read(n int) []byte { |
| if len(d.p) < n { |
| d.p = nil |
| d.error = true |
| return nil |
| } |
| p := d.p[0:n] |
| d.p = d.p[n:] |
| return p |
| } |
| |
| func (d *dataIO) big4() (n uint32, ok bool) { |
| p := d.read(4) |
| if len(p) < 4 { |
| d.error = true |
| return 0, false |
| } |
| return uint32(p[3]) | uint32(p[2])<<8 | uint32(p[1])<<16 | uint32(p[0])<<24, true |
| } |
| |
| func (d *dataIO) big8() (n uint64, ok bool) { |
| n1, ok1 := d.big4() |
| n2, ok2 := d.big4() |
| if !ok1 || !ok2 { |
| d.error = true |
| return 0, false |
| } |
| return (uint64(n1) << 32) | uint64(n2), true |
| } |
| |
| func (d *dataIO) byte() (n byte, ok bool) { |
| p := d.read(1) |
| if len(p) < 1 { |
| d.error = true |
| return 0, false |
| } |
| return p[0], true |
| } |
| |
| // read returns the read of the data in the buffer. |
| func (d *dataIO) rest() []byte { |
| r := d.p |
| d.p = nil |
| return r |
| } |
| |
| // Make a string by stopping at the first NUL |
| func byteString(p []byte) string { |
| for i := 0; i < len(p); i++ { |
| if p[i] == 0 { |
| return string(p[0:i]) |
| } |
| } |
| return string(p) |
| } |
| |
| var badData = errors.New("malformed time zone information") |
| |
| // LoadLocationFromTZData returns a Location with the given name |
| // initialized from the IANA Time Zone database-formatted data. |
| // The data should be in the format of a standard IANA time zone file |
| // (for example, the content of /etc/localtime on Unix systems). |
| func LoadLocationFromTZData(name string, data []byte) (*Location, error) { |
| d := dataIO{data, false} |
| |
| // 4-byte magic "TZif" |
| if magic := d.read(4); string(magic) != "TZif" { |
| return nil, badData |
| } |
| |
| // 1-byte version, then 15 bytes of padding |
| var version int |
| var p []byte |
| if p = d.read(16); len(p) != 16 { |
| return nil, badData |
| } else { |
| switch p[0] { |
| case 0: |
| version = 1 |
| case '2': |
| version = 2 |
| case '3': |
| version = 3 |
| default: |
| return nil, badData |
| } |
| } |
| |
| // six big-endian 32-bit integers: |
| // number of UTC/local indicators |
| // number of standard/wall indicators |
| // number of leap seconds |
| // number of transition times |
| // number of local time zones |
| // number of characters of time zone abbrev strings |
| const ( |
| NUTCLocal = iota |
| NStdWall |
| NLeap |
| NTime |
| NZone |
| NChar |
| ) |
| var n [6]int |
| for i := 0; i < 6; i++ { |
| nn, ok := d.big4() |
| if !ok { |
| return nil, badData |
| } |
| if uint32(int(nn)) != nn { |
| return nil, badData |
| } |
| n[i] = int(nn) |
| } |
| |
| // If we have version 2 or 3, then the data is first written out |
| // in a 32-bit format, then written out again in a 64-bit format. |
| // Skip the 32-bit format and read the 64-bit one, as it can |
| // describe a broader range of dates. |
| |
| is64 := false |
| if version > 1 { |
| // Skip the 32-bit data. |
| skip := n[NTime]*4 + |
| n[NTime] + |
| n[NZone]*6 + |
| n[NChar] + |
| n[NLeap]*8 + |
| n[NStdWall] + |
| n[NUTCLocal] |
| // Skip the version 2 header that we just read. |
| skip += 4 + 16 |
| d.read(skip) |
| |
| is64 = true |
| |
| // Read the counts again, they can differ. |
| for i := 0; i < 6; i++ { |
| nn, ok := d.big4() |
| if !ok { |
| return nil, badData |
| } |
| if uint32(int(nn)) != nn { |
| return nil, badData |
| } |
| n[i] = int(nn) |
| } |
| } |
| |
| size := 4 |
| if is64 { |
| size = 8 |
| } |
| |
| // Transition times. |
| txtimes := dataIO{d.read(n[NTime] * size), false} |
| |
| // Time zone indices for transition times. |
| txzones := d.read(n[NTime]) |
| |
| // Zone info structures |
| zonedata := dataIO{d.read(n[NZone] * 6), false} |
| |
| // Time zone abbreviations. |
| abbrev := d.read(n[NChar]) |
| |
| // Leap-second time pairs |
| d.read(n[NLeap] * (size + 4)) |
| |
| // Whether tx times associated with local time types |
| // are specified as standard time or wall time. |
| isstd := d.read(n[NStdWall]) |
| |
| // Whether tx times associated with local time types |
| // are specified as UTC or local time. |
| isutc := d.read(n[NUTCLocal]) |
| |
| if d.error { // ran out of data |
| return nil, badData |
| } |
| |
| var extend string |
| rest := d.rest() |
| if len(rest) > 2 && rest[0] == '\n' && rest[len(rest)-1] == '\n' { |
| extend = string(rest[1 : len(rest)-1]) |
| } |
| |
| // Now we can build up a useful data structure. |
| // First the zone information. |
| // utcoff[4] isdst[1] nameindex[1] |
| nzone := n[NZone] |
| if nzone == 0 { |
| // Reject tzdata files with no zones. There's nothing useful in them. |
| // This also avoids a panic later when we add and then use a fake transition (golang.org/issue/29437). |
| return nil, badData |
| } |
| zones := make([]zone, nzone) |
| for i := range zones { |
| var ok bool |
| var n uint32 |
| if n, ok = zonedata.big4(); !ok { |
| return nil, badData |
| } |
| if uint32(int(n)) != n { |
| return nil, badData |
| } |
| zones[i].offset = int(int32(n)) |
| var b byte |
| if b, ok = zonedata.byte(); !ok { |
| return nil, badData |
| } |
| zones[i].isDST = b != 0 |
| if b, ok = zonedata.byte(); !ok || int(b) >= len(abbrev) { |
| return nil, badData |
| } |
| zones[i].name = byteString(abbrev[b:]) |
| if runtime.GOOS == "aix" && len(name) > 8 && (name[:8] == "Etc/GMT+" || name[:8] == "Etc/GMT-") { |
| // There is a bug with AIX 7.2 TL 0 with files in Etc, |
| // GMT+1 will return GMT-1 instead of GMT+1 or -01. |
| if name != "Etc/GMT+0" { |
| // GMT+0 is OK |
| zones[i].name = name[4:] |
| } |
| } |
| } |
| |
| // Now the transition time info. |
| tx := make([]zoneTrans, n[NTime]) |
| for i := range tx { |
| var n int64 |
| if !is64 { |
| if n4, ok := txtimes.big4(); !ok { |
| return nil, badData |
| } else { |
| n = int64(int32(n4)) |
| } |
| } else { |
| if n8, ok := txtimes.big8(); !ok { |
| return nil, badData |
| } else { |
| n = int64(n8) |
| } |
| } |
| tx[i].when = n |
| if int(txzones[i]) >= len(zones) { |
| return nil, badData |
| } |
| tx[i].index = txzones[i] |
| if i < len(isstd) { |
| tx[i].isstd = isstd[i] != 0 |
| } |
| if i < len(isutc) { |
| tx[i].isutc = isutc[i] != 0 |
| } |
| } |
| |
| if len(tx) == 0 { |
| // Build fake transition to cover all time. |
| // This happens in fixed locations like "Etc/GMT0". |
| tx = append(tx, zoneTrans{when: alpha, index: 0}) |
| } |
| |
| // Committed to succeed. |
| l := &Location{zone: zones, tx: tx, name: name, extend: extend} |
| |
| // Fill in the cache with information about right now, |
| // since that will be the most common lookup. |
| sec, _, _ := now() |
| for i := range tx { |
| if tx[i].when <= sec && (i+1 == len(tx) || sec < tx[i+1].when) { |
| l.cacheStart = tx[i].when |
| l.cacheEnd = omega |
| l.cacheZone = &l.zone[tx[i].index] |
| if i+1 < len(tx) { |
| l.cacheEnd = tx[i+1].when |
| } else if l.extend != "" { |
| // If we're at the end of the known zone transitions, |
| // try the extend string. |
| if name, offset, estart, eend, isDST, ok := tzset(l.extend, l.cacheStart, sec); ok { |
| l.cacheStart = estart |
| l.cacheEnd = eend |
| // Find the zone that is returned by tzset to avoid allocation if possible. |
| if zoneIdx := findZone(l.zone, name, offset, isDST); zoneIdx != -1 { |
| l.cacheZone = &l.zone[zoneIdx] |
| } else { |
| l.cacheZone = &zone{ |
| name: name, |
| offset: offset, |
| isDST: isDST, |
| } |
| } |
| } |
| } |
| break |
| } |
| } |
| |
| return l, nil |
| } |
| |
| func findZone(zones []zone, name string, offset int, isDST bool) int { |
| for i, z := range zones { |
| if z.name == name && z.offset == offset && z.isDST == isDST { |
| return i |
| } |
| } |
| return -1 |
| } |
| |
| // loadTzinfoFromDirOrZip returns the contents of the file with the given name |
| // in dir. dir can either be an uncompressed zip file, or a directory. |
| func loadTzinfoFromDirOrZip(dir, name string) ([]byte, error) { |
| if len(dir) > 4 && dir[len(dir)-4:] == ".zip" { |
| return loadTzinfoFromZip(dir, name) |
| } |
| if dir != "" { |
| name = dir + "/" + name |
| } |
| return readFile(name) |
| } |
| |
| // There are 500+ zoneinfo files. Rather than distribute them all |
| // individually, we ship them in an uncompressed zip file. |
| // Used this way, the zip file format serves as a commonly readable |
| // container for the individual small files. We choose zip over tar |
| // because zip files have a contiguous table of contents, making |
| // individual file lookups faster, and because the per-file overhead |
| // in a zip file is considerably less than tar's 512 bytes. |
| |
| // get4 returns the little-endian 32-bit value in b. |
| func get4(b []byte) int { |
| if len(b) < 4 { |
| return 0 |
| } |
| return int(b[0]) | int(b[1])<<8 | int(b[2])<<16 | int(b[3])<<24 |
| } |
| |
| // get2 returns the little-endian 16-bit value in b. |
| func get2(b []byte) int { |
| if len(b) < 2 { |
| return 0 |
| } |
| return int(b[0]) | int(b[1])<<8 |
| } |
| |
| // loadTzinfoFromZip returns the contents of the file with the given name |
| // in the given uncompressed zip file. |
| func loadTzinfoFromZip(zipfile, name string) ([]byte, error) { |
| fd, err := open(zipfile) |
| if err != nil { |
| return nil, err |
| } |
| defer closefd(fd) |
| |
| const ( |
| zecheader = 0x06054b50 |
| zcheader = 0x02014b50 |
| ztailsize = 22 |
| |
| zheadersize = 30 |
| zheader = 0x04034b50 |
| ) |
| |
| buf := make([]byte, ztailsize) |
| if err := preadn(fd, buf, -ztailsize); err != nil || get4(buf) != zecheader { |
| return nil, errors.New("corrupt zip file " + zipfile) |
| } |
| n := get2(buf[10:]) |
| size := get4(buf[12:]) |
| off := get4(buf[16:]) |
| |
| buf = make([]byte, size) |
| if err := preadn(fd, buf, off); err != nil { |
| return nil, errors.New("corrupt zip file " + zipfile) |
| } |
| |
| for i := 0; i < n; i++ { |
| // zip entry layout: |
| // 0 magic[4] |
| // 4 madevers[1] |
| // 5 madeos[1] |
| // 6 extvers[1] |
| // 7 extos[1] |
| // 8 flags[2] |
| // 10 meth[2] |
| // 12 modtime[2] |
| // 14 moddate[2] |
| // 16 crc[4] |
| // 20 csize[4] |
| // 24 uncsize[4] |
| // 28 namelen[2] |
| // 30 xlen[2] |
| // 32 fclen[2] |
| // 34 disknum[2] |
| // 36 iattr[2] |
| // 38 eattr[4] |
| // 42 off[4] |
| // 46 name[namelen] |
| // 46+namelen+xlen+fclen - next header |
| // |
| if get4(buf) != zcheader { |
| break |
| } |
| meth := get2(buf[10:]) |
| size := get4(buf[24:]) |
| namelen := get2(buf[28:]) |
| xlen := get2(buf[30:]) |
| fclen := get2(buf[32:]) |
| off := get4(buf[42:]) |
| zname := buf[46 : 46+namelen] |
| buf = buf[46+namelen+xlen+fclen:] |
| if string(zname) != name { |
| continue |
| } |
| if meth != 0 { |
| return nil, errors.New("unsupported compression for " + name + " in " + zipfile) |
| } |
| |
| // zip per-file header layout: |
| // 0 magic[4] |
| // 4 extvers[1] |
| // 5 extos[1] |
| // 6 flags[2] |
| // 8 meth[2] |
| // 10 modtime[2] |
| // 12 moddate[2] |
| // 14 crc[4] |
| // 18 csize[4] |
| // 22 uncsize[4] |
| // 26 namelen[2] |
| // 28 xlen[2] |
| // 30 name[namelen] |
| // 30+namelen+xlen - file data |
| // |
| buf = make([]byte, zheadersize+namelen) |
| if err := preadn(fd, buf, off); err != nil || |
| get4(buf) != zheader || |
| get2(buf[8:]) != meth || |
| get2(buf[26:]) != namelen || |
| string(buf[30:30+namelen]) != name { |
| return nil, errors.New("corrupt zip file " + zipfile) |
| } |
| xlen = get2(buf[28:]) |
| |
| buf = make([]byte, size) |
| if err := preadn(fd, buf, off+30+namelen+xlen); err != nil { |
| return nil, errors.New("corrupt zip file " + zipfile) |
| } |
| |
| return buf, nil |
| } |
| |
| return nil, syscall.ENOENT |
| } |
| |
| // loadTzinfoFromTzdata returns the time zone information of the time zone |
| // with the given name, from a tzdata database file as they are typically |
| // found on android. |
| var loadTzinfoFromTzdata func(file, name string) ([]byte, error) |
| |
| // loadTzinfo returns the time zone information of the time zone |
| // with the given name, from a given source. A source may be a |
| // timezone database directory, tzdata database file or an uncompressed |
| // zip file, containing the contents of such a directory. |
| func loadTzinfo(name string, source string) ([]byte, error) { |
| if len(source) >= 6 && source[len(source)-6:] == "tzdata" { |
| return loadTzinfoFromTzdata(source, name) |
| } |
| return loadTzinfoFromDirOrZip(source, name) |
| } |
| |
| // loadLocation returns the Location with the given name from one of |
| // the specified sources. See loadTzinfo for a list of supported sources. |
| // The first timezone data matching the given name that is successfully loaded |
| // and parsed is returned as a Location. |
| func loadLocation(name string, sources []string) (z *Location, firstErr error) { |
| for _, source := range sources { |
| zoneData, err := loadTzinfo(name, source) |
| if err == nil { |
| if z, err = LoadLocationFromTZData(name, zoneData); err == nil { |
| return z, nil |
| } |
| } |
| if firstErr == nil && err != syscall.ENOENT { |
| firstErr = err |
| } |
| } |
| if loadFromEmbeddedTZData != nil { |
| zoneData, err := loadFromEmbeddedTZData(name) |
| if err == nil { |
| if z, err = LoadLocationFromTZData(name, []byte(zoneData)); err == nil { |
| return z, nil |
| } |
| } |
| if firstErr == nil && err != syscall.ENOENT { |
| firstErr = err |
| } |
| } |
| if source, ok := gorootZoneSource(goroot()); ok { |
| zoneData, err := loadTzinfo(name, source) |
| if err == nil { |
| if z, err = LoadLocationFromTZData(name, zoneData); err == nil { |
| return z, nil |
| } |
| } |
| if firstErr == nil && err != syscall.ENOENT { |
| firstErr = err |
| } |
| } |
| if firstErr != nil { |
| return nil, firstErr |
| } |
| return nil, errors.New("unknown time zone " + name) |
| } |
| |
| // readFile reads and returns the content of the named file. |
| // It is a trivial implementation of os.ReadFile, reimplemented |
| // here to avoid depending on io/ioutil or os. |
| // It returns an error if name exceeds maxFileSize bytes. |
| func readFile(name string) ([]byte, error) { |
| f, err := open(name) |
| if err != nil { |
| return nil, err |
| } |
| defer closefd(f) |
| var ( |
| buf [4096]byte |
| ret []byte |
| n int |
| ) |
| for { |
| n, err = read(f, buf[:]) |
| if n > 0 { |
| ret = append(ret, buf[:n]...) |
| } |
| if n == 0 || err != nil { |
| break |
| } |
| if len(ret) > maxFileSize { |
| return nil, fileSizeError(name) |
| } |
| } |
| return ret, err |
| } |