Source file src/pkg/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), http://en.wikipedia.org/wiki/Zoneinfo,
     8	// and ftp://munnari.oz.au/pub/oldtz/
     9	
    10	package time
    11	
    12	import "errors"
    13	
    14	const (
    15		headerSize = 4 + 16 + 4*7
    16	)
    17	
    18	// Simple I/O interface to binary blob of data.
    19	type data struct {
    20		p     []byte
    21		error bool
    22	}
    23	
    24	func (d *data) read(n int) []byte {
    25		if len(d.p) < n {
    26			d.p = nil
    27			d.error = true
    28			return nil
    29		}
    30		p := d.p[0:n]
    31		d.p = d.p[n:]
    32		return p
    33	}
    34	
    35	func (d *data) big4() (n uint32, ok bool) {
    36		p := d.read(4)
    37		if len(p) < 4 {
    38			d.error = true
    39			return 0, false
    40		}
    41		return uint32(p[0])<<24 | uint32(p[1])<<16 | uint32(p[2])<<8 | uint32(p[3]), true
    42	}
    43	
    44	func (d *data) byte() (n byte, ok bool) {
    45		p := d.read(1)
    46		if len(p) < 1 {
    47			d.error = true
    48			return 0, false
    49		}
    50		return p[0], true
    51	}
    52	
    53	// Make a string by stopping at the first NUL
    54	func byteString(p []byte) string {
    55		for i := 0; i < len(p); i++ {
    56			if p[i] == 0 {
    57				return string(p[0:i])
    58			}
    59		}
    60		return string(p)
    61	}
    62	
    63	var badData = errors.New("malformed time zone information")
    64	
    65	func loadZoneData(bytes []byte) (l *Location, err error) {
    66		d := data{bytes, false}
    67	
    68		// 4-byte magic "TZif"
    69		if magic := d.read(4); string(magic) != "TZif" {
    70			return nil, badData
    71		}
    72	
    73		// 1-byte version, then 15 bytes of padding
    74		var p []byte
    75		if p = d.read(16); len(p) != 16 || p[0] != 0 && p[0] != '2' {
    76			return nil, badData
    77		}
    78	
    79		// six big-endian 32-bit integers:
    80		//	number of UTC/local indicators
    81		//	number of standard/wall indicators
    82		//	number of leap seconds
    83		//	number of transition times
    84		//	number of local time zones
    85		//	number of characters of time zone abbrev strings
    86		const (
    87			NUTCLocal = iota
    88			NStdWall
    89			NLeap
    90			NTime
    91			NZone
    92			NChar
    93		)
    94		var n [6]int
    95		for i := 0; i < 6; i++ {
    96			nn, ok := d.big4()
    97			if !ok {
    98				return nil, badData
    99			}
   100			n[i] = int(nn)
   101		}
   102	
   103		// Transition times.
   104		txtimes := data{d.read(n[NTime] * 4), false}
   105	
   106		// Time zone indices for transition times.
   107		txzones := d.read(n[NTime])
   108	
   109		// Zone info structures
   110		zonedata := data{d.read(n[NZone] * 6), false}
   111	
   112		// Time zone abbreviations.
   113		abbrev := d.read(n[NChar])
   114	
   115		// Leap-second time pairs
   116		d.read(n[NLeap] * 8)
   117	
   118		// Whether tx times associated with local time types
   119		// are specified as standard time or wall time.
   120		isstd := d.read(n[NStdWall])
   121	
   122		// Whether tx times associated with local time types
   123		// are specified as UTC or local time.
   124		isutc := d.read(n[NUTCLocal])
   125	
   126		if d.error { // ran out of data
   127			return nil, badData
   128		}
   129	
   130		// If version == 2, the entire file repeats, this time using
   131		// 8-byte ints for txtimes and leap seconds.
   132		// We won't need those until 2106.
   133	
   134		// Now we can build up a useful data structure.
   135		// First the zone information.
   136		//	utcoff[4] isdst[1] nameindex[1]
   137		zone := make([]zone, n[NZone])
   138		for i := range zone {
   139			var ok bool
   140			var n uint32
   141			if n, ok = zonedata.big4(); !ok {
   142				return nil, badData
   143			}
   144			zone[i].offset = int(n)
   145			var b byte
   146			if b, ok = zonedata.byte(); !ok {
   147				return nil, badData
   148			}
   149			zone[i].isDST = b != 0
   150			if b, ok = zonedata.byte(); !ok || int(b) >= len(abbrev) {
   151				return nil, badData
   152			}
   153			zone[i].name = byteString(abbrev[b:])
   154		}
   155	
   156		// Now the transition time info.
   157		tx := make([]zoneTrans, n[NTime])
   158		for i := range tx {
   159			var ok bool
   160			var n uint32
   161			if n, ok = txtimes.big4(); !ok {
   162				return nil, badData
   163			}
   164			tx[i].when = int64(int32(n))
   165			if int(txzones[i]) >= len(zone) {
   166				return nil, badData
   167			}
   168			tx[i].index = txzones[i]
   169			if i < len(isstd) {
   170				tx[i].isstd = isstd[i] != 0
   171			}
   172			if i < len(isutc) {
   173				tx[i].isutc = isutc[i] != 0
   174			}
   175		}
   176	
   177		// Commited to succeed.
   178		l = &Location{zone: zone, tx: tx}
   179	
   180		// Fill in the cache with information about right now,
   181		// since that will be the most common lookup.
   182		sec, _ := now()
   183		for i := range tx {
   184			if tx[i].when <= sec && (i+1 == len(tx) || sec < tx[i+1].when) {
   185				l.cacheStart = tx[i].when
   186				l.cacheEnd = 1<<63 - 1
   187				if i+1 < len(tx) {
   188					l.cacheEnd = tx[i+1].when
   189				}
   190				l.cacheZone = &l.zone[tx[i].index]
   191			}
   192		}
   193	
   194		return l, nil
   195	}
   196	
   197	func loadZoneFile(dir, name string) (l *Location, err error) {
   198		if len(dir) > 4 && dir[len(dir)-4:] == ".zip" {
   199			return loadZoneZip(dir, name)
   200		}
   201		if dir != "" {
   202			name = dir + "/" + name
   203		}
   204		buf, err := readFile(name)
   205		if err != nil {
   206			return
   207		}
   208		return loadZoneData(buf)
   209	}
   210	
   211	// There are 500+ zoneinfo files.  Rather than distribute them all
   212	// individually, we ship them in an uncompressed zip file.
   213	// Used this way, the zip file format serves as a commonly readable
   214	// container for the individual small files.  We choose zip over tar
   215	// because zip files have a contiguous table of contents, making
   216	// individual file lookups faster, and because the per-file overhead
   217	// in a zip file is considerably less than tar's 512 bytes.
   218	
   219	// get4 returns the little-endian 32-bit value in b.
   220	func get4(b []byte) int {
   221		if len(b) < 4 {
   222			return 0
   223		}
   224		return int(b[0]) | int(b[1])<<8 | int(b[2])<<16 | int(b[3])<<24
   225	}
   226	
   227	// get2 returns the little-endian 16-bit value in b.
   228	func get2(b []byte) int {
   229		if len(b) < 2 {
   230			return 0
   231		}
   232		return int(b[0]) | int(b[1])<<8
   233	}
   234	
   235	func loadZoneZip(zipfile, name string) (l *Location, err error) {
   236		fd, err := open(zipfile)
   237		if err != nil {
   238			return nil, errors.New("open " + zipfile + ": " + err.Error())
   239		}
   240		defer closefd(fd)
   241	
   242		const (
   243			zecheader = 0x06054b50
   244			zcheader  = 0x02014b50
   245			ztailsize = 22
   246	
   247			zheadersize = 30
   248			zheader     = 0x04034b50
   249		)
   250	
   251		buf := make([]byte, ztailsize)
   252		if err := preadn(fd, buf, -ztailsize); err != nil || get4(buf) != zecheader {
   253			return nil, errors.New("corrupt zip file " + zipfile)
   254		}
   255		n := get2(buf[10:])
   256		size := get4(buf[12:])
   257		off := get4(buf[16:])
   258	
   259		buf = make([]byte, size)
   260		if err := preadn(fd, buf, off); err != nil {
   261			return nil, errors.New("corrupt zip file " + zipfile)
   262		}
   263	
   264		for i := 0; i < n; i++ {
   265			// zip entry layout:
   266			//	0	magic[4]
   267			//	4	madevers[1]
   268			//	5	madeos[1]
   269			//	6	extvers[1]
   270			//	7	extos[1]
   271			//	8	flags[2]
   272			//	10	meth[2]
   273			//	12	modtime[2]
   274			//	14	moddate[2]
   275			//	16	crc[4]
   276			//	20	csize[4]
   277			//	24	uncsize[4]
   278			//	28	namelen[2]
   279			//	30	xlen[2]
   280			//	32	fclen[2]
   281			//	34	disknum[2]
   282			//	36	iattr[2]
   283			//	38	eattr[4]
   284			//	42	off[4]
   285			//	46	name[namelen]
   286			//	46+namelen+xlen+fclen - next header
   287			//		
   288			if get4(buf) != zcheader {
   289				break
   290			}
   291			meth := get2(buf[10:])
   292			size := get4(buf[24:])
   293			namelen := get2(buf[28:])
   294			xlen := get2(buf[30:])
   295			fclen := get2(buf[32:])
   296			off := get4(buf[42:])
   297			zname := buf[46 : 46+namelen]
   298			buf = buf[46+namelen+xlen+fclen:]
   299			if string(zname) != name {
   300				continue
   301			}
   302			if meth != 0 {
   303				return nil, errors.New("unsupported compression for " + name + " in " + zipfile)
   304			}
   305	
   306			// zip per-file header layout:
   307			//	0	magic[4]
   308			//	4	extvers[1]
   309			//	5	extos[1]
   310			//	6	flags[2]
   311			//	8	meth[2]
   312			//	10	modtime[2]
   313			//	12	moddate[2]
   314			//	14	crc[4]
   315			//	18	csize[4]
   316			//	22	uncsize[4]
   317			//	26	namelen[2]
   318			//	28	xlen[2]
   319			//	30	name[namelen]
   320			//	30+namelen+xlen - file data
   321			//
   322			buf = make([]byte, zheadersize+namelen)
   323			if err := preadn(fd, buf, off); err != nil ||
   324				get4(buf) != zheader ||
   325				get2(buf[8:]) != meth ||
   326				get2(buf[26:]) != namelen ||
   327				string(buf[30:30+namelen]) != name {
   328				return nil, errors.New("corrupt zip file " + zipfile)
   329			}
   330			xlen = get2(buf[28:])
   331	
   332			buf = make([]byte, size)
   333			if err := preadn(fd, buf, off+30+namelen+xlen); err != nil {
   334				return nil, errors.New("corrupt zip file " + zipfile)
   335			}
   336	
   337			return loadZoneData(buf)
   338		}
   339	
   340		return nil, errors.New("cannot find " + name + " in zip file " + zipfile)
   341	}