Source file src/time/zoneinfo_read.go

     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	
     5	// Parse "zoneinfo" time zone file.
     6	// This is a fairly standard file format used on OS X, Linux, BSD, Sun, and others.
     7	// See tzfile(5), https://en.wikipedia.org/wiki/Zoneinfo,
     8	// and ftp://munnari.oz.au/pub/oldtz/
     9	
    10	package time
    11	
    12	import (
    13		"errors"
    14		"runtime"
    15		"syscall"
    16	)
    17	
    18	// maxFileSize is the max permitted size of files read by readFile.
    19	// As reference, the zoneinfo.zip distributed by Go is ~350 KB,
    20	// so 10MB is overkill.
    21	const maxFileSize = 10 << 20
    22	
    23	type fileSizeError string
    24	
    25	func (f fileSizeError) Error() string {
    26		return "time: file " + string(f) + " is too large"
    27	}
    28	
    29	// Copies of io.Seek* constants to avoid importing "io":
    30	const (
    31		seekStart   = 0
    32		seekCurrent = 1
    33		seekEnd     = 2
    34	)
    35	
    36	// Simple I/O interface to binary blob of data.
    37	type dataIO struct {
    38		p     []byte
    39		error bool
    40	}
    41	
    42	func (d *dataIO) read(n int) []byte {
    43		if len(d.p) < n {
    44			d.p = nil
    45			d.error = true
    46			return nil
    47		}
    48		p := d.p[0:n]
    49		d.p = d.p[n:]
    50		return p
    51	}
    52	
    53	func (d *dataIO) big4() (n uint32, ok bool) {
    54		p := d.read(4)
    55		if len(p) < 4 {
    56			d.error = true
    57			return 0, false
    58		}
    59		return uint32(p[3]) | uint32(p[2])<<8 | uint32(p[1])<<16 | uint32(p[0])<<24, true
    60	}
    61	
    62	func (d *dataIO) big8() (n uint64, ok bool) {
    63		n1, ok1 := d.big4()
    64		n2, ok2 := d.big4()
    65		if !ok1 || !ok2 {
    66			d.error = true
    67			return 0, false
    68		}
    69		return (uint64(n1) << 32) | uint64(n2), true
    70	}
    71	
    72	func (d *dataIO) byte() (n byte, ok bool) {
    73		p := d.read(1)
    74		if len(p) < 1 {
    75			d.error = true
    76			return 0, false
    77		}
    78		return p[0], true
    79	}
    80	
    81	// Make a string by stopping at the first NUL
    82	func byteString(p []byte) string {
    83		for i := 0; i < len(p); i++ {
    84			if p[i] == 0 {
    85				return string(p[0:i])
    86			}
    87		}
    88		return string(p)
    89	}
    90	
    91	var badData = errors.New("malformed time zone information")
    92	
    93	// LoadLocationFromTZData returns a Location with the given name
    94	// initialized from the IANA Time Zone database-formatted data.
    95	// The data should be in the format of a standard IANA time zone file
    96	// (for example, the content of /etc/localtime on Unix systems).
    97	func LoadLocationFromTZData(name string, data []byte) (*Location, error) {
    98		d := dataIO{data, false}
    99	
   100		// 4-byte magic "TZif"
   101		if magic := d.read(4); string(magic) != "TZif" {
   102			return nil, badData
   103		}
   104	
   105		// 1-byte version, then 15 bytes of padding
   106		var version int
   107		var p []byte
   108		if p = d.read(16); len(p) != 16 {
   109			return nil, badData
   110		} else {
   111			switch p[0] {
   112			case 0:
   113				version = 1
   114			case '2':
   115				version = 2
   116			case '3':
   117				version = 3
   118			default:
   119				return nil, badData
   120			}
   121		}
   122	
   123		// six big-endian 32-bit integers:
   124		//	number of UTC/local indicators
   125		//	number of standard/wall indicators
   126		//	number of leap seconds
   127		//	number of transition times
   128		//	number of local time zones
   129		//	number of characters of time zone abbrev strings
   130		const (
   131			NUTCLocal = iota
   132			NStdWall
   133			NLeap
   134			NTime
   135			NZone
   136			NChar
   137		)
   138		var n [6]int
   139		for i := 0; i < 6; i++ {
   140			nn, ok := d.big4()
   141			if !ok {
   142				return nil, badData
   143			}
   144			if uint32(int(nn)) != nn {
   145				return nil, badData
   146			}
   147			n[i] = int(nn)
   148		}
   149	
   150		// If we have version 2 or 3, then the data is first written out
   151		// in a 32-bit format, then written out again in a 64-bit format.
   152		// Skip the 32-bit format and read the 64-bit one, as it can
   153		// describe a broader range of dates.
   154	
   155		is64 := false
   156		if version > 1 {
   157			// Skip the 32-bit data.
   158			skip := n[NTime]*4 +
   159				n[NTime] +
   160				n[NZone]*6 +
   161				n[NChar] +
   162				n[NLeap]*8 +
   163				n[NStdWall] +
   164				n[NUTCLocal]
   165			// Skip the version 2 header that we just read.
   166			skip += 4 + 16
   167			d.read(skip)
   168	
   169			is64 = true
   170	
   171			// Read the counts again, they can differ.
   172			for i := 0; i < 6; i++ {
   173				nn, ok := d.big4()
   174				if !ok {
   175					return nil, badData
   176				}
   177				if uint32(int(nn)) != nn {
   178					return nil, badData
   179				}
   180				n[i] = int(nn)
   181			}
   182		}
   183	
   184		size := 4
   185		if is64 {
   186			size = 8
   187		}
   188	
   189		// Transition times.
   190		txtimes := dataIO{d.read(n[NTime] * size), false}
   191	
   192		// Time zone indices for transition times.
   193		txzones := d.read(n[NTime])
   194	
   195		// Zone info structures
   196		zonedata := dataIO{d.read(n[NZone] * 6), false}
   197	
   198		// Time zone abbreviations.
   199		abbrev := d.read(n[NChar])
   200	
   201		// Leap-second time pairs
   202		d.read(n[NLeap] * (size + 4))
   203	
   204		// Whether tx times associated with local time types
   205		// are specified as standard time or wall time.
   206		isstd := d.read(n[NStdWall])
   207	
   208		// Whether tx times associated with local time types
   209		// are specified as UTC or local time.
   210		isutc := d.read(n[NUTCLocal])
   211	
   212		if d.error { // ran out of data
   213			return nil, badData
   214		}
   215	
   216		// Now we can build up a useful data structure.
   217		// First the zone information.
   218		//	utcoff[4] isdst[1] nameindex[1]
   219		nzone := n[NZone]
   220		if nzone == 0 {
   221			// Reject tzdata files with no zones. There's nothing useful in them.
   222			// This also avoids a panic later when we add and then use a fake transition (golang.org/issue/29437).
   223			return nil, badData
   224		}
   225		zone := make([]zone, nzone)
   226		for i := range zone {
   227			var ok bool
   228			var n uint32
   229			if n, ok = zonedata.big4(); !ok {
   230				return nil, badData
   231			}
   232			if uint32(int(n)) != n {
   233				return nil, badData
   234			}
   235			zone[i].offset = int(int32(n))
   236			var b byte
   237			if b, ok = zonedata.byte(); !ok {
   238				return nil, badData
   239			}
   240			zone[i].isDST = b != 0
   241			if b, ok = zonedata.byte(); !ok || int(b) >= len(abbrev) {
   242				return nil, badData
   243			}
   244			zone[i].name = byteString(abbrev[b:])
   245			if runtime.GOOS == "aix" && len(name) > 8 && (name[:8] == "Etc/GMT+" || name[:8] == "Etc/GMT-") {
   246				// There is a bug with AIX 7.2 TL 0 with files in Etc,
   247				// GMT+1 will return GMT-1 instead of GMT+1 or -01.
   248				if name != "Etc/GMT+0" {
   249					// GMT+0 is OK
   250					zone[i].name = name[4:]
   251				}
   252			}
   253		}
   254	
   255		// Now the transition time info.
   256		tx := make([]zoneTrans, n[NTime])
   257		for i := range tx {
   258			var n int64
   259			if !is64 {
   260				if n4, ok := txtimes.big4(); !ok {
   261					return nil, badData
   262				} else {
   263					n = int64(int32(n4))
   264				}
   265			} else {
   266				if n8, ok := txtimes.big8(); !ok {
   267					return nil, badData
   268				} else {
   269					n = int64(n8)
   270				}
   271			}
   272			tx[i].when = n
   273			if int(txzones[i]) >= len(zone) {
   274				return nil, badData
   275			}
   276			tx[i].index = txzones[i]
   277			if i < len(isstd) {
   278				tx[i].isstd = isstd[i] != 0
   279			}
   280			if i < len(isutc) {
   281				tx[i].isutc = isutc[i] != 0
   282			}
   283		}
   284	
   285		if len(tx) == 0 {
   286			// Build fake transition to cover all time.
   287			// This happens in fixed locations like "Etc/GMT0".
   288			tx = append(tx, zoneTrans{when: alpha, index: 0})
   289		}
   290	
   291		// Committed to succeed.
   292		l := &Location{zone: zone, tx: tx, name: name}
   293	
   294		// Fill in the cache with information about right now,
   295		// since that will be the most common lookup.
   296		sec, _, _ := now()
   297		for i := range tx {
   298			if tx[i].when <= sec && (i+1 == len(tx) || sec < tx[i+1].when) {
   299				l.cacheStart = tx[i].when
   300				l.cacheEnd = omega
   301				if i+1 < len(tx) {
   302					l.cacheEnd = tx[i+1].when
   303				}
   304				l.cacheZone = &l.zone[tx[i].index]
   305			}
   306		}
   307	
   308		return l, nil
   309	}
   310	
   311	// loadTzinfoFromDirOrZip returns the contents of the file with the given name
   312	// in dir. dir can either be an uncompressed zip file, or a directory.
   313	func loadTzinfoFromDirOrZip(dir, name string) ([]byte, error) {
   314		if len(dir) > 4 && dir[len(dir)-4:] == ".zip" {
   315			return loadTzinfoFromZip(dir, name)
   316		}
   317		if dir != "" {
   318			name = dir + "/" + name
   319		}
   320		return readFile(name)
   321	}
   322	
   323	// There are 500+ zoneinfo files. Rather than distribute them all
   324	// individually, we ship them in an uncompressed zip file.
   325	// Used this way, the zip file format serves as a commonly readable
   326	// container for the individual small files. We choose zip over tar
   327	// because zip files have a contiguous table of contents, making
   328	// individual file lookups faster, and because the per-file overhead
   329	// in a zip file is considerably less than tar's 512 bytes.
   330	
   331	// get4 returns the little-endian 32-bit value in b.
   332	func get4(b []byte) int {
   333		if len(b) < 4 {
   334			return 0
   335		}
   336		return int(b[0]) | int(b[1])<<8 | int(b[2])<<16 | int(b[3])<<24
   337	}
   338	
   339	// get2 returns the little-endian 16-bit value in b.
   340	func get2(b []byte) int {
   341		if len(b) < 2 {
   342			return 0
   343		}
   344		return int(b[0]) | int(b[1])<<8
   345	}
   346	
   347	// loadTzinfoFromZip returns the contents of the file with the given name
   348	// in the given uncompressed zip file.
   349	func loadTzinfoFromZip(zipfile, name string) ([]byte, error) {
   350		fd, err := open(zipfile)
   351		if err != nil {
   352			return nil, err
   353		}
   354		defer closefd(fd)
   355	
   356		const (
   357			zecheader = 0x06054b50
   358			zcheader  = 0x02014b50
   359			ztailsize = 22
   360	
   361			zheadersize = 30
   362			zheader     = 0x04034b50
   363		)
   364	
   365		buf := make([]byte, ztailsize)
   366		if err := preadn(fd, buf, -ztailsize); err != nil || get4(buf) != zecheader {
   367			return nil, errors.New("corrupt zip file " + zipfile)
   368		}
   369		n := get2(buf[10:])
   370		size := get4(buf[12:])
   371		off := get4(buf[16:])
   372	
   373		buf = make([]byte, size)
   374		if err := preadn(fd, buf, off); err != nil {
   375			return nil, errors.New("corrupt zip file " + zipfile)
   376		}
   377	
   378		for i := 0; i < n; i++ {
   379			// zip entry layout:
   380			//	0	magic[4]
   381			//	4	madevers[1]
   382			//	5	madeos[1]
   383			//	6	extvers[1]
   384			//	7	extos[1]
   385			//	8	flags[2]
   386			//	10	meth[2]
   387			//	12	modtime[2]
   388			//	14	moddate[2]
   389			//	16	crc[4]
   390			//	20	csize[4]
   391			//	24	uncsize[4]
   392			//	28	namelen[2]
   393			//	30	xlen[2]
   394			//	32	fclen[2]
   395			//	34	disknum[2]
   396			//	36	iattr[2]
   397			//	38	eattr[4]
   398			//	42	off[4]
   399			//	46	name[namelen]
   400			//	46+namelen+xlen+fclen - next header
   401			//
   402			if get4(buf) != zcheader {
   403				break
   404			}
   405			meth := get2(buf[10:])
   406			size := get4(buf[24:])
   407			namelen := get2(buf[28:])
   408			xlen := get2(buf[30:])
   409			fclen := get2(buf[32:])
   410			off := get4(buf[42:])
   411			zname := buf[46 : 46+namelen]
   412			buf = buf[46+namelen+xlen+fclen:]
   413			if string(zname) != name {
   414				continue
   415			}
   416			if meth != 0 {
   417				return nil, errors.New("unsupported compression for " + name + " in " + zipfile)
   418			}
   419	
   420			// zip per-file header layout:
   421			//	0	magic[4]
   422			//	4	extvers[1]
   423			//	5	extos[1]
   424			//	6	flags[2]
   425			//	8	meth[2]
   426			//	10	modtime[2]
   427			//	12	moddate[2]
   428			//	14	crc[4]
   429			//	18	csize[4]
   430			//	22	uncsize[4]
   431			//	26	namelen[2]
   432			//	28	xlen[2]
   433			//	30	name[namelen]
   434			//	30+namelen+xlen - file data
   435			//
   436			buf = make([]byte, zheadersize+namelen)
   437			if err := preadn(fd, buf, off); err != nil ||
   438				get4(buf) != zheader ||
   439				get2(buf[8:]) != meth ||
   440				get2(buf[26:]) != namelen ||
   441				string(buf[30:30+namelen]) != name {
   442				return nil, errors.New("corrupt zip file " + zipfile)
   443			}
   444			xlen = get2(buf[28:])
   445	
   446			buf = make([]byte, size)
   447			if err := preadn(fd, buf, off+30+namelen+xlen); err != nil {
   448				return nil, errors.New("corrupt zip file " + zipfile)
   449			}
   450	
   451			return buf, nil
   452		}
   453	
   454		return nil, syscall.ENOENT
   455	}
   456	
   457	// loadTzinfoFromTzdata returns the time zone information of the time zone
   458	// with the given name, from a tzdata database file as they are typically
   459	// found on android.
   460	var loadTzinfoFromTzdata func(file, name string) ([]byte, error)
   461	
   462	// loadTzinfo returns the time zone information of the time zone
   463	// with the given name, from a given source. A source may be a
   464	// timezone database directory, tzdata database file or an uncompressed
   465	// zip file, containing the contents of such a directory.
   466	func loadTzinfo(name string, source string) ([]byte, error) {
   467		if len(source) >= 6 && source[len(source)-6:] == "tzdata" {
   468			return loadTzinfoFromTzdata(source, name)
   469		}
   470		return loadTzinfoFromDirOrZip(source, name)
   471	}
   472	
   473	// loadLocation returns the Location with the given name from one of
   474	// the specified sources. See loadTzinfo for a list of supported sources.
   475	// The first timezone data matching the given name that is successfully loaded
   476	// and parsed is returned as a Location.
   477	func loadLocation(name string, sources []string) (z *Location, firstErr error) {
   478		for _, source := range sources {
   479			var zoneData, err = loadTzinfo(name, source)
   480			if err == nil {
   481				if z, err = LoadLocationFromTZData(name, zoneData); err == nil {
   482					return z, nil
   483				}
   484			}
   485			if firstErr == nil && err != syscall.ENOENT {
   486				firstErr = err
   487			}
   488		}
   489		if firstErr != nil {
   490			return nil, firstErr
   491		}
   492		return nil, errors.New("unknown time zone " + name)
   493	}
   494	
   495	// readFile reads and returns the content of the named file.
   496	// It is a trivial implementation of ioutil.ReadFile, reimplemented
   497	// here to avoid depending on io/ioutil or os.
   498	// It returns an error if name exceeds maxFileSize bytes.
   499	func readFile(name string) ([]byte, error) {
   500		f, err := open(name)
   501		if err != nil {
   502			return nil, err
   503		}
   504		defer closefd(f)
   505		var (
   506			buf [4096]byte
   507			ret []byte
   508			n   int
   509		)
   510		for {
   511			n, err = read(f, buf[:])
   512			if n > 0 {
   513				ret = append(ret, buf[:n]...)
   514			}
   515			if n == 0 || err != nil {
   516				break
   517			}
   518			if len(ret) > maxFileSize {
   519				return nil, fileSizeError(name)
   520			}
   521		}
   522		return ret, err
   523	}
   524	

View as plain text