2 * Copyright (c) 2005, 2006 Rene Scharfe
8 #include "run-command.h"
10 #define RECORDSIZE (512)
11 #define BLOCKSIZE (RECORDSIZE * 20)
13 static char block
[BLOCKSIZE
];
14 static unsigned long offset
;
16 static int tar_umask
= 002;
18 static int write_tar_filter_archive(const struct archiver
*ar
,
19 struct archiver_args
*args
);
22 * This is the max value that a ustar size header can specify, as it is fixed
23 * at 11 octal digits. POSIX specifies that we switch to extended headers at
26 * Likewise for the mtime (which happens to use a buffer of the same size).
28 #define USTAR_MAX_SIZE 077777777777UL
29 #define USTAR_MAX_MTIME 077777777777UL
31 /* writes out the whole block, but only if it is full */
32 static void write_if_needed(void)
34 if (offset
== BLOCKSIZE
) {
35 write_or_die(1, block
, BLOCKSIZE
);
41 * queues up writes, so that all our write(2) calls write exactly one
42 * full block; pads writes to RECORDSIZE
44 static void do_write_blocked(const void *data
, unsigned long size
)
46 const char *buf
= data
;
49 unsigned long chunk
= BLOCKSIZE
- offset
;
52 memcpy(block
+ offset
, buf
, chunk
);
58 while (size
>= BLOCKSIZE
) {
59 write_or_die(1, buf
, BLOCKSIZE
);
64 memcpy(block
+ offset
, buf
, size
);
69 static void finish_record(void)
72 tail
= offset
% RECORDSIZE
;
74 memset(block
+ offset
, 0, RECORDSIZE
- tail
);
75 offset
+= RECORDSIZE
- tail
;
80 static void write_blocked(const void *data
, unsigned long size
)
82 do_write_blocked(data
, size
);
87 * The end of tar archives is marked by 2*512 nul bytes and after that
88 * follows the rest of the block (if any).
90 static void write_trailer(void)
92 int tail
= BLOCKSIZE
- offset
;
93 memset(block
+ offset
, 0, tail
);
94 write_or_die(1, block
, BLOCKSIZE
);
95 if (tail
< 2 * RECORDSIZE
) {
96 memset(block
, 0, offset
);
97 write_or_die(1, block
, BLOCKSIZE
);
102 * queues up writes, so that all our write(2) calls write exactly one
103 * full block; pads writes to RECORDSIZE
105 static int stream_blocked(const unsigned char *sha1
)
107 struct git_istream
*st
;
108 enum object_type type
;
113 st
= open_istream(sha1
, &type
, &sz
, NULL
);
115 return error("cannot stream blob %s", sha1_to_hex(sha1
));
117 readlen
= read_istream(st
, buf
, sizeof(buf
));
120 do_write_blocked(buf
, readlen
);
129 * pax extended header records have the format "%u %s=%s\n". %u contains
130 * the size of the whole string (including the %u), the first %s is the
131 * keyword, the second one is the value. This function constructs such a
132 * string and appends it to a struct strbuf.
134 static void strbuf_append_ext_header(struct strbuf
*sb
, const char *keyword
,
135 const char *value
, unsigned int valuelen
)
140 len
= 1 + 1 + strlen(keyword
) + 1 + valuelen
+ 1;
141 for (tmp
= len
; tmp
> 9; tmp
/= 10)
144 strbuf_grow(sb
, len
);
145 strbuf_addf(sb
, "%u %s=", len
, keyword
);
146 strbuf_add(sb
, value
, valuelen
);
147 strbuf_addch(sb
, '\n');
151 * Like strbuf_append_ext_header, but for numeric values.
153 static void strbuf_append_ext_header_uint(struct strbuf
*sb
,
157 char buf
[40]; /* big enough for 2^128 in decimal, plus NUL */
160 len
= xsnprintf(buf
, sizeof(buf
), "%"PRIuMAX
, value
);
161 strbuf_append_ext_header(sb
, keyword
, buf
, len
);
164 static unsigned int ustar_header_chksum(const struct ustar_header
*header
)
166 const unsigned char *p
= (const unsigned char *)header
;
167 unsigned int chksum
= 0;
168 while (p
< (const unsigned char *)header
->chksum
)
170 chksum
+= sizeof(header
->chksum
) * ' ';
171 p
+= sizeof(header
->chksum
);
172 while (p
< (const unsigned char *)header
+ sizeof(struct ustar_header
))
177 static size_t get_path_prefix(const char *path
, size_t pathlen
, size_t maxlen
)
180 if (i
> 1 && path
[i
- 1] == '/')
186 } while (i
> 0 && path
[i
] != '/');
190 static void prepare_header(struct archiver_args
*args
,
191 struct ustar_header
*header
,
192 unsigned int mode
, unsigned long size
)
194 xsnprintf(header
->mode
, sizeof(header
->mode
), "%07o", mode
& 07777);
195 xsnprintf(header
->size
, sizeof(header
->size
), "%011lo", S_ISREG(mode
) ? size
: 0);
196 xsnprintf(header
->mtime
, sizeof(header
->mtime
), "%011lo", (unsigned long) args
->time
);
198 xsnprintf(header
->uid
, sizeof(header
->uid
), "%07o", 0);
199 xsnprintf(header
->gid
, sizeof(header
->gid
), "%07o", 0);
200 strlcpy(header
->uname
, "root", sizeof(header
->uname
));
201 strlcpy(header
->gname
, "root", sizeof(header
->gname
));
202 xsnprintf(header
->devmajor
, sizeof(header
->devmajor
), "%07o", 0);
203 xsnprintf(header
->devminor
, sizeof(header
->devminor
), "%07o", 0);
205 memcpy(header
->magic
, "ustar", 6);
206 memcpy(header
->version
, "00", 2);
208 xsnprintf(header
->chksum
, sizeof(header
->chksum
), "%07o", ustar_header_chksum(header
));
211 static int write_extended_header(struct archiver_args
*args
,
212 const unsigned char *sha1
,
213 const void *buffer
, unsigned long size
)
215 struct ustar_header header
;
217 memset(&header
, 0, sizeof(header
));
218 *header
.typeflag
= TYPEFLAG_EXT_HEADER
;
220 xsnprintf(header
.name
, sizeof(header
.name
), "%s.paxheader", sha1_to_hex(sha1
));
221 prepare_header(args
, &header
, mode
, size
);
222 write_blocked(&header
, sizeof(header
));
223 write_blocked(buffer
, size
);
227 static int write_tar_entry(struct archiver_args
*args
,
228 const unsigned char *sha1
,
229 const char *path
, size_t pathlen
,
232 struct ustar_header header
;
233 struct strbuf ext_header
= STRBUF_INIT
;
234 unsigned int old_mode
= mode
;
235 unsigned long size
, size_in_header
;
239 memset(&header
, 0, sizeof(header
));
241 if (S_ISDIR(mode
) || S_ISGITLINK(mode
)) {
242 *header
.typeflag
= TYPEFLAG_DIR
;
243 mode
= (mode
| 0777) & ~tar_umask
;
244 } else if (S_ISLNK(mode
)) {
245 *header
.typeflag
= TYPEFLAG_LNK
;
247 } else if (S_ISREG(mode
)) {
248 *header
.typeflag
= TYPEFLAG_REG
;
249 mode
= (mode
| ((mode
& 0100) ? 0777 : 0666)) & ~tar_umask
;
251 return error("unsupported file mode: 0%o (SHA1: %s)",
252 mode
, sha1_to_hex(sha1
));
254 if (pathlen
> sizeof(header
.name
)) {
255 size_t plen
= get_path_prefix(path
, pathlen
,
256 sizeof(header
.prefix
));
257 size_t rest
= pathlen
- plen
- 1;
258 if (plen
> 0 && rest
<= sizeof(header
.name
)) {
259 memcpy(header
.prefix
, path
, plen
);
260 memcpy(header
.name
, path
+ plen
+ 1, rest
);
262 xsnprintf(header
.name
, sizeof(header
.name
), "%s.data",
264 strbuf_append_ext_header(&ext_header
, "path",
268 memcpy(header
.name
, path
, pathlen
);
270 if (S_ISREG(mode
) && !args
->convert
&&
271 sha1_object_info(sha1
, &size
) == OBJ_BLOB
&&
272 size
> big_file_threshold
)
274 else if (S_ISLNK(mode
) || S_ISREG(mode
)) {
275 enum object_type type
;
276 buffer
= sha1_file_to_archive(args
, path
, sha1
, old_mode
, &type
, &size
);
278 return error("cannot read %s", sha1_to_hex(sha1
));
285 if (size
> sizeof(header
.linkname
)) {
286 xsnprintf(header
.linkname
, sizeof(header
.linkname
),
287 "see %s.paxheader", sha1_to_hex(sha1
));
288 strbuf_append_ext_header(&ext_header
, "linkpath",
291 memcpy(header
.linkname
, buffer
, size
);
294 size_in_header
= size
;
295 if (S_ISREG(mode
) && size
> USTAR_MAX_SIZE
) {
297 strbuf_append_ext_header_uint(&ext_header
, "size", size
);
300 prepare_header(args
, &header
, mode
, size_in_header
);
302 if (ext_header
.len
> 0) {
303 err
= write_extended_header(args
, sha1
, ext_header
.buf
,
310 strbuf_release(&ext_header
);
311 write_blocked(&header
, sizeof(header
));
312 if (S_ISREG(mode
) && size
> 0) {
314 write_blocked(buffer
, size
);
316 err
= stream_blocked(sha1
);
322 static void write_global_extended_header(struct archiver_args
*args
)
324 const unsigned char *sha1
= args
->commit_sha1
;
325 struct strbuf ext_header
= STRBUF_INIT
;
326 struct ustar_header header
;
330 strbuf_append_ext_header(&ext_header
, "comment",
331 sha1_to_hex(sha1
), 40);
332 if (args
->time
> USTAR_MAX_MTIME
) {
333 strbuf_append_ext_header_uint(&ext_header
, "mtime",
335 args
->time
= USTAR_MAX_MTIME
;
341 memset(&header
, 0, sizeof(header
));
342 *header
.typeflag
= TYPEFLAG_GLOBAL_HEADER
;
344 xsnprintf(header
.name
, sizeof(header
.name
), "pax_global_header");
345 prepare_header(args
, &header
, mode
, ext_header
.len
);
346 write_blocked(&header
, sizeof(header
));
347 write_blocked(ext_header
.buf
, ext_header
.len
);
348 strbuf_release(&ext_header
);
351 static struct archiver
**tar_filters
;
352 static int nr_tar_filters
;
353 static int alloc_tar_filters
;
355 static struct archiver
*find_tar_filter(const char *name
, int len
)
358 for (i
= 0; i
< nr_tar_filters
; i
++) {
359 struct archiver
*ar
= tar_filters
[i
];
360 if (!strncmp(ar
->name
, name
, len
) && !ar
->name
[len
])
366 static int tar_filter_config(const char *var
, const char *value
, void *data
)
373 if (parse_config_key(var
, "tar", &name
, &namelen
, &type
) < 0 || !name
)
376 ar
= find_tar_filter(name
, namelen
);
378 ar
= xcalloc(1, sizeof(*ar
));
379 ar
->name
= xmemdupz(name
, namelen
);
380 ar
->write_archive
= write_tar_filter_archive
;
381 ar
->flags
= ARCHIVER_WANT_COMPRESSION_LEVELS
;
382 ALLOC_GROW(tar_filters
, nr_tar_filters
+ 1, alloc_tar_filters
);
383 tar_filters
[nr_tar_filters
++] = ar
;
386 if (!strcmp(type
, "command")) {
388 return config_error_nonbool(var
);
390 ar
->data
= xstrdup(value
);
393 if (!strcmp(type
, "remote")) {
394 if (git_config_bool(var
, value
))
395 ar
->flags
|= ARCHIVER_REMOTE
;
397 ar
->flags
&= ~ARCHIVER_REMOTE
;
404 static int git_tar_config(const char *var
, const char *value
, void *cb
)
406 if (!strcmp(var
, "tar.umask")) {
407 if (value
&& !strcmp(value
, "user")) {
408 tar_umask
= umask(0);
411 tar_umask
= git_config_int(var
, value
);
416 return tar_filter_config(var
, value
, cb
);
419 static int write_tar_archive(const struct archiver
*ar
,
420 struct archiver_args
*args
)
424 write_global_extended_header(args
);
425 err
= write_archive_entries(args
, write_tar_entry
);
431 static int write_tar_filter_archive(const struct archiver
*ar
,
432 struct archiver_args
*args
)
434 struct strbuf cmd
= STRBUF_INIT
;
435 struct child_process filter
= CHILD_PROCESS_INIT
;
440 die("BUG: tar-filter archiver called with no filter defined");
442 strbuf_addstr(&cmd
, ar
->data
);
443 if (args
->compression_level
>= 0)
444 strbuf_addf(&cmd
, " -%d", args
->compression_level
);
449 filter
.use_shell
= 1;
452 if (start_command(&filter
) < 0)
453 die_errno("unable to start '%s' filter", argv
[0]);
455 if (dup2(filter
.in
, 1) < 0)
456 die_errno("unable to redirect descriptor");
459 r
= write_tar_archive(ar
, args
);
462 if (finish_command(&filter
) != 0)
463 die("'%s' filter reported error", argv
[0]);
465 strbuf_release(&cmd
);
469 static struct archiver tar_archiver
= {
475 void init_tar_archiver(void)
478 register_archiver(&tar_archiver
);
480 tar_filter_config("tar.tgz.command", "gzip -cn", NULL
);
481 tar_filter_config("tar.tgz.remote", "true", NULL
);
482 tar_filter_config("tar.tar.gz.command", "gzip -cn", NULL
);
483 tar_filter_config("tar.tar.gz.remote", "true", NULL
);
484 git_config(git_tar_config
, NULL
);
485 for (i
= 0; i
< nr_tar_filters
; i
++) {
486 /* omit any filters that never had a command configured */
487 if (tar_filters
[i
]->data
)
488 register_archiver(tar_filters
[i
]);