// 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 } // rest returns the rest 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 errBadData = 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, errBadData } // 1-byte version, then 15 bytes of padding var version int var p []byte if p = d.read(16); len(p) != 16 { return nil, errBadData } else { switch p[0] { case 0: version = 1 case '2': version = 2 case '3': version = 3 default: return nil, errBadData } } // 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, errBadData } if uint32(int(nn)) != nn { return nil, errBadData } 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, errBadData } if uint32(int(nn)) != nn { return nil, errBadData } 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, errBadData } 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, errBadData } zones := make([]zone, nzone) for i := range zones { var ok bool var n uint32 if n, ok = zonedata.big4(); !ok { return nil, errBadData } if uint32(int(n)) != n { return nil, errBadData } zones[i].offset = int(int32(n)) var b byte if b, ok = zonedata.byte(); !ok { return nil, errBadData } zones[i].isDST = b != 0 if b, ok = zonedata.byte(); !ok || int(b) >= len(abbrev) { return nil, errBadData } 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, errBadData } else { n = int64(int32(n4)) } } else { if n8, ok := txtimes.big8(); !ok { return nil, errBadData } else { n = int64(n8) } } tx[i].when = n if int(txzones[i]) >= len(zones) { return nil, errBadData } 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(runtime.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 }