4 #include "object-store.h"
9 #include "parse-options.h"
10 #include "unpack-trees.h"
13 static char const * const archive_usage
[] = {
14 N_("git archive [<options>] <tree-ish> [<path>...]"),
15 N_("git archive --list"),
16 N_("git archive --remote <repo> [--exec <cmd>] [<options>] <tree-ish> [<path>...]"),
17 N_("git archive --remote <repo> [--exec <cmd>] --list"),
21 static const struct archiver
**archivers
;
22 static int nr_archivers
;
23 static int alloc_archivers
;
24 static int remote_allow_unreachable
;
26 void register_archiver(struct archiver
*ar
)
28 ALLOC_GROW(archivers
, nr_archivers
+ 1, alloc_archivers
);
29 archivers
[nr_archivers
++] = ar
;
32 static void format_subst(const struct commit
*commit
,
33 const char *src
, size_t len
,
37 struct strbuf fmt
= STRBUF_INIT
;
38 struct pretty_print_context ctx
= {0};
39 ctx
.date_mode
.type
= DATE_NORMAL
;
40 ctx
.abbrev
= DEFAULT_ABBREV
;
43 to_free
= strbuf_detach(buf
, NULL
);
47 b
= memmem(src
, len
, "$Format:", 8);
50 c
= memchr(b
+ 8, '$', (src
+ len
) - b
- 8);
55 strbuf_add(&fmt
, b
+ 8, c
- b
- 8);
57 strbuf_add(buf
, src
, b
- src
);
58 format_commit_message(commit
, fmt
.buf
, buf
, &ctx
);
62 strbuf_add(buf
, src
, len
);
67 void *object_file_to_archive(const struct archiver_args
*args
,
68 const char *path
, const struct object_id
*oid
,
69 unsigned int mode
, enum object_type
*type
,
73 const struct commit
*commit
= args
->convert
? args
->commit
: NULL
;
75 path
+= args
->baselen
;
76 buffer
= read_object_file(oid
, type
, sizep
);
77 if (buffer
&& S_ISREG(mode
)) {
78 struct strbuf buf
= STRBUF_INIT
;
81 strbuf_attach(&buf
, buffer
, *sizep
, *sizep
+ 1);
82 convert_to_working_tree(args
->repo
->index
, path
, buf
.buf
, buf
.len
, &buf
);
84 format_subst(commit
, buf
.buf
, buf
.len
, &buf
);
85 buffer
= strbuf_detach(&buf
, &size
);
98 char path
[FLEX_ARRAY
];
101 struct archiver_context
{
102 struct archiver_args
*args
;
103 write_archive_entry_fn_t write_entry
;
104 struct directory
*bottom
;
107 static const struct attr_check
*get_archive_attrs(struct index_state
*istate
,
110 static struct attr_check
*check
;
112 check
= attr_check_initl("export-ignore", "export-subst", NULL
);
113 git_check_attr(istate
, path
, check
);
117 static int check_attr_export_ignore(const struct attr_check
*check
)
119 return check
&& ATTR_TRUE(check
->items
[0].value
);
122 static int check_attr_export_subst(const struct attr_check
*check
)
124 return check
&& ATTR_TRUE(check
->items
[1].value
);
127 static int write_archive_entry(const struct object_id
*oid
, const char *base
,
128 int baselen
, const char *filename
, unsigned mode
, int stage
,
131 static struct strbuf path
= STRBUF_INIT
;
132 struct archiver_context
*c
= context
;
133 struct archiver_args
*args
= c
->args
;
134 write_archive_entry_fn_t write_entry
= c
->write_entry
;
136 const char *path_without_prefix
;
140 strbuf_grow(&path
, PATH_MAX
);
141 strbuf_add(&path
, args
->base
, args
->baselen
);
142 strbuf_add(&path
, base
, baselen
);
143 strbuf_addstr(&path
, filename
);
144 if (S_ISDIR(mode
) || S_ISGITLINK(mode
))
145 strbuf_addch(&path
, '/');
146 path_without_prefix
= path
.buf
+ args
->baselen
;
148 if (!S_ISDIR(mode
)) {
149 const struct attr_check
*check
;
150 check
= get_archive_attrs(args
->repo
->index
, path_without_prefix
);
151 if (check_attr_export_ignore(check
))
153 args
->convert
= check_attr_export_subst(check
);
156 if (S_ISDIR(mode
) || S_ISGITLINK(mode
)) {
158 fprintf(stderr
, "%.*s\n", (int)path
.len
, path
.buf
);
159 err
= write_entry(args
, oid
, path
.buf
, path
.len
, mode
);
162 return (S_ISDIR(mode
) ? READ_TREE_RECURSIVE
: 0);
166 fprintf(stderr
, "%.*s\n", (int)path
.len
, path
.buf
);
167 return write_entry(args
, oid
, path
.buf
, path
.len
, mode
);
170 static void queue_directory(const unsigned char *sha1
,
171 struct strbuf
*base
, const char *filename
,
172 unsigned mode
, int stage
, struct archiver_context
*c
)
175 size_t len
= st_add4(base
->len
, 1, strlen(filename
), 1);
176 d
= xmalloc(st_add(sizeof(*d
), len
));
178 d
->baselen
= base
->len
;
182 d
->len
= xsnprintf(d
->path
, len
, "%.*s%s/", (int)base
->len
, base
->buf
, filename
);
183 hashcpy(d
->oid
.hash
, sha1
);
186 static int write_directory(struct archiver_context
*c
)
188 struct directory
*d
= c
->bottom
;
194 d
->path
[d
->len
- 1] = '\0'; /* no trailing slash */
196 write_directory(c
) ||
197 write_archive_entry(&d
->oid
, d
->path
, d
->baselen
,
198 d
->path
+ d
->baselen
, d
->mode
,
199 d
->stage
, c
) != READ_TREE_RECURSIVE
;
204 static int queue_or_write_archive_entry(const struct object_id
*oid
,
205 struct strbuf
*base
, const char *filename
,
206 unsigned mode
, int stage
, void *context
)
208 struct archiver_context
*c
= context
;
211 !(base
->len
>= c
->bottom
->len
&&
212 !strncmp(base
->buf
, c
->bottom
->path
, c
->bottom
->len
))) {
213 struct directory
*next
= c
->bottom
->up
;
219 size_t baselen
= base
->len
;
220 const struct attr_check
*check
;
222 /* Borrow base, but restore its original value when done. */
223 strbuf_addstr(base
, filename
);
224 strbuf_addch(base
, '/');
225 check
= get_archive_attrs(c
->args
->repo
->index
, base
->buf
);
226 strbuf_setlen(base
, baselen
);
228 if (check_attr_export_ignore(check
))
230 queue_directory(oid
->hash
, base
, filename
,
232 return READ_TREE_RECURSIVE
;
235 if (write_directory(c
))
237 return write_archive_entry(oid
, base
->buf
, base
->len
, filename
, mode
,
241 int write_archive_entries(struct archiver_args
*args
,
242 write_archive_entry_fn_t write_entry
)
244 struct archiver_context context
;
245 struct unpack_trees_options opts
;
249 if (args
->baselen
> 0 && args
->base
[args
->baselen
- 1] == '/') {
250 size_t len
= args
->baselen
;
252 while (len
> 1 && args
->base
[len
- 2] == '/')
255 fprintf(stderr
, "%.*s\n", (int)len
, args
->base
);
256 err
= write_entry(args
, &args
->tree
->object
.oid
, args
->base
,
262 memset(&context
, 0, sizeof(context
));
264 context
.write_entry
= write_entry
;
267 * Setup index and instruct attr to read index only
269 if (!args
->worktree_attributes
) {
270 memset(&opts
, 0, sizeof(opts
));
273 opts
.src_index
= args
->repo
->index
;
274 opts
.dst_index
= args
->repo
->index
;
275 opts
.fn
= oneway_merge
;
276 init_tree_desc(&t
, args
->tree
->buffer
, args
->tree
->size
);
277 if (unpack_trees(1, &t
, &opts
))
279 git_attr_set_direction(GIT_ATTR_INDEX
);
282 err
= read_tree_recursive(args
->tree
, "", 0, 0, &args
->pathspec
,
283 queue_or_write_archive_entry
,
285 if (err
== READ_TREE_RECURSIVE
)
287 while (context
.bottom
) {
288 struct directory
*next
= context
.bottom
->up
;
289 free(context
.bottom
);
290 context
.bottom
= next
;
295 static const struct archiver
*lookup_archiver(const char *name
)
302 for (i
= 0; i
< nr_archivers
; i
++) {
303 if (!strcmp(name
, archivers
[i
]->name
))
309 struct path_exists_context
{
310 struct pathspec pathspec
;
311 struct archiver_args
*args
;
314 static int reject_entry(const struct object_id
*oid
, struct strbuf
*base
,
315 const char *filename
, unsigned mode
,
316 int stage
, void *context
)
319 struct path_exists_context
*ctx
= context
;
322 struct strbuf sb
= STRBUF_INIT
;
323 strbuf_addbuf(&sb
, base
);
324 strbuf_addstr(&sb
, filename
);
325 if (!match_pathspec(ctx
->args
->repo
->index
,
327 sb
.buf
, sb
.len
, 0, NULL
, 1))
328 ret
= READ_TREE_RECURSIVE
;
334 static int path_exists(struct archiver_args
*args
, const char *path
)
336 const char *paths
[] = { path
, NULL
};
337 struct path_exists_context ctx
;
341 parse_pathspec(&ctx
.pathspec
, 0, 0, "", paths
);
342 ctx
.pathspec
.recursive
= 1;
343 ret
= read_tree_recursive(args
->tree
, "", 0, 0, &ctx
.pathspec
,
345 clear_pathspec(&ctx
.pathspec
);
349 static void parse_pathspec_arg(const char **pathspec
,
350 struct archiver_args
*ar_args
)
353 * must be consistent with parse_pathspec in path_exists()
354 * Also if pathspec patterns are dependent, we're in big
355 * trouble as we test each one separately
357 parse_pathspec(&ar_args
->pathspec
, 0,
358 PATHSPEC_PREFER_FULL
,
360 ar_args
->pathspec
.recursive
= 1;
363 if (**pathspec
&& !path_exists(ar_args
, *pathspec
))
364 die(_("pathspec '%s' did not match any files"), *pathspec
);
370 static void parse_treeish_arg(const char **argv
,
371 struct archiver_args
*ar_args
, const char *prefix
,
374 const char *name
= argv
[0];
375 const unsigned char *commit_sha1
;
378 const struct commit
*commit
;
379 struct object_id oid
;
381 /* Remotes are only allowed to fetch actual refs */
382 if (remote
&& !remote_allow_unreachable
) {
384 const char *colon
= strchrnul(name
, ':');
385 int refnamelen
= colon
- name
;
387 if (!dwim_ref(name
, refnamelen
, &oid
, &ref
))
388 die("no such ref: %.*s", refnamelen
, name
);
392 if (get_oid(name
, &oid
))
393 die("Not a valid object name");
395 commit
= lookup_commit_reference_gently(the_repository
, &oid
, 1);
397 commit_sha1
= commit
->object
.oid
.hash
;
398 archive_time
= commit
->date
;
401 archive_time
= time(NULL
);
404 tree
= parse_tree_indirect(&oid
);
406 die("not a tree object");
409 struct object_id tree_oid
;
413 err
= get_tree_entry(&tree
->object
.oid
, prefix
, &tree_oid
,
415 if (err
|| !S_ISDIR(mode
))
416 die("current working directory is untracked");
418 tree
= parse_tree_indirect(&tree_oid
);
420 ar_args
->tree
= tree
;
421 ar_args
->commit_sha1
= commit_sha1
;
422 ar_args
->commit
= commit
;
423 ar_args
->time
= archive_time
;
426 #define OPT__COMPR(s, v, h, p) \
427 OPT_SET_INT_F(s, NULL, v, h, p, PARSE_OPT_NONEG)
428 #define OPT__COMPR_HIDDEN(s, v, p) \
429 OPT_SET_INT_F(s, NULL, v, "", p, PARSE_OPT_NONEG | PARSE_OPT_HIDDEN)
431 static int parse_archive_args(int argc
, const char **argv
,
432 const struct archiver
**ar
, struct archiver_args
*args
,
433 const char *name_hint
, int is_remote
)
435 const char *format
= NULL
;
436 const char *base
= NULL
;
437 const char *remote
= NULL
;
438 const char *exec
= NULL
;
439 const char *output
= NULL
;
440 int compression_level
= -1;
444 int worktree_attributes
= 0;
445 struct option opts
[] = {
447 OPT_STRING(0, "format", &format
, N_("fmt"), N_("archive format")),
448 OPT_STRING(0, "prefix", &base
, N_("prefix"),
449 N_("prepend prefix to each pathname in the archive")),
450 OPT_STRING('o', "output", &output
, N_("file"),
451 N_("write the archive to this file")),
452 OPT_BOOL(0, "worktree-attributes", &worktree_attributes
,
453 N_("read .gitattributes in working directory")),
454 OPT__VERBOSE(&verbose
, N_("report archived files on stderr")),
455 OPT__COMPR('0', &compression_level
, N_("store only"), 0),
456 OPT__COMPR('1', &compression_level
, N_("compress faster"), 1),
457 OPT__COMPR_HIDDEN('2', &compression_level
, 2),
458 OPT__COMPR_HIDDEN('3', &compression_level
, 3),
459 OPT__COMPR_HIDDEN('4', &compression_level
, 4),
460 OPT__COMPR_HIDDEN('5', &compression_level
, 5),
461 OPT__COMPR_HIDDEN('6', &compression_level
, 6),
462 OPT__COMPR_HIDDEN('7', &compression_level
, 7),
463 OPT__COMPR_HIDDEN('8', &compression_level
, 8),
464 OPT__COMPR('9', &compression_level
, N_("compress better"), 9),
466 OPT_BOOL('l', "list", &list
,
467 N_("list supported archive formats")),
469 OPT_STRING(0, "remote", &remote
, N_("repo"),
470 N_("retrieve the archive from remote repository <repo>")),
471 OPT_STRING(0, "exec", &exec
, N_("command"),
472 N_("path to the remote git-upload-archive command")),
476 argc
= parse_options(argc
, argv
, NULL
, opts
, archive_usage
, 0);
479 die(_("Unexpected option --remote"));
481 die(_("Option --exec can only be used together with --remote"));
483 die(_("Unexpected option --output"));
489 for (i
= 0; i
< nr_archivers
; i
++)
490 if (!is_remote
|| archivers
[i
]->flags
& ARCHIVER_REMOTE
)
491 printf("%s\n", archivers
[i
]->name
);
495 if (!format
&& name_hint
)
496 format
= archive_format_from_filename(name_hint
);
500 /* We need at least one parameter -- tree-ish */
502 usage_with_options(archive_usage
, opts
);
503 *ar
= lookup_archiver(format
);
504 if (!*ar
|| (is_remote
&& !((*ar
)->flags
& ARCHIVER_REMOTE
)))
505 die(_("Unknown archive format '%s'"), format
);
507 args
->compression_level
= Z_DEFAULT_COMPRESSION
;
508 if (compression_level
!= -1) {
509 if ((*ar
)->flags
& ARCHIVER_WANT_COMPRESSION_LEVELS
)
510 args
->compression_level
= compression_level
;
512 die(_("Argument not supported for format '%s': -%d"),
513 format
, compression_level
);
516 args
->verbose
= verbose
;
518 args
->baselen
= strlen(base
);
519 args
->worktree_attributes
= worktree_attributes
;
524 int write_archive(int argc
, const char **argv
, const char *prefix
,
525 struct repository
*repo
,
526 const char *name_hint
, int remote
)
528 const struct archiver
*ar
= NULL
;
529 struct archiver_args args
;
531 git_config_get_bool("uploadarchive.allowunreachable", &remote_allow_unreachable
);
532 git_config(git_default_config
, NULL
);
538 argc
= parse_archive_args(argc
, argv
, &ar
, &args
, name_hint
, remote
);
539 if (!startup_info
->have_repository
) {
541 * We know this will die() with an error, so we could just
542 * die ourselves; but its error message will be more specific
543 * than what we could write here.
545 setup_git_directory();
548 parse_treeish_arg(argv
, &args
, prefix
, remote
);
549 parse_pathspec_arg(argv
+ 1, &args
);
551 return ar
->write_archive(ar
, &args
);
554 static int match_extension(const char *filename
, const char *ext
)
556 int prefixlen
= strlen(filename
) - strlen(ext
);
559 * We need 1 character for the '.', and 1 character to ensure that the
560 * prefix is non-empty (k.e., we don't match .tar.gz with no actual
563 if (prefixlen
< 2 || filename
[prefixlen
- 1] != '.')
565 return !strcmp(filename
+ prefixlen
, ext
);
568 const char *archive_format_from_filename(const char *filename
)
572 for (i
= 0; i
< nr_archivers
; i
++)
573 if (match_extension(filename
, archivers
[i
]->name
))
574 return archivers
[i
]->name
;