strconv.go

Documentation: archive/tar

		 1  // Copyright 2016 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  package tar
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"fmt"
		10  	"strconv"
		11  	"strings"
		12  	"time"
		13  )
		14  
		15  // hasNUL reports whether the NUL character exists within s.
		16  func hasNUL(s string) bool {
		17  	return strings.IndexByte(s, 0) >= 0
		18  }
		19  
		20  // isASCII reports whether the input is an ASCII C-style string.
		21  func isASCII(s string) bool {
		22  	for _, c := range s {
		23  		if c >= 0x80 || c == 0x00 {
		24  			return false
		25  		}
		26  	}
		27  	return true
		28  }
		29  
		30  // toASCII converts the input to an ASCII C-style string.
		31  // This is a best effort conversion, so invalid characters are dropped.
		32  func toASCII(s string) string {
		33  	if isASCII(s) {
		34  		return s
		35  	}
		36  	b := make([]byte, 0, len(s))
		37  	for _, c := range s {
		38  		if c < 0x80 && c != 0x00 {
		39  			b = append(b, byte(c))
		40  		}
		41  	}
		42  	return string(b)
		43  }
		44  
		45  type parser struct {
		46  	err error // Last error seen
		47  }
		48  
		49  type formatter struct {
		50  	err error // Last error seen
		51  }
		52  
		53  // parseString parses bytes as a NUL-terminated C-style string.
		54  // If a NUL byte is not found then the whole slice is returned as a string.
		55  func (*parser) parseString(b []byte) string {
		56  	if i := bytes.IndexByte(b, 0); i >= 0 {
		57  		return string(b[:i])
		58  	}
		59  	return string(b)
		60  }
		61  
		62  // formatString copies s into b, NUL-terminating if possible.
		63  func (f *formatter) formatString(b []byte, s string) {
		64  	if len(s) > len(b) {
		65  		f.err = ErrFieldTooLong
		66  	}
		67  	copy(b, s)
		68  	if len(s) < len(b) {
		69  		b[len(s)] = 0
		70  	}
		71  
		72  	// Some buggy readers treat regular files with a trailing slash
		73  	// in the V7 path field as a directory even though the full path
		74  	// recorded elsewhere (e.g., via PAX record) contains no trailing slash.
		75  	if len(s) > len(b) && b[len(b)-1] == '/' {
		76  		n := len(strings.TrimRight(s[:len(b)], "/"))
		77  		b[n] = 0 // Replace trailing slash with NUL terminator
		78  	}
		79  }
		80  
		81  // fitsInBase256 reports whether x can be encoded into n bytes using base-256
		82  // encoding. Unlike octal encoding, base-256 encoding does not require that the
		83  // string ends with a NUL character. Thus, all n bytes are available for output.
		84  //
		85  // If operating in binary mode, this assumes strict GNU binary mode; which means
		86  // that the first byte can only be either 0x80 or 0xff. Thus, the first byte is
		87  // equivalent to the sign bit in two's complement form.
		88  func fitsInBase256(n int, x int64) bool {
		89  	binBits := uint(n-1) * 8
		90  	return n >= 9 || (x >= -1<<binBits && x < 1<<binBits)
		91  }
		92  
		93  // parseNumeric parses the input as being encoded in either base-256 or octal.
		94  // This function may return negative numbers.
		95  // If parsing fails or an integer overflow occurs, err will be set.
		96  func (p *parser) parseNumeric(b []byte) int64 {
		97  	// Check for base-256 (binary) format first.
		98  	// If the first bit is set, then all following bits constitute a two's
		99  	// complement encoded number in big-endian byte order.
	 100  	if len(b) > 0 && b[0]&0x80 != 0 {
	 101  		// Handling negative numbers relies on the following identity:
	 102  		//	-a-1 == ^a
	 103  		//
	 104  		// If the number is negative, we use an inversion mask to invert the
	 105  		// data bytes and treat the value as an unsigned number.
	 106  		var inv byte // 0x00 if positive or zero, 0xff if negative
	 107  		if b[0]&0x40 != 0 {
	 108  			inv = 0xff
	 109  		}
	 110  
	 111  		var x uint64
	 112  		for i, c := range b {
	 113  			c ^= inv // Inverts c only if inv is 0xff, otherwise does nothing
	 114  			if i == 0 {
	 115  				c &= 0x7f // Ignore signal bit in first byte
	 116  			}
	 117  			if (x >> 56) > 0 {
	 118  				p.err = ErrHeader // Integer overflow
	 119  				return 0
	 120  			}
	 121  			x = x<<8 | uint64(c)
	 122  		}
	 123  		if (x >> 63) > 0 {
	 124  			p.err = ErrHeader // Integer overflow
	 125  			return 0
	 126  		}
	 127  		if inv == 0xff {
	 128  			return ^int64(x)
	 129  		}
	 130  		return int64(x)
	 131  	}
	 132  
	 133  	// Normal case is base-8 (octal) format.
	 134  	return p.parseOctal(b)
	 135  }
	 136  
	 137  // formatNumeric encodes x into b using base-8 (octal) encoding if possible.
	 138  // Otherwise it will attempt to use base-256 (binary) encoding.
	 139  func (f *formatter) formatNumeric(b []byte, x int64) {
	 140  	if fitsInOctal(len(b), x) {
	 141  		f.formatOctal(b, x)
	 142  		return
	 143  	}
	 144  
	 145  	if fitsInBase256(len(b), x) {
	 146  		for i := len(b) - 1; i >= 0; i-- {
	 147  			b[i] = byte(x)
	 148  			x >>= 8
	 149  		}
	 150  		b[0] |= 0x80 // Highest bit indicates binary format
	 151  		return
	 152  	}
	 153  
	 154  	f.formatOctal(b, 0) // Last resort, just write zero
	 155  	f.err = ErrFieldTooLong
	 156  }
	 157  
	 158  func (p *parser) parseOctal(b []byte) int64 {
	 159  	// Because unused fields are filled with NULs, we need
	 160  	// to skip leading NULs. Fields may also be padded with
	 161  	// spaces or NULs.
	 162  	// So we remove leading and trailing NULs and spaces to
	 163  	// be sure.
	 164  	b = bytes.Trim(b, " \x00")
	 165  
	 166  	if len(b) == 0 {
	 167  		return 0
	 168  	}
	 169  	x, perr := strconv.ParseUint(p.parseString(b), 8, 64)
	 170  	if perr != nil {
	 171  		p.err = ErrHeader
	 172  	}
	 173  	return int64(x)
	 174  }
	 175  
	 176  func (f *formatter) formatOctal(b []byte, x int64) {
	 177  	if !fitsInOctal(len(b), x) {
	 178  		x = 0 // Last resort, just write zero
	 179  		f.err = ErrFieldTooLong
	 180  	}
	 181  
	 182  	s := strconv.FormatInt(x, 8)
	 183  	// Add leading zeros, but leave room for a NUL.
	 184  	if n := len(b) - len(s) - 1; n > 0 {
	 185  		s = strings.Repeat("0", n) + s
	 186  	}
	 187  	f.formatString(b, s)
	 188  }
	 189  
	 190  // fitsInOctal reports whether the integer x fits in a field n-bytes long
	 191  // using octal encoding with the appropriate NUL terminator.
	 192  func fitsInOctal(n int, x int64) bool {
	 193  	octBits := uint(n-1) * 3
	 194  	return x >= 0 && (n >= 22 || x < 1<<octBits)
	 195  }
	 196  
	 197  // parsePAXTime takes a string of the form %d.%d as described in the PAX
	 198  // specification. Note that this implementation allows for negative timestamps,
	 199  // which is allowed for by the PAX specification, but not always portable.
	 200  func parsePAXTime(s string) (time.Time, error) {
	 201  	const maxNanoSecondDigits = 9
	 202  
	 203  	// Split string into seconds and sub-seconds parts.
	 204  	ss, sn := s, ""
	 205  	if pos := strings.IndexByte(s, '.'); pos >= 0 {
	 206  		ss, sn = s[:pos], s[pos+1:]
	 207  	}
	 208  
	 209  	// Parse the seconds.
	 210  	secs, err := strconv.ParseInt(ss, 10, 64)
	 211  	if err != nil {
	 212  		return time.Time{}, ErrHeader
	 213  	}
	 214  	if len(sn) == 0 {
	 215  		return time.Unix(secs, 0), nil // No sub-second values
	 216  	}
	 217  
	 218  	// Parse the nanoseconds.
	 219  	if strings.Trim(sn, "0123456789") != "" {
	 220  		return time.Time{}, ErrHeader
	 221  	}
	 222  	if len(sn) < maxNanoSecondDigits {
	 223  		sn += strings.Repeat("0", maxNanoSecondDigits-len(sn)) // Right pad
	 224  	} else {
	 225  		sn = sn[:maxNanoSecondDigits] // Right truncate
	 226  	}
	 227  	nsecs, _ := strconv.ParseInt(sn, 10, 64) // Must succeed
	 228  	if len(ss) > 0 && ss[0] == '-' {
	 229  		return time.Unix(secs, -1*nsecs), nil // Negative correction
	 230  	}
	 231  	return time.Unix(secs, nsecs), nil
	 232  }
	 233  
	 234  // formatPAXTime converts ts into a time of the form %d.%d as described in the
	 235  // PAX specification. This function is capable of negative timestamps.
	 236  func formatPAXTime(ts time.Time) (s string) {
	 237  	secs, nsecs := ts.Unix(), ts.Nanosecond()
	 238  	if nsecs == 0 {
	 239  		return strconv.FormatInt(secs, 10)
	 240  	}
	 241  
	 242  	// If seconds is negative, then perform correction.
	 243  	sign := ""
	 244  	if secs < 0 {
	 245  		sign = "-"						 // Remember sign
	 246  		secs = -(secs + 1)		 // Add a second to secs
	 247  		nsecs = -(nsecs - 1e9) // Take that second away from nsecs
	 248  	}
	 249  	return strings.TrimRight(fmt.Sprintf("%s%d.%09d", sign, secs, nsecs), "0")
	 250  }
	 251  
	 252  // parsePAXRecord parses the input PAX record string into a key-value pair.
	 253  // If parsing is successful, it will slice off the currently read record and
	 254  // return the remainder as r.
	 255  func parsePAXRecord(s string) (k, v, r string, err error) {
	 256  	// The size field ends at the first space.
	 257  	sp := strings.IndexByte(s, ' ')
	 258  	if sp == -1 {
	 259  		return "", "", s, ErrHeader
	 260  	}
	 261  
	 262  	// Parse the first token as a decimal integer.
	 263  	n, perr := strconv.ParseInt(s[:sp], 10, 0) // Intentionally parse as native int
	 264  	if perr != nil || n < 5 || int64(len(s)) < n {
	 265  		return "", "", s, ErrHeader
	 266  	}
	 267  
	 268  	afterSpace := int64(sp + 1)
	 269  	beforeLastNewLine := n - 1
	 270  	// In some cases, "length" was perhaps padded/malformed, and
	 271  	// trying to index past where the space supposedly is goes past
	 272  	// the end of the actual record.
	 273  	// For example:
	 274  	//		"0000000000000000000000000000000030 mtime=1432668921.098285006\n30 ctime=2147483649.15163319"
	 275  	//																	^		 ^
	 276  	//																	|		 |
	 277  	//																	|	afterSpace=35
	 278  	//																	|
	 279  	//													beforeLastNewLine=29
	 280  	// yet indexOf(firstSpace) MUST BE before endOfRecord.
	 281  	//
	 282  	// See https://golang.org/issues/40196.
	 283  	if afterSpace >= beforeLastNewLine {
	 284  		return "", "", s, ErrHeader
	 285  	}
	 286  
	 287  	// Extract everything between the space and the final newline.
	 288  	rec, nl, rem := s[afterSpace:beforeLastNewLine], s[beforeLastNewLine:n], s[n:]
	 289  	if nl != "\n" {
	 290  		return "", "", s, ErrHeader
	 291  	}
	 292  
	 293  	// The first equals separates the key from the value.
	 294  	eq := strings.IndexByte(rec, '=')
	 295  	if eq == -1 {
	 296  		return "", "", s, ErrHeader
	 297  	}
	 298  	k, v = rec[:eq], rec[eq+1:]
	 299  
	 300  	if !validPAXRecord(k, v) {
	 301  		return "", "", s, ErrHeader
	 302  	}
	 303  	return k, v, rem, nil
	 304  }
	 305  
	 306  // formatPAXRecord formats a single PAX record, prefixing it with the
	 307  // appropriate length.
	 308  func formatPAXRecord(k, v string) (string, error) {
	 309  	if !validPAXRecord(k, v) {
	 310  		return "", ErrHeader
	 311  	}
	 312  
	 313  	const padding = 3 // Extra padding for ' ', '=', and '\n'
	 314  	size := len(k) + len(v) + padding
	 315  	size += len(strconv.Itoa(size))
	 316  	record := strconv.Itoa(size) + " " + k + "=" + v + "\n"
	 317  
	 318  	// Final adjustment if adding size field increased the record size.
	 319  	if len(record) != size {
	 320  		size = len(record)
	 321  		record = strconv.Itoa(size) + " " + k + "=" + v + "\n"
	 322  	}
	 323  	return record, nil
	 324  }
	 325  
	 326  // validPAXRecord reports whether the key-value pair is valid where each
	 327  // record is formatted as:
	 328  //	"%d %s=%s\n" % (size, key, value)
	 329  //
	 330  // Keys and values should be UTF-8, but the number of bad writers out there
	 331  // forces us to be a more liberal.
	 332  // Thus, we only reject all keys with NUL, and only reject NULs in values
	 333  // for the PAX version of the USTAR string fields.
	 334  // The key must not contain an '=' character.
	 335  func validPAXRecord(k, v string) bool {
	 336  	if k == "" || strings.IndexByte(k, '=') >= 0 {
	 337  		return false
	 338  	}
	 339  	switch k {
	 340  	case paxPath, paxLinkpath, paxUname, paxGname:
	 341  		return !hasNUL(v)
	 342  	default:
	 343  		return !hasNUL(k)
	 344  	}
	 345  }
	 346
View as plain text