Source file src/archive/tar/writer.go

Documentation: archive/tar

		 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  package tar
		 6  
		 7  import (
		 8  	"fmt"
		 9  	"io"
		10  	"path"
		11  	"sort"
		12  	"strings"
		13  	"time"
		14  )
		15  
		16  // Writer provides sequential writing of a tar archive.
		17  // Write.WriteHeader begins a new file with the provided Header,
		18  // and then Writer can be treated as an io.Writer to supply that file's data.
		19  type Writer struct {
		20  	w		io.Writer
		21  	pad	int64			// Amount of padding to write after current file entry
		22  	curr fileWriter // Writer for current file entry
		23  	hdr	Header		 // Shallow copy of Header that is safe for mutations
		24  	blk	block			// Buffer to use as temporary local storage
		25  
		26  	// err is a persistent error.
		27  	// It is only the responsibility of every exported method of Writer to
		28  	// ensure that this error is sticky.
		29  	err error
		30  }
		31  
		32  // NewWriter creates a new Writer writing to w.
		33  func NewWriter(w io.Writer) *Writer {
		34  	return &Writer{w: w, curr: &regFileWriter{w, 0}}
		35  }
		36  
		37  type fileWriter interface {
		38  	io.Writer
		39  	fileState
		40  
		41  	ReadFrom(io.Reader) (int64, error)
		42  }
		43  
		44  // Flush finishes writing the current file's block padding.
		45  // The current file must be fully written before Flush can be called.
		46  //
		47  // This is unnecessary as the next call to WriteHeader or Close
		48  // will implicitly flush out the file's padding.
		49  func (tw *Writer) Flush() error {
		50  	if tw.err != nil {
		51  		return tw.err
		52  	}
		53  	if nb := tw.curr.LogicalRemaining(); nb > 0 {
		54  		return fmt.Errorf("archive/tar: missed writing %d bytes", nb)
		55  	}
		56  	if _, tw.err = tw.w.Write(zeroBlock[:tw.pad]); tw.err != nil {
		57  		return tw.err
		58  	}
		59  	tw.pad = 0
		60  	return nil
		61  }
		62  
		63  // WriteHeader writes hdr and prepares to accept the file's contents.
		64  // The Header.Size determines how many bytes can be written for the next file.
		65  // If the current file is not fully written, then this returns an error.
		66  // This implicitly flushes any padding necessary before writing the header.
		67  func (tw *Writer) WriteHeader(hdr *Header) error {
		68  	if err := tw.Flush(); err != nil {
		69  		return err
		70  	}
		71  	tw.hdr = *hdr // Shallow copy of Header
		72  
		73  	// Avoid usage of the legacy TypeRegA flag, and automatically promote
		74  	// it to use TypeReg or TypeDir.
		75  	if tw.hdr.Typeflag == TypeRegA {
		76  		if strings.HasSuffix(tw.hdr.Name, "/") {
		77  			tw.hdr.Typeflag = TypeDir
		78  		} else {
		79  			tw.hdr.Typeflag = TypeReg
		80  		}
		81  	}
		82  
		83  	// Round ModTime and ignore AccessTime and ChangeTime unless
		84  	// the format is explicitly chosen.
		85  	// This ensures nominal usage of WriteHeader (without specifying the format)
		86  	// does not always result in the PAX format being chosen, which
		87  	// causes a 1KiB increase to every header.
		88  	if tw.hdr.Format == FormatUnknown {
		89  		tw.hdr.ModTime = tw.hdr.ModTime.Round(time.Second)
		90  		tw.hdr.AccessTime = time.Time{}
		91  		tw.hdr.ChangeTime = time.Time{}
		92  	}
		93  
		94  	allowedFormats, paxHdrs, err := tw.hdr.allowedFormats()
		95  	switch {
		96  	case allowedFormats.has(FormatUSTAR):
		97  		tw.err = tw.writeUSTARHeader(&tw.hdr)
		98  		return tw.err
		99  	case allowedFormats.has(FormatPAX):
	 100  		tw.err = tw.writePAXHeader(&tw.hdr, paxHdrs)
	 101  		return tw.err
	 102  	case allowedFormats.has(FormatGNU):
	 103  		tw.err = tw.writeGNUHeader(&tw.hdr)
	 104  		return tw.err
	 105  	default:
	 106  		return err // Non-fatal error
	 107  	}
	 108  }
	 109  
	 110  func (tw *Writer) writeUSTARHeader(hdr *Header) error {
	 111  	// Check if we can use USTAR prefix/suffix splitting.
	 112  	var namePrefix string
	 113  	if prefix, suffix, ok := splitUSTARPath(hdr.Name); ok {
	 114  		namePrefix, hdr.Name = prefix, suffix
	 115  	}
	 116  
	 117  	// Pack the main header.
	 118  	var f formatter
	 119  	blk := tw.templateV7Plus(hdr, f.formatString, f.formatOctal)
	 120  	f.formatString(blk.USTAR().Prefix(), namePrefix)
	 121  	blk.SetFormat(FormatUSTAR)
	 122  	if f.err != nil {
	 123  		return f.err // Should never happen since header is validated
	 124  	}
	 125  	return tw.writeRawHeader(blk, hdr.Size, hdr.Typeflag)
	 126  }
	 127  
	 128  func (tw *Writer) writePAXHeader(hdr *Header, paxHdrs map[string]string) error {
	 129  	realName, realSize := hdr.Name, hdr.Size
	 130  
	 131  	// TODO(dsnet): Re-enable this when adding sparse support.
	 132  	// See https://golang.org/issue/22735
	 133  	/*
	 134  		// Handle sparse files.
	 135  		var spd sparseDatas
	 136  		var spb []byte
	 137  		if len(hdr.SparseHoles) > 0 {
	 138  			sph := append([]sparseEntry{}, hdr.SparseHoles...) // Copy sparse map
	 139  			sph = alignSparseEntries(sph, hdr.Size)
	 140  			spd = invertSparseEntries(sph, hdr.Size)
	 141  
	 142  			// Format the sparse map.
	 143  			hdr.Size = 0 // Replace with encoded size
	 144  			spb = append(strconv.AppendInt(spb, int64(len(spd)), 10), '\n')
	 145  			for _, s := range spd {
	 146  				hdr.Size += s.Length
	 147  				spb = append(strconv.AppendInt(spb, s.Offset, 10), '\n')
	 148  				spb = append(strconv.AppendInt(spb, s.Length, 10), '\n')
	 149  			}
	 150  			pad := blockPadding(int64(len(spb)))
	 151  			spb = append(spb, zeroBlock[:pad]...)
	 152  			hdr.Size += int64(len(spb)) // Accounts for encoded sparse map
	 153  
	 154  			// Add and modify appropriate PAX records.
	 155  			dir, file := path.Split(realName)
	 156  			hdr.Name = path.Join(dir, "GNUSparseFile.0", file)
	 157  			paxHdrs[paxGNUSparseMajor] = "1"
	 158  			paxHdrs[paxGNUSparseMinor] = "0"
	 159  			paxHdrs[paxGNUSparseName] = realName
	 160  			paxHdrs[paxGNUSparseRealSize] = strconv.FormatInt(realSize, 10)
	 161  			paxHdrs[paxSize] = strconv.FormatInt(hdr.Size, 10)
	 162  			delete(paxHdrs, paxPath) // Recorded by paxGNUSparseName
	 163  		}
	 164  	*/
	 165  	_ = realSize
	 166  
	 167  	// Write PAX records to the output.
	 168  	isGlobal := hdr.Typeflag == TypeXGlobalHeader
	 169  	if len(paxHdrs) > 0 || isGlobal {
	 170  		// Sort keys for deterministic ordering.
	 171  		var keys []string
	 172  		for k := range paxHdrs {
	 173  			keys = append(keys, k)
	 174  		}
	 175  		sort.Strings(keys)
	 176  
	 177  		// Write each record to a buffer.
	 178  		var buf strings.Builder
	 179  		for _, k := range keys {
	 180  			rec, err := formatPAXRecord(k, paxHdrs[k])
	 181  			if err != nil {
	 182  				return err
	 183  			}
	 184  			buf.WriteString(rec)
	 185  		}
	 186  
	 187  		// Write the extended header file.
	 188  		var name string
	 189  		var flag byte
	 190  		if isGlobal {
	 191  			name = realName
	 192  			if name == "" {
	 193  				name = "GlobalHead.0.0"
	 194  			}
	 195  			flag = TypeXGlobalHeader
	 196  		} else {
	 197  			dir, file := path.Split(realName)
	 198  			name = path.Join(dir, "PaxHeaders.0", file)
	 199  			flag = TypeXHeader
	 200  		}
	 201  		data := buf.String()
	 202  		if err := tw.writeRawFile(name, data, flag, FormatPAX); err != nil || isGlobal {
	 203  			return err // Global headers return here
	 204  		}
	 205  	}
	 206  
	 207  	// Pack the main header.
	 208  	var f formatter // Ignore errors since they are expected
	 209  	fmtStr := func(b []byte, s string) { f.formatString(b, toASCII(s)) }
	 210  	blk := tw.templateV7Plus(hdr, fmtStr, f.formatOctal)
	 211  	blk.SetFormat(FormatPAX)
	 212  	if err := tw.writeRawHeader(blk, hdr.Size, hdr.Typeflag); err != nil {
	 213  		return err
	 214  	}
	 215  
	 216  	// TODO(dsnet): Re-enable this when adding sparse support.
	 217  	// See https://golang.org/issue/22735
	 218  	/*
	 219  		// Write the sparse map and setup the sparse writer if necessary.
	 220  		if len(spd) > 0 {
	 221  			// Use tw.curr since the sparse map is accounted for in hdr.Size.
	 222  			if _, err := tw.curr.Write(spb); err != nil {
	 223  				return err
	 224  			}
	 225  			tw.curr = &sparseFileWriter{tw.curr, spd, 0}
	 226  		}
	 227  	*/
	 228  	return nil
	 229  }
	 230  
	 231  func (tw *Writer) writeGNUHeader(hdr *Header) error {
	 232  	// Use long-link files if Name or Linkname exceeds the field size.
	 233  	const longName = "././@LongLink"
	 234  	if len(hdr.Name) > nameSize {
	 235  		data := hdr.Name + "\x00"
	 236  		if err := tw.writeRawFile(longName, data, TypeGNULongName, FormatGNU); err != nil {
	 237  			return err
	 238  		}
	 239  	}
	 240  	if len(hdr.Linkname) > nameSize {
	 241  		data := hdr.Linkname + "\x00"
	 242  		if err := tw.writeRawFile(longName, data, TypeGNULongLink, FormatGNU); err != nil {
	 243  			return err
	 244  		}
	 245  	}
	 246  
	 247  	// Pack the main header.
	 248  	var f formatter // Ignore errors since they are expected
	 249  	var spd sparseDatas
	 250  	var spb []byte
	 251  	blk := tw.templateV7Plus(hdr, f.formatString, f.formatNumeric)
	 252  	if !hdr.AccessTime.IsZero() {
	 253  		f.formatNumeric(blk.GNU().AccessTime(), hdr.AccessTime.Unix())
	 254  	}
	 255  	if !hdr.ChangeTime.IsZero() {
	 256  		f.formatNumeric(blk.GNU().ChangeTime(), hdr.ChangeTime.Unix())
	 257  	}
	 258  	// TODO(dsnet): Re-enable this when adding sparse support.
	 259  	// See https://golang.org/issue/22735
	 260  	/*
	 261  		if hdr.Typeflag == TypeGNUSparse {
	 262  			sph := append([]sparseEntry{}, hdr.SparseHoles...) // Copy sparse map
	 263  			sph = alignSparseEntries(sph, hdr.Size)
	 264  			spd = invertSparseEntries(sph, hdr.Size)
	 265  
	 266  			// Format the sparse map.
	 267  			formatSPD := func(sp sparseDatas, sa sparseArray) sparseDatas {
	 268  				for i := 0; len(sp) > 0 && i < sa.MaxEntries(); i++ {
	 269  					f.formatNumeric(sa.Entry(i).Offset(), sp[0].Offset)
	 270  					f.formatNumeric(sa.Entry(i).Length(), sp[0].Length)
	 271  					sp = sp[1:]
	 272  				}
	 273  				if len(sp) > 0 {
	 274  					sa.IsExtended()[0] = 1
	 275  				}
	 276  				return sp
	 277  			}
	 278  			sp2 := formatSPD(spd, blk.GNU().Sparse())
	 279  			for len(sp2) > 0 {
	 280  				var spHdr block
	 281  				sp2 = formatSPD(sp2, spHdr.Sparse())
	 282  				spb = append(spb, spHdr[:]...)
	 283  			}
	 284  
	 285  			// Update size fields in the header block.
	 286  			realSize := hdr.Size
	 287  			hdr.Size = 0 // Encoded size; does not account for encoded sparse map
	 288  			for _, s := range spd {
	 289  				hdr.Size += s.Length
	 290  			}
	 291  			copy(blk.V7().Size(), zeroBlock[:]) // Reset field
	 292  			f.formatNumeric(blk.V7().Size(), hdr.Size)
	 293  			f.formatNumeric(blk.GNU().RealSize(), realSize)
	 294  		}
	 295  	*/
	 296  	blk.SetFormat(FormatGNU)
	 297  	if err := tw.writeRawHeader(blk, hdr.Size, hdr.Typeflag); err != nil {
	 298  		return err
	 299  	}
	 300  
	 301  	// Write the extended sparse map and setup the sparse writer if necessary.
	 302  	if len(spd) > 0 {
	 303  		// Use tw.w since the sparse map is not accounted for in hdr.Size.
	 304  		if _, err := tw.w.Write(spb); err != nil {
	 305  			return err
	 306  		}
	 307  		tw.curr = &sparseFileWriter{tw.curr, spd, 0}
	 308  	}
	 309  	return nil
	 310  }
	 311  
	 312  type (
	 313  	stringFormatter func([]byte, string)
	 314  	numberFormatter func([]byte, int64)
	 315  )
	 316  
	 317  // templateV7Plus fills out the V7 fields of a block using values from hdr.
	 318  // It also fills out fields (uname, gname, devmajor, devminor) that are
	 319  // shared in the USTAR, PAX, and GNU formats using the provided formatters.
	 320  //
	 321  // The block returned is only valid until the next call to
	 322  // templateV7Plus or writeRawFile.
	 323  func (tw *Writer) templateV7Plus(hdr *Header, fmtStr stringFormatter, fmtNum numberFormatter) *block {
	 324  	tw.blk.Reset()
	 325  
	 326  	modTime := hdr.ModTime
	 327  	if modTime.IsZero() {
	 328  		modTime = time.Unix(0, 0)
	 329  	}
	 330  
	 331  	v7 := tw.blk.V7()
	 332  	v7.TypeFlag()[0] = hdr.Typeflag
	 333  	fmtStr(v7.Name(), hdr.Name)
	 334  	fmtStr(v7.LinkName(), hdr.Linkname)
	 335  	fmtNum(v7.Mode(), hdr.Mode)
	 336  	fmtNum(v7.UID(), int64(hdr.Uid))
	 337  	fmtNum(v7.GID(), int64(hdr.Gid))
	 338  	fmtNum(v7.Size(), hdr.Size)
	 339  	fmtNum(v7.ModTime(), modTime.Unix())
	 340  
	 341  	ustar := tw.blk.USTAR()
	 342  	fmtStr(ustar.UserName(), hdr.Uname)
	 343  	fmtStr(ustar.GroupName(), hdr.Gname)
	 344  	fmtNum(ustar.DevMajor(), hdr.Devmajor)
	 345  	fmtNum(ustar.DevMinor(), hdr.Devminor)
	 346  
	 347  	return &tw.blk
	 348  }
	 349  
	 350  // writeRawFile writes a minimal file with the given name and flag type.
	 351  // It uses format to encode the header format and will write data as the body.
	 352  // It uses default values for all of the other fields (as BSD and GNU tar does).
	 353  func (tw *Writer) writeRawFile(name, data string, flag byte, format Format) error {
	 354  	tw.blk.Reset()
	 355  
	 356  	// Best effort for the filename.
	 357  	name = toASCII(name)
	 358  	if len(name) > nameSize {
	 359  		name = name[:nameSize]
	 360  	}
	 361  	name = strings.TrimRight(name, "/")
	 362  
	 363  	var f formatter
	 364  	v7 := tw.blk.V7()
	 365  	v7.TypeFlag()[0] = flag
	 366  	f.formatString(v7.Name(), name)
	 367  	f.formatOctal(v7.Mode(), 0)
	 368  	f.formatOctal(v7.UID(), 0)
	 369  	f.formatOctal(v7.GID(), 0)
	 370  	f.formatOctal(v7.Size(), int64(len(data))) // Must be < 8GiB
	 371  	f.formatOctal(v7.ModTime(), 0)
	 372  	tw.blk.SetFormat(format)
	 373  	if f.err != nil {
	 374  		return f.err // Only occurs if size condition is violated
	 375  	}
	 376  
	 377  	// Write the header and data.
	 378  	if err := tw.writeRawHeader(&tw.blk, int64(len(data)), flag); err != nil {
	 379  		return err
	 380  	}
	 381  	_, err := io.WriteString(tw, data)
	 382  	return err
	 383  }
	 384  
	 385  // writeRawHeader writes the value of blk, regardless of its value.
	 386  // It sets up the Writer such that it can accept a file of the given size.
	 387  // If the flag is a special header-only flag, then the size is treated as zero.
	 388  func (tw *Writer) writeRawHeader(blk *block, size int64, flag byte) error {
	 389  	if err := tw.Flush(); err != nil {
	 390  		return err
	 391  	}
	 392  	if _, err := tw.w.Write(blk[:]); err != nil {
	 393  		return err
	 394  	}
	 395  	if isHeaderOnlyType(flag) {
	 396  		size = 0
	 397  	}
	 398  	tw.curr = &regFileWriter{tw.w, size}
	 399  	tw.pad = blockPadding(size)
	 400  	return nil
	 401  }
	 402  
	 403  // splitUSTARPath splits a path according to USTAR prefix and suffix rules.
	 404  // If the path is not splittable, then it will return ("", "", false).
	 405  func splitUSTARPath(name string) (prefix, suffix string, ok bool) {
	 406  	length := len(name)
	 407  	if length <= nameSize || !isASCII(name) {
	 408  		return "", "", false
	 409  	} else if length > prefixSize+1 {
	 410  		length = prefixSize + 1
	 411  	} else if name[length-1] == '/' {
	 412  		length--
	 413  	}
	 414  
	 415  	i := strings.LastIndex(name[:length], "/")
	 416  	nlen := len(name) - i - 1 // nlen is length of suffix
	 417  	plen := i								 // plen is length of prefix
	 418  	if i <= 0 || nlen > nameSize || nlen == 0 || plen > prefixSize {
	 419  		return "", "", false
	 420  	}
	 421  	return name[:i], name[i+1:], true
	 422  }
	 423  
	 424  // Write writes to the current file in the tar archive.
	 425  // Write returns the error ErrWriteTooLong if more than
	 426  // Header.Size bytes are written after WriteHeader.
	 427  //
	 428  // Calling Write on special types like TypeLink, TypeSymlink, TypeChar,
	 429  // TypeBlock, TypeDir, and TypeFifo returns (0, ErrWriteTooLong) regardless
	 430  // of what the Header.Size claims.
	 431  func (tw *Writer) Write(b []byte) (int, error) {
	 432  	if tw.err != nil {
	 433  		return 0, tw.err
	 434  	}
	 435  	n, err := tw.curr.Write(b)
	 436  	if err != nil && err != ErrWriteTooLong {
	 437  		tw.err = err
	 438  	}
	 439  	return n, err
	 440  }
	 441  
	 442  // readFrom populates the content of the current file by reading from r.
	 443  // The bytes read must match the number of remaining bytes in the current file.
	 444  //
	 445  // If the current file is sparse and r is an io.ReadSeeker,
	 446  // then readFrom uses Seek to skip past holes defined in Header.SparseHoles,
	 447  // assuming that skipped regions are all NULs.
	 448  // This always reads the last byte to ensure r is the right size.
	 449  //
	 450  // TODO(dsnet): Re-export this when adding sparse file support.
	 451  // See https://golang.org/issue/22735
	 452  func (tw *Writer) readFrom(r io.Reader) (int64, error) {
	 453  	if tw.err != nil {
	 454  		return 0, tw.err
	 455  	}
	 456  	n, err := tw.curr.ReadFrom(r)
	 457  	if err != nil && err != ErrWriteTooLong {
	 458  		tw.err = err
	 459  	}
	 460  	return n, err
	 461  }
	 462  
	 463  // Close closes the tar archive by flushing the padding, and writing the footer.
	 464  // If the current file (from a prior call to WriteHeader) is not fully written,
	 465  // then this returns an error.
	 466  func (tw *Writer) Close() error {
	 467  	if tw.err == ErrWriteAfterClose {
	 468  		return nil
	 469  	}
	 470  	if tw.err != nil {
	 471  		return tw.err
	 472  	}
	 473  
	 474  	// Trailer: two zero blocks.
	 475  	err := tw.Flush()
	 476  	for i := 0; i < 2 && err == nil; i++ {
	 477  		_, err = tw.w.Write(zeroBlock[:])
	 478  	}
	 479  
	 480  	// Ensure all future actions are invalid.
	 481  	tw.err = ErrWriteAfterClose
	 482  	return err // Report IO errors
	 483  }
	 484  
	 485  // regFileWriter is a fileWriter for writing data to a regular file entry.
	 486  type regFileWriter struct {
	 487  	w	io.Writer // Underlying Writer
	 488  	nb int64		 // Number of remaining bytes to write
	 489  }
	 490  
	 491  func (fw *regFileWriter) Write(b []byte) (n int, err error) {
	 492  	overwrite := int64(len(b)) > fw.nb
	 493  	if overwrite {
	 494  		b = b[:fw.nb]
	 495  	}
	 496  	if len(b) > 0 {
	 497  		n, err = fw.w.Write(b)
	 498  		fw.nb -= int64(n)
	 499  	}
	 500  	switch {
	 501  	case err != nil:
	 502  		return n, err
	 503  	case overwrite:
	 504  		return n, ErrWriteTooLong
	 505  	default:
	 506  		return n, nil
	 507  	}
	 508  }
	 509  
	 510  func (fw *regFileWriter) ReadFrom(r io.Reader) (int64, error) {
	 511  	return io.Copy(struct{ io.Writer }{fw}, r)
	 512  }
	 513  
	 514  func (fw regFileWriter) LogicalRemaining() int64 {
	 515  	return fw.nb
	 516  }
	 517  func (fw regFileWriter) PhysicalRemaining() int64 {
	 518  	return fw.nb
	 519  }
	 520  
	 521  // sparseFileWriter is a fileWriter for writing data to a sparse file entry.
	 522  type sparseFileWriter struct {
	 523  	fw	fileWriter	// Underlying fileWriter
	 524  	sp	sparseDatas // Normalized list of data fragments
	 525  	pos int64			 // Current position in sparse file
	 526  }
	 527  
	 528  func (sw *sparseFileWriter) Write(b []byte) (n int, err error) {
	 529  	overwrite := int64(len(b)) > sw.LogicalRemaining()
	 530  	if overwrite {
	 531  		b = b[:sw.LogicalRemaining()]
	 532  	}
	 533  
	 534  	b0 := b
	 535  	endPos := sw.pos + int64(len(b))
	 536  	for endPos > sw.pos && err == nil {
	 537  		var nf int // Bytes written in fragment
	 538  		dataStart, dataEnd := sw.sp[0].Offset, sw.sp[0].endOffset()
	 539  		if sw.pos < dataStart { // In a hole fragment
	 540  			bf := b[:min(int64(len(b)), dataStart-sw.pos)]
	 541  			nf, err = zeroWriter{}.Write(bf)
	 542  		} else { // In a data fragment
	 543  			bf := b[:min(int64(len(b)), dataEnd-sw.pos)]
	 544  			nf, err = sw.fw.Write(bf)
	 545  		}
	 546  		b = b[nf:]
	 547  		sw.pos += int64(nf)
	 548  		if sw.pos >= dataEnd && len(sw.sp) > 1 {
	 549  			sw.sp = sw.sp[1:] // Ensure last fragment always remains
	 550  		}
	 551  	}
	 552  
	 553  	n = len(b0) - len(b)
	 554  	switch {
	 555  	case err == ErrWriteTooLong:
	 556  		return n, errMissData // Not possible; implies bug in validation logic
	 557  	case err != nil:
	 558  		return n, err
	 559  	case sw.LogicalRemaining() == 0 && sw.PhysicalRemaining() > 0:
	 560  		return n, errUnrefData // Not possible; implies bug in validation logic
	 561  	case overwrite:
	 562  		return n, ErrWriteTooLong
	 563  	default:
	 564  		return n, nil
	 565  	}
	 566  }
	 567  
	 568  func (sw *sparseFileWriter) ReadFrom(r io.Reader) (n int64, err error) {
	 569  	rs, ok := r.(io.ReadSeeker)
	 570  	if ok {
	 571  		if _, err := rs.Seek(0, io.SeekCurrent); err != nil {
	 572  			ok = false // Not all io.Seeker can really seek
	 573  		}
	 574  	}
	 575  	if !ok {
	 576  		return io.Copy(struct{ io.Writer }{sw}, r)
	 577  	}
	 578  
	 579  	var readLastByte bool
	 580  	pos0 := sw.pos
	 581  	for sw.LogicalRemaining() > 0 && !readLastByte && err == nil {
	 582  		var nf int64 // Size of fragment
	 583  		dataStart, dataEnd := sw.sp[0].Offset, sw.sp[0].endOffset()
	 584  		if sw.pos < dataStart { // In a hole fragment
	 585  			nf = dataStart - sw.pos
	 586  			if sw.PhysicalRemaining() == 0 {
	 587  				readLastByte = true
	 588  				nf--
	 589  			}
	 590  			_, err = rs.Seek(nf, io.SeekCurrent)
	 591  		} else { // In a data fragment
	 592  			nf = dataEnd - sw.pos
	 593  			nf, err = io.CopyN(sw.fw, rs, nf)
	 594  		}
	 595  		sw.pos += nf
	 596  		if sw.pos >= dataEnd && len(sw.sp) > 1 {
	 597  			sw.sp = sw.sp[1:] // Ensure last fragment always remains
	 598  		}
	 599  	}
	 600  
	 601  	// If the last fragment is a hole, then seek to 1-byte before EOF, and
	 602  	// read a single byte to ensure the file is the right size.
	 603  	if readLastByte && err == nil {
	 604  		_, err = mustReadFull(rs, []byte{0})
	 605  		sw.pos++
	 606  	}
	 607  
	 608  	n = sw.pos - pos0
	 609  	switch {
	 610  	case err == io.EOF:
	 611  		return n, io.ErrUnexpectedEOF
	 612  	case err == ErrWriteTooLong:
	 613  		return n, errMissData // Not possible; implies bug in validation logic
	 614  	case err != nil:
	 615  		return n, err
	 616  	case sw.LogicalRemaining() == 0 && sw.PhysicalRemaining() > 0:
	 617  		return n, errUnrefData // Not possible; implies bug in validation logic
	 618  	default:
	 619  		return n, ensureEOF(rs)
	 620  	}
	 621  }
	 622  
	 623  func (sw sparseFileWriter) LogicalRemaining() int64 {
	 624  	return sw.sp[len(sw.sp)-1].endOffset() - sw.pos
	 625  }
	 626  func (sw sparseFileWriter) PhysicalRemaining() int64 {
	 627  	return sw.fw.PhysicalRemaining()
	 628  }
	 629  
	 630  // zeroWriter may only be written with NULs, otherwise it returns errWriteHole.
	 631  type zeroWriter struct{}
	 632  
	 633  func (zeroWriter) Write(b []byte) (int, error) {
	 634  	for i, c := range b {
	 635  		if c != 0 {
	 636  			return i, errWriteHole
	 637  		}
	 638  	}
	 639  	return len(b), nil
	 640  }
	 641  
	 642  // ensureEOF checks whether r is at EOF, reporting ErrWriteTooLong if not so.
	 643  func ensureEOF(r io.Reader) error {
	 644  	n, err := tryReadFull(r, []byte{0})
	 645  	switch {
	 646  	case n > 0:
	 647  		return ErrWriteTooLong
	 648  	case err == io.EOF:
	 649  		return nil
	 650  	default:
	 651  		return err
	 652  	}
	 653  }
	 654  

View as plain text