2 * Copyright (c) 2005, 2006 Rene Scharfe
11 #define RECORDSIZE (512)
12 #define BLOCKSIZE (RECORDSIZE * 20)
14 #define EXT_HEADER_PATH 1
15 #define EXT_HEADER_LINKPATH 2
17 static const char tar_tree_usage
[] = "git-tar-tree <key> [basedir]";
19 static char block
[BLOCKSIZE
];
20 static unsigned long offset
;
22 static const char *basedir
;
23 static time_t archive_time
;
26 struct path_prefix
*prev
;
30 /* tries hard to write, either succeeds or dies in the attempt */
31 static void reliable_write(void *buf
, unsigned long size
)
34 long ret
= xwrite(1, buf
, size
);
38 die("git-tar-tree: %s", strerror(errno
));
40 die("git-tar-tree: disk full?");
47 /* writes out the whole block, but only if it is full */
48 static void write_if_needed(void)
50 if (offset
== BLOCKSIZE
) {
51 reliable_write(block
, BLOCKSIZE
);
56 /* acquire the next record from the buffer; user must call write_if_needed() */
57 static char *get_record(void)
59 char *p
= block
+ offset
;
60 memset(p
, 0, RECORDSIZE
);
66 * The end of tar archives is marked by 1024 nul bytes and after that
67 * follows the rest of the block (if any).
69 static void write_trailer(void)
82 * queues up writes, so that all our write(2) calls write exactly one
83 * full block; pads writes to RECORDSIZE
85 static void write_blocked(void *buf
, unsigned long size
)
90 unsigned long chunk
= BLOCKSIZE
- offset
;
93 memcpy(block
+ offset
, buf
, chunk
);
99 while (size
>= BLOCKSIZE
) {
100 reliable_write(buf
, BLOCKSIZE
);
105 memcpy(block
+ offset
, buf
, size
);
109 tail
= offset
% RECORDSIZE
;
111 memset(block
+ offset
, 0, RECORDSIZE
- tail
);
112 offset
+= RECORDSIZE
- tail
;
118 * pax extended header records have the format "%u %s=%s\n". %u contains
119 * the size of the whole string (including the %u), the first %s is the
120 * keyword, the second one is the value. This function constructs such a
121 * string and appends it to a struct strbuf.
123 static void strbuf_append_ext_header(struct strbuf
*sb
, const char *keyword
,
124 const char *value
, unsigned int valuelen
)
130 len
= 1 + 1 + strlen(keyword
) + 1 + valuelen
+ 1;
131 for (tmp
= len
; tmp
> 9; tmp
/= 10)
134 total
= sb
->len
+ len
;
135 if (total
> sb
->alloc
) {
136 sb
->buf
= xrealloc(sb
->buf
, total
);
141 p
+= sprintf(p
, "%u %s=", len
, keyword
);
142 memcpy(p
, value
, valuelen
);
148 static unsigned int ustar_header_chksum(const struct ustar_header
*header
)
150 char *p
= (char *)header
;
151 unsigned int chksum
= 0;
152 while (p
< header
->chksum
)
154 chksum
+= sizeof(header
->chksum
) * ' ';
155 p
+= sizeof(header
->chksum
);
156 while (p
< (char *)header
+ sizeof(struct ustar_header
))
161 static void write_entry(const unsigned char *sha1
, struct strbuf
*path
,
162 unsigned int mode
, void *buffer
, unsigned long size
)
164 struct ustar_header header
;
165 struct strbuf ext_header
;
167 memset(&header
, 0, sizeof(header
));
168 ext_header
.buf
= NULL
;
169 ext_header
.len
= ext_header
.alloc
= 0;
172 *header
.typeflag
= TYPEFLAG_GLOBAL_HEADER
;
174 strcpy(header
.name
, "pax_global_header");
176 *header
.typeflag
= TYPEFLAG_EXT_HEADER
;
178 sprintf(header
.name
, "%s.paxheader", sha1_to_hex(sha1
));
181 *header
.typeflag
= TYPEFLAG_DIR
;
183 } else if (S_ISLNK(mode
)) {
184 *header
.typeflag
= TYPEFLAG_LNK
;
186 } else if (S_ISREG(mode
)) {
187 *header
.typeflag
= TYPEFLAG_REG
;
188 mode
|= (mode
& 0100) ? 0777 : 0666;
190 error("unsupported file mode: 0%o (SHA1: %s)",
191 mode
, sha1_to_hex(sha1
));
194 if (path
->len
> sizeof(header
.name
)) {
195 sprintf(header
.name
, "%s.data", sha1_to_hex(sha1
));
196 strbuf_append_ext_header(&ext_header
, "path",
197 path
->buf
, path
->len
);
199 memcpy(header
.name
, path
->buf
, path
->len
);
202 if (S_ISLNK(mode
) && buffer
) {
203 if (size
> sizeof(header
.linkname
)) {
204 sprintf(header
.linkname
, "see %s.paxheader",
206 strbuf_append_ext_header(&ext_header
, "linkpath",
209 memcpy(header
.linkname
, buffer
, size
);
212 sprintf(header
.mode
, "%07o", mode
& 07777);
213 sprintf(header
.size
, "%011lo", S_ISREG(mode
) ? size
: 0);
214 sprintf(header
.mtime
, "%011lo", archive_time
);
216 /* XXX: should we provide more meaningful info here? */
217 sprintf(header
.uid
, "%07o", 0);
218 sprintf(header
.gid
, "%07o", 0);
219 strncpy(header
.uname
, "git", 31);
220 strncpy(header
.gname
, "git", 31);
221 sprintf(header
.devmajor
, "%07o", 0);
222 sprintf(header
.devminor
, "%07o", 0);
224 memcpy(header
.magic
, "ustar", 6);
225 memcpy(header
.version
, "00", 2);
227 sprintf(header
.chksum
, "%07o", ustar_header_chksum(&header
));
229 if (ext_header
.len
> 0) {
230 write_entry(sha1
, NULL
, 0, ext_header
.buf
, ext_header
.len
);
231 free(ext_header
.buf
);
233 write_blocked(&header
, sizeof(header
));
234 if (S_ISREG(mode
) && buffer
&& size
> 0)
235 write_blocked(buffer
, size
);
238 static void append_string(char **p
, const char *s
)
240 unsigned int len
= strlen(s
);
245 static void append_char(char **p
, char c
)
251 static void append_path_prefix(char **buffer
, struct path_prefix
*prefix
)
255 append_path_prefix(buffer
, prefix
->prev
);
256 append_string(buffer
, prefix
->name
);
257 append_char(buffer
, '/');
260 static unsigned int path_prefix_len(struct path_prefix
*prefix
)
264 return path_prefix_len(prefix
->prev
) + strlen(prefix
->name
) + 1;
267 static void append_path(char **p
, int is_dir
, const char *basepath
,
268 struct path_prefix
*prefix
, const char *path
)
271 append_string(p
, basepath
);
274 append_path_prefix(p
, prefix
);
275 append_string(p
, path
);
280 static unsigned int path_len(int is_dir
, const char *basepath
,
281 struct path_prefix
*prefix
, const char *path
)
283 unsigned int len
= 0;
285 len
+= strlen(basepath
) + 1;
286 len
+= path_prefix_len(prefix
) + strlen(path
);
292 static void append_extended_header_prefix(char **p
, unsigned int size
,
295 int len
= sprintf(*p
, "%u %s=", size
, keyword
);
299 static unsigned int extended_header_len(const char *keyword
,
300 unsigned int valuelen
)
303 unsigned int len
= 1 + 1 + strlen(keyword
) + 1 + valuelen
+ 1;
311 static void append_extended_header(char **p
, const char *keyword
,
312 const char *value
, unsigned int len
)
314 unsigned int size
= extended_header_len(keyword
, len
);
315 append_extended_header_prefix(p
, size
, keyword
);
316 memcpy(*p
, value
, len
);
318 append_char(p
, '\n');
321 static void write_header(const unsigned char *, char, const char *, struct path_prefix
*,
322 const char *, unsigned int, void *, unsigned long);
324 /* stores a pax extended header directly in the block buffer */
325 static void write_extended_header(const char *headerfilename
, int is_dir
,
326 unsigned int flags
, const char *basepath
,
327 struct path_prefix
*prefix
,
328 const char *path
, unsigned int namelen
,
329 void *content
, unsigned int contentsize
)
332 unsigned int pathlen
, size
, linkpathlen
= 0;
334 size
= pathlen
= extended_header_len("path", namelen
);
335 if (flags
& EXT_HEADER_LINKPATH
) {
336 linkpathlen
= extended_header_len("linkpath", contentsize
);
339 write_header(NULL
, TYPEFLAG_EXT_HEADER
, NULL
, NULL
, headerfilename
,
340 0100600, NULL
, size
);
342 buffer
= p
= malloc(size
);
344 die("git-tar-tree: %s", strerror(errno
));
345 append_extended_header_prefix(&p
, pathlen
, "path");
346 append_path(&p
, is_dir
, basepath
, prefix
, path
);
347 append_char(&p
, '\n');
348 if (flags
& EXT_HEADER_LINKPATH
)
349 append_extended_header(&p
, "linkpath", content
, contentsize
);
350 write_blocked(buffer
, size
);
354 static void write_global_extended_header(const unsigned char *sha1
)
356 struct strbuf ext_header
;
357 ext_header
.buf
= NULL
;
358 ext_header
.len
= ext_header
.alloc
= 0;
359 strbuf_append_ext_header(&ext_header
, "comment", sha1_to_hex(sha1
), 40);
360 write_entry(NULL
, NULL
, 0, ext_header
.buf
, ext_header
.len
);
361 free(ext_header
.buf
);
364 /* stores a ustar header directly in the block buffer */
365 static void write_header(const unsigned char *sha1
, char typeflag
, const char *basepath
,
366 struct path_prefix
*prefix
, const char *path
,
367 unsigned int mode
, void *buffer
, unsigned long size
)
369 unsigned int namelen
;
371 unsigned int checksum
= 0;
373 unsigned int ext_header
= 0;
375 if (typeflag
== TYPEFLAG_AUTO
) {
377 typeflag
= TYPEFLAG_DIR
;
378 else if (S_ISLNK(mode
))
379 typeflag
= TYPEFLAG_LNK
;
381 typeflag
= TYPEFLAG_REG
;
384 namelen
= path_len(S_ISDIR(mode
), basepath
, prefix
, path
);
386 ext_header
|= EXT_HEADER_PATH
;
387 if (typeflag
== TYPEFLAG_LNK
&& size
> 100)
388 ext_header
|= EXT_HEADER_LINKPATH
;
390 /* the extended header must be written before the normal one */
392 char headerfilename
[51];
393 sprintf(headerfilename
, "%s.paxheader", sha1_to_hex(sha1
));
394 write_extended_header(headerfilename
, S_ISDIR(mode
),
395 ext_header
, basepath
, prefix
, path
,
396 namelen
, buffer
, size
);
399 header
= get_record();
402 sprintf(header
, "%s.data", sha1_to_hex(sha1
));
405 append_path(&p
, S_ISDIR(mode
), basepath
, prefix
, path
);
408 if (typeflag
== TYPEFLAG_LNK
) {
409 if (ext_header
& EXT_HEADER_LINKPATH
) {
410 sprintf(&header
[157], "see %s.paxheader",
414 strncpy(&header
[157], buffer
, size
);
420 else if (S_ISREG(mode
))
421 mode
|= (mode
& 0100) ? 0777 : 0666;
422 else if (S_ISLNK(mode
))
424 sprintf(&header
[100], "%07o", mode
& 07777);
426 /* XXX: should we provide more meaningful info here? */
427 sprintf(&header
[108], "%07o", 0); /* uid */
428 sprintf(&header
[116], "%07o", 0); /* gid */
429 strncpy(&header
[265], "git", 31); /* uname */
430 strncpy(&header
[297], "git", 31); /* gname */
432 if (S_ISDIR(mode
) || S_ISLNK(mode
))
434 sprintf(&header
[124], "%011lo", size
);
435 sprintf(&header
[136], "%011lo", archive_time
);
437 header
[156] = typeflag
;
439 memcpy(&header
[257], "ustar", 6);
440 memcpy(&header
[263], "00", 2);
442 sprintf(&header
[329], "%07o", 0); /* devmajor */
443 sprintf(&header
[337], "%07o", 0); /* devminor */
445 memset(&header
[148], ' ', 8);
446 for (i
= 0; i
< RECORDSIZE
; i
++)
447 checksum
+= header
[i
];
448 sprintf(&header
[148], "%07o", checksum
& 0x1fffff);
453 static void traverse_tree(struct tree_desc
*tree
,
454 struct path_prefix
*prefix
)
456 struct path_prefix this_prefix
;
457 this_prefix
.prev
= prefix
;
461 const unsigned char *sha1
;
465 unsigned long eltsize
;
467 sha1
= tree_entry_extract(tree
, &name
, &mode
);
468 update_tree_entry(tree
);
470 eltbuf
= read_sha1_file(sha1
, elttype
, &eltsize
);
472 die("cannot read %s", sha1_to_hex(sha1
));
473 write_header(sha1
, TYPEFLAG_AUTO
, basedir
,
474 prefix
, name
, mode
, eltbuf
, eltsize
);
476 struct tree_desc subtree
;
477 subtree
.buf
= eltbuf
;
478 subtree
.size
= eltsize
;
479 this_prefix
.name
= name
;
480 traverse_tree(&subtree
, &this_prefix
);
481 } else if (!S_ISLNK(mode
)) {
482 write_blocked(eltbuf
, eltsize
);
488 int main(int argc
, char **argv
)
490 unsigned char sha1
[20], tree_sha1
[20];
491 struct commit
*commit
;
492 struct tree_desc tree
;
494 setup_git_directory();
501 if (get_sha1(argv
[1], sha1
) < 0)
502 usage(tar_tree_usage
);
505 usage(tar_tree_usage
);
508 commit
= lookup_commit_reference_gently(sha1
, 1);
510 write_global_extended_header(commit
->object
.sha1
);
511 archive_time
= commit
->date
;
513 tree
.buf
= read_object_with_reference(sha1
, "tree", &tree
.size
,
516 die("not a reference to a tag, commit or tree object: %s",
519 archive_time
= time(NULL
);
521 write_header(tree_sha1
, TYPEFLAG_DIR
, NULL
, NULL
,
522 basedir
, 040777, NULL
, 0);
523 traverse_tree(&tree
, NULL
);