...
Run Format

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