Source file src/time/zoneinfo_read.go

Documentation: time

  // 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), http://en.wikipedia.org/wiki/Zoneinfo,
  // and ftp://munnari.oz.au/pub/oldtz/
  
  package time
  
  import (
  	"errors"
  	"syscall"
  )
  
  // 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[0])<<24 | uint32(p[1])<<16 | uint32(p[2])<<8 | uint32(p[3]), 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
  }
  
  // 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 p []byte
  	if p = d.read(16); len(p) != 16 || p[0] != 0 && p[0] != '2' && p[0] != '3' {
  		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
  		}
  		n[i] = int(nn)
  	}
  
  	// Transition times.
  	txtimes := dataIO{d.read(n[NTime] * 4), 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] * 8)
  
  	// 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
  	}
  
  	// If version == 2 or 3, the entire file repeats, this time using
  	// 8-byte ints for txtimes and leap seconds.
  	// We won't need those until 2106.
  
  	// Now we can build up a useful data structure.
  	// First the zone information.
  	//	utcoff[4] isdst[1] nameindex[1]
  	zone := make([]zone, n[NZone])
  	for i := range zone {
  		var ok bool
  		var n uint32
  		if n, ok = zonedata.big4(); !ok {
  			return nil, badData
  		}
  		zone[i].offset = int(int32(n))
  		var b byte
  		if b, ok = zonedata.byte(); !ok {
  			return nil, badData
  		}
  		zone[i].isDST = b != 0
  		if b, ok = zonedata.byte(); !ok || int(b) >= len(abbrev) {
  			return nil, badData
  		}
  		zone[i].name = byteString(abbrev[b:])
  	}
  
  	// Now the transition time info.
  	tx := make([]zoneTrans, n[NTime])
  	for i := range tx {
  		var ok bool
  		var n uint32
  		if n, ok = txtimes.big4(); !ok {
  			return nil, badData
  		}
  		tx[i].when = int64(int32(n))
  		if int(txzones[i]) >= len(zone) {
  			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: zone, tx: tx, name: name}
  
  	// 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
  			if i+1 < len(tx) {
  				l.cacheEnd = tx[i+1].when
  			}
  			l.cacheZone = &l.zone[tx[i].index]
  		}
  	}
  
  	return l, nil
  }
  
  // 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, errors.New("open " + zipfile + ": " + err.Error())
  	}
  	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, errors.New("cannot find " + name + " in zip file " + zipfile)
  }
  
  // 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 {
  		var 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 ioutil.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
  }
  

View as plain text