1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
// 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.
package tar
// TODO(dsymonds):
// - catch more errors (no first header, write after close, etc.)
import (
"bytes";
"io";
"os";
"strconv";
"strings";
)
var (
ErrWriteTooLong os.Error = os.ErrorString("write too long");
// TODO(dsymonds): remove ErrIntFieldTooBig after we implement binary extension.
ErrIntFieldTooBig os.Error = os.ErrorString("an integer header field was too big");
)
// A Writer provides sequential writing of a tar archive in POSIX.1 format.
// A tar archive consists of a sequence of files.
// Call WriteHeader to begin a new file, and then call Write to supply that file's data,
// writing at most hdr.Size bytes in total.
//
// Example:
// tw := tar.NewWriter(w);
// hdr := new(Header);
// hdr.Size = length of data in bytes;
// // populate other hdr fields as desired
// if err := tw.WriteHeader(hdr); err != nil {
// // handle error
// }
// io.Copy(data, tw);
// tw.Close();
type Writer struct {
w io.Writer;
err os.Error;
nb int64; // number of unwritten bytes for current file entry
pad int64; // amount of padding to write after current file entry
closed bool;
}
// NewWriter creates a new Writer writing to w.
func NewWriter(w io.Writer) *Writer {
return &Writer{ w: w }
}
// Flush finishes writing the current file (optional).
func (tw *Writer) Flush() os.Error {
n := tw.nb + tw.pad;
for n > 0 && tw.err == nil {
nr := n;
if nr > blockSize {
nr = blockSize;
}
var nw int;
nw, tw.err = tw.w.Write(zeroBlock[0:nr]);
n -= int64(nw);
}
tw.nb = 0;
tw.pad = 0;
return tw.err
}
// Write s into b, terminating it with a NUL if there is room.
func (tw *Writer) cString(b []byte, s string) {
if len(s) > len(b) {
if tw.err == nil {
tw.err = ErrIntFieldTooBig;
}
return
}
for i, ch := range strings.Bytes(s) {
b[i] = ch;
}
if len(s) < len(b) {
b[len(s)] = 0;
}
}
// Encode x as an octal ASCII string and write it into b with leading zeros.
func (tw *Writer) octal(b []byte, x int64) {
s := strconv.Itob64(x, 8);
// leading zeros, but leave room for a NUL.
for len(s) + 1 < len(b) {
s = "0" + s;
}
tw.cString(b, s);
}
// WriteHeader writes hdr and prepares to accept the file's contents.
// WriteHeader calls Flush if it is not the first header.
func (tw *Writer) WriteHeader(hdr *Header) os.Error {
if tw.err == nil {
tw.Flush();
}
if tw.err != nil {
return tw.err
}
tw.nb = int64(hdr.Size);
tw.pad = -tw.nb & (blockSize - 1); // blockSize is a power of two
header := make([]byte, blockSize);
s := slicer(header);
// TODO(dsymonds): handle names longer than 100 chars
nr := bytes.Copy(s.next(100), strings.Bytes(hdr.Name));
tw.octal(s.next(8), hdr.Mode); // 100:108
tw.octal(s.next(8), hdr.Uid); // 108:116
tw.octal(s.next(8), hdr.Gid); // 116:124
tw.octal(s.next(12), hdr.Size); // 124:136
tw.octal(s.next(12), hdr.Mtime); // 136:148
s.next(8); // chksum (148:156)
s.next(1)[0] = hdr.Typeflag; // 156:157
s.next(100); // linkname (157:257)
bytes.Copy(s.next(8), strings.Bytes("ustar\x0000")); // 257:265
tw.cString(s.next(32), hdr.Uname); // 265:297
tw.cString(s.next(32), hdr.Gname); // 297:329
tw.octal(s.next(8), hdr.Devmajor); // 329:337
tw.octal(s.next(8), hdr.Devminor); // 337:345
// The chksum field is terminated by a NUL and a space.
// This is different from the other octal fields.
chksum, _ := checksum(header);
tw.octal(header[148:155], chksum);
header[155] = ' ';
if tw.err != nil {
// problem with header; probably integer too big for a field.
return tw.err
}
var n int;
n, tw.err = tw.w.Write(header);
return tw.err
}
// Write writes to the current entry in the tar archive.
// Write returns the error ErrWriteTooLong if more than
// hdr.Size bytes are written after WriteHeader.
func (tw *Writer) Write(b []uint8) (n int, err os.Error) {
overwrite := false;
if int64(len(b)) > tw.nb {
b = b[0:tw.nb];
overwrite = true;
}
n, err = tw.w.Write(b);
tw.nb -= int64(n);
if err == nil && overwrite {
err = ErrWriteTooLong;
}
tw.err = err;
return
}
func (tw *Writer) Close() os.Error {
if tw.err != nil || tw.closed {
return tw.err
}
tw.Flush();
tw.closed = true;
// trailer: two zero blocks
for i := 0; i < 2; i++ {
var n int;
n, tw.err = tw.w.Write(zeroBlock);
if tw.err != nil {
break
}
}
return tw.err
}
|
