1 #include "git-compat-util.h"
5 #include "environment.h"
12 #include "object-store-ll.h"
15 #include "tree-walk.h"
18 #include "parse-options.h"
19 #include "unpack-trees.h"
22 static char const * const archive_usage
[] = {
23 N_("git archive [<options>] <tree-ish> [<path>...]"),
25 N_("git archive --remote <repo> [--exec <cmd>] [<options>] <tree-ish> [<path>...]"),
26 N_("git archive --remote <repo> [--exec <cmd>] --list"),
30 static const struct archiver
**archivers
;
31 static int nr_archivers
;
32 static int alloc_archivers
;
33 static int remote_allow_unreachable
;
35 void register_archiver(struct archiver
*ar
)
37 ALLOC_GROW(archivers
, nr_archivers
+ 1, alloc_archivers
);
38 archivers
[nr_archivers
++] = ar
;
41 void init_archivers(void)
47 static void format_subst(const struct commit
*commit
,
48 const char *src
, size_t len
,
49 struct strbuf
*buf
, struct pretty_print_context
*ctx
)
52 struct strbuf fmt
= STRBUF_INIT
;
55 to_free
= strbuf_detach(buf
, NULL
);
59 b
= memmem(src
, len
, "$Format:", 8);
62 c
= memchr(b
+ 8, '$', (src
+ len
) - b
- 8);
67 strbuf_add(&fmt
, b
+ 8, c
- b
- 8);
69 strbuf_add(buf
, src
, b
- src
);
70 repo_format_commit_message(the_repository
, commit
, fmt
.buf
,
75 strbuf_add(buf
, src
, len
);
80 static void *object_file_to_archive(const struct archiver_args
*args
,
82 const struct object_id
*oid
,
84 enum object_type
*type
,
88 const struct commit
*commit
= args
->convert
? args
->commit
: NULL
;
89 struct checkout_metadata meta
;
91 init_checkout_metadata(&meta
, args
->refname
,
92 args
->commit_oid
? args
->commit_oid
:
93 (args
->tree
? &args
->tree
->object
.oid
: NULL
), oid
);
95 path
+= args
->baselen
;
96 buffer
= repo_read_object_file(the_repository
, oid
, type
, sizep
);
97 if (buffer
&& S_ISREG(mode
)) {
98 struct strbuf buf
= STRBUF_INIT
;
101 strbuf_attach(&buf
, buffer
, *sizep
, *sizep
+ 1);
102 convert_to_working_tree(args
->repo
->index
, path
, buf
.buf
, buf
.len
, &buf
, &meta
);
104 format_subst(commit
, buf
.buf
, buf
.len
, &buf
, args
->pretty_ctx
);
105 buffer
= strbuf_detach(&buf
, &size
);
113 struct directory
*up
;
114 struct object_id oid
;
117 char path
[FLEX_ARRAY
];
120 struct archiver_context
{
121 struct archiver_args
*args
;
122 write_archive_entry_fn_t write_entry
;
123 struct directory
*bottom
;
126 static const struct attr_check
*get_archive_attrs(struct index_state
*istate
,
129 static struct attr_check
*check
;
131 check
= attr_check_initl("export-ignore", "export-subst", NULL
);
132 git_check_attr(istate
, path
, check
);
136 static int check_attr_export_ignore(const struct attr_check
*check
)
138 return check
&& ATTR_TRUE(check
->items
[0].value
);
141 static int check_attr_export_subst(const struct attr_check
*check
)
143 return check
&& ATTR_TRUE(check
->items
[1].value
);
146 static int write_archive_entry(const struct object_id
*oid
, const char *base
,
147 int baselen
, const char *filename
, unsigned mode
,
150 static struct strbuf path
= STRBUF_INIT
;
151 struct archiver_context
*c
= context
;
152 struct archiver_args
*args
= c
->args
;
153 write_archive_entry_fn_t write_entry
= c
->write_entry
;
155 const char *path_without_prefix
;
158 enum object_type type
;
162 strbuf_grow(&path
, PATH_MAX
);
163 strbuf_add(&path
, args
->base
, args
->baselen
);
164 strbuf_add(&path
, base
, baselen
);
165 strbuf_addstr(&path
, filename
);
166 if (S_ISDIR(mode
) || S_ISGITLINK(mode
))
167 strbuf_addch(&path
, '/');
168 path_without_prefix
= path
.buf
+ args
->baselen
;
170 if (!S_ISDIR(mode
)) {
171 const struct attr_check
*check
;
172 check
= get_archive_attrs(args
->repo
->index
, path_without_prefix
);
173 if (check_attr_export_ignore(check
))
175 args
->convert
= check_attr_export_subst(check
);
179 static struct strbuf new_path
= STRBUF_INIT
;
180 static struct strbuf buf
= STRBUF_INIT
;
183 rel
= relative_path(path_without_prefix
, args
->prefix
, &buf
);
186 * We don't add an entry for the current working
187 * directory when we are at the root; skip it also when
188 * we're in a subdirectory or submodule. Skip entries
191 if (!strcmp(rel
, "./") || starts_with(rel
, "../"))
192 return S_ISDIR(mode
) ? READ_TREE_RECURSIVE
: 0;
194 /* rel can refer to path, so don't edit it in place */
195 strbuf_reset(&new_path
);
196 strbuf_add(&new_path
, args
->base
, args
->baselen
);
197 strbuf_addstr(&new_path
, rel
);
198 strbuf_swap(&path
, &new_path
);
202 fprintf(stderr
, "%.*s\n", (int)path
.len
, path
.buf
);
204 if (S_ISDIR(mode
) || S_ISGITLINK(mode
)) {
205 err
= write_entry(args
, oid
, path
.buf
, path
.len
, mode
, NULL
, 0);
208 return (S_ISDIR(mode
) ? READ_TREE_RECURSIVE
: 0);
212 if (S_ISREG(mode
) && !args
->convert
&&
213 oid_object_info(args
->repo
, oid
, &size
) == OBJ_BLOB
&&
214 size
> big_file_threshold
)
215 return write_entry(args
, oid
, path
.buf
, path
.len
, mode
, NULL
, size
);
217 buffer
= object_file_to_archive(args
, path
.buf
, oid
, mode
, &type
, &size
);
219 return error(_("cannot read '%s'"), oid_to_hex(oid
));
220 err
= write_entry(args
, oid
, path
.buf
, path
.len
, mode
, buffer
, size
);
225 static void queue_directory(const struct object_id
*oid
,
226 struct strbuf
*base
, const char *filename
,
227 unsigned mode
, struct archiver_context
*c
)
230 size_t len
= st_add4(base
->len
, 1, strlen(filename
), 1);
231 d
= xmalloc(st_add(sizeof(*d
), len
));
233 d
->baselen
= base
->len
;
236 d
->len
= xsnprintf(d
->path
, len
, "%.*s%s/", (int)base
->len
, base
->buf
, filename
);
237 oidcpy(&d
->oid
, oid
);
240 static int write_directory(struct archiver_context
*c
)
242 struct directory
*d
= c
->bottom
;
248 d
->path
[d
->len
- 1] = '\0'; /* no trailing slash */
250 write_directory(c
) ||
251 write_archive_entry(&d
->oid
, d
->path
, d
->baselen
,
252 d
->path
+ d
->baselen
, d
->mode
,
253 c
) != READ_TREE_RECURSIVE
;
258 static int queue_or_write_archive_entry(const struct object_id
*oid
,
259 struct strbuf
*base
, const char *filename
,
260 unsigned mode
, void *context
)
262 struct archiver_context
*c
= context
;
265 !(base
->len
>= c
->bottom
->len
&&
266 !strncmp(base
->buf
, c
->bottom
->path
, c
->bottom
->len
))) {
267 struct directory
*next
= c
->bottom
->up
;
273 size_t baselen
= base
->len
;
274 const struct attr_check
*check
;
276 /* Borrow base, but restore its original value when done. */
277 strbuf_addstr(base
, filename
);
278 strbuf_addch(base
, '/');
279 check
= get_archive_attrs(c
->args
->repo
->index
, base
->buf
);
280 strbuf_setlen(base
, baselen
);
282 if (check_attr_export_ignore(check
))
284 queue_directory(oid
, base
, filename
, mode
, c
);
285 return READ_TREE_RECURSIVE
;
288 if (write_directory(c
))
290 return write_archive_entry(oid
, base
->buf
, base
->len
, filename
, mode
,
294 struct extra_file_info
{
300 int write_archive_entries(struct archiver_args
*args
,
301 write_archive_entry_fn_t write_entry
)
303 struct archiver_context context
;
304 struct unpack_trees_options opts
;
307 struct strbuf path_in_archive
= STRBUF_INIT
;
308 struct strbuf content
= STRBUF_INIT
;
309 struct object_id fake_oid
;
312 oidcpy(&fake_oid
, null_oid());
314 if (args
->baselen
> 0 && args
->base
[args
->baselen
- 1] == '/') {
315 size_t len
= args
->baselen
;
317 while (len
> 1 && args
->base
[len
- 2] == '/')
320 fprintf(stderr
, "%.*s\n", (int)len
, args
->base
);
321 err
= write_entry(args
, &args
->tree
->object
.oid
, args
->base
,
322 len
, 040777, NULL
, 0);
327 memset(&context
, 0, sizeof(context
));
329 context
.write_entry
= write_entry
;
332 * Setup index and instruct attr to read index only
334 if (!args
->worktree_attributes
) {
335 memset(&opts
, 0, sizeof(opts
));
338 opts
.src_index
= args
->repo
->index
;
339 opts
.dst_index
= args
->repo
->index
;
340 opts
.fn
= oneway_merge
;
341 init_tree_desc(&t
, args
->tree
->buffer
, args
->tree
->size
);
342 if (unpack_trees(1, &t
, &opts
))
344 git_attr_set_direction(GIT_ATTR_INDEX
);
347 err
= read_tree(args
->repo
, args
->tree
,
349 queue_or_write_archive_entry
,
351 if (err
== READ_TREE_RECURSIVE
)
353 while (context
.bottom
) {
354 struct directory
*next
= context
.bottom
->up
;
355 free(context
.bottom
);
356 context
.bottom
= next
;
359 for (i
= 0; i
< args
->extra_files
.nr
; i
++) {
360 struct string_list_item
*item
= args
->extra_files
.items
+ i
;
361 char *path
= item
->string
;
362 struct extra_file_info
*info
= item
->util
;
364 put_be64(fake_oid
.hash
, i
+ 1);
366 if (!info
->content
) {
367 strbuf_reset(&path_in_archive
);
369 strbuf_addstr(&path_in_archive
, info
->base
);
370 strbuf_addstr(&path_in_archive
, basename(path
));
372 strbuf_reset(&content
);
373 if (strbuf_read_file(&content
, path
, info
->stat
.st_size
) < 0)
374 err
= error_errno(_("cannot read '%s'"), path
);
376 err
= write_entry(args
, &fake_oid
, path_in_archive
.buf
,
378 canon_mode(info
->stat
.st_mode
),
379 content
.buf
, content
.len
);
381 err
= write_entry(args
, &fake_oid
,
383 canon_mode(info
->stat
.st_mode
),
384 info
->content
, info
->stat
.st_size
);
390 strbuf_release(&path_in_archive
);
391 strbuf_release(&content
);
396 static const struct archiver
*lookup_archiver(const char *name
)
403 for (i
= 0; i
< nr_archivers
; i
++) {
404 if (!strcmp(name
, archivers
[i
]->name
))
410 struct path_exists_context
{
411 struct pathspec pathspec
;
412 struct archiver_args
*args
;
415 static int reject_entry(const struct object_id
*oid UNUSED
,
417 const char *filename
, unsigned mode
,
421 struct path_exists_context
*ctx
= context
;
424 struct strbuf sb
= STRBUF_INIT
;
425 strbuf_addbuf(&sb
, base
);
426 strbuf_addstr(&sb
, filename
);
427 if (!match_pathspec(ctx
->args
->repo
->index
,
429 sb
.buf
, sb
.len
, 0, NULL
, 1))
430 ret
= READ_TREE_RECURSIVE
;
436 static int reject_outside(const struct object_id
*oid UNUSED
,
437 struct strbuf
*base
, const char *filename
,
438 unsigned mode
, void *context
)
440 struct archiver_args
*args
= context
;
441 struct strbuf buf
= STRBUF_INIT
;
442 struct strbuf path
= STRBUF_INIT
;
446 return READ_TREE_RECURSIVE
;
448 strbuf_addbuf(&path
, base
);
449 strbuf_addstr(&path
, filename
);
450 if (starts_with(relative_path(path
.buf
, args
->prefix
, &buf
), "../"))
452 strbuf_release(&buf
);
453 strbuf_release(&path
);
457 static int path_exists(struct archiver_args
*args
, const char *path
)
459 const char *paths
[] = { path
, NULL
};
460 struct path_exists_context ctx
;
464 parse_pathspec(&ctx
.pathspec
, 0, PATHSPEC_PREFER_CWD
,
465 args
->prefix
, paths
);
466 ctx
.pathspec
.recursive
= 1;
467 if (args
->prefix
&& read_tree(args
->repo
, args
->tree
, &ctx
.pathspec
,
468 reject_outside
, args
))
469 die(_("pathspec '%s' matches files outside the "
470 "current directory"), path
);
471 ret
= read_tree(args
->repo
, args
->tree
,
474 clear_pathspec(&ctx
.pathspec
);
478 static void parse_pathspec_arg(const char **pathspec
,
479 struct archiver_args
*ar_args
)
482 * must be consistent with parse_pathspec in path_exists()
483 * Also if pathspec patterns are dependent, we're in big
484 * trouble as we test each one separately
486 parse_pathspec(&ar_args
->pathspec
, 0, PATHSPEC_PREFER_CWD
,
487 ar_args
->prefix
, pathspec
);
488 ar_args
->pathspec
.recursive
= 1;
491 if (**pathspec
&& !path_exists(ar_args
, *pathspec
))
492 die(_("pathspec '%s' did not match any files"), *pathspec
);
498 static void parse_treeish_arg(const char **argv
,
499 struct archiver_args
*ar_args
, int remote
)
501 const char *name
= argv
[0];
502 const struct object_id
*commit_oid
;
505 const struct commit
*commit
;
506 struct object_id oid
;
509 /* Remotes are only allowed to fetch actual refs */
510 if (remote
&& !remote_allow_unreachable
) {
511 const char *colon
= strchrnul(name
, ':');
512 int refnamelen
= colon
- name
;
514 if (!repo_dwim_ref(the_repository
, name
, refnamelen
, &oid
, &ref
, 0))
515 die(_("no such ref: %.*s"), refnamelen
, name
);
517 repo_dwim_ref(the_repository
, name
, strlen(name
), &oid
, &ref
,
521 if (repo_get_oid(the_repository
, name
, &oid
))
522 die(_("not a valid object name: %s"), name
);
524 commit
= lookup_commit_reference_gently(ar_args
->repo
, &oid
, 1);
526 commit_oid
= &commit
->object
.oid
;
527 archive_time
= commit
->date
;
530 archive_time
= time(NULL
);
532 if (ar_args
->mtime_option
)
533 archive_time
= approxidate(ar_args
->mtime_option
);
535 tree
= parse_tree_indirect(&oid
);
537 die(_("not a tree object: %s"), oid_to_hex(&oid
));
539 ar_args
->refname
= ref
;
540 ar_args
->tree
= tree
;
541 ar_args
->commit_oid
= commit_oid
;
542 ar_args
->commit
= commit
;
543 ar_args
->time
= archive_time
;
546 static void extra_file_info_clear(void *util
, const char *str UNUSED
)
548 struct extra_file_info
*info
= util
;
554 static int add_file_cb(const struct option
*opt
, const char *arg
, int unset
)
556 struct archiver_args
*args
= opt
->value
;
557 const char **basep
= (const char **)opt
->defval
;
558 const char *base
= *basep
;
560 struct string_list_item
*item
;
561 struct extra_file_info
*info
;
564 string_list_clear_func(&args
->extra_files
,
565 extra_file_info_clear
);
572 info
= xmalloc(sizeof(*info
));
573 info
->base
= xstrdup_or_null(base
);
575 if (!strcmp(opt
->long_name
, "add-file")) {
576 path
= prefix_filename(args
->prefix
, arg
);
577 if (stat(path
, &info
->stat
))
578 die(_("File not found: %s"), path
);
579 if (!S_ISREG(info
->stat
.st_mode
))
580 die(_("Not a regular file: %s"), path
);
581 info
->content
= NULL
; /* read the file later */
582 } else if (!strcmp(opt
->long_name
, "add-virtual-file")) {
583 struct strbuf buf
= STRBUF_INIT
;
588 else if (unquote_c_style(&buf
, p
, &p
) < 0)
589 die(_("unclosed quote: '%s'"), arg
);
592 die(_("missing colon: '%s'"), arg
);
595 die(_("empty file name: '%s'"), arg
);
598 strbuf_detach(&buf
, NULL
) : xstrndup(arg
, p
- arg
);
602 path
= prefix_filename(args
->prefix
, path
);
605 memset(&info
->stat
, 0, sizeof(info
->stat
));
606 info
->stat
.st_mode
= S_IFREG
| 0644;
607 info
->content
= xstrdup(p
+ 1);
608 info
->stat
.st_size
= strlen(info
->content
);
610 BUG("add_file_cb() called for %s", opt
->long_name
);
612 item
= string_list_append_nodup(&args
->extra_files
, path
);
618 static int number_callback(const struct option
*opt
, const char *arg
, int unset
)
620 BUG_ON_OPT_NEG(unset
);
621 *(int *)opt
->value
= strtol(arg
, NULL
, 10);
625 static int parse_archive_args(int argc
, const char **argv
,
626 const struct archiver
**ar
, struct archiver_args
*args
,
627 const char *name_hint
, int is_remote
)
629 const char *format
= NULL
;
630 const char *base
= NULL
;
631 const char *remote
= NULL
;
632 const char *exec
= NULL
;
633 const char *output
= NULL
;
634 const char *mtime_option
= NULL
;
635 int compression_level
= -1;
639 int worktree_attributes
= 0;
640 struct option opts
[] = {
642 OPT_STRING(0, "format", &format
, N_("fmt"), N_("archive format")),
643 OPT_STRING(0, "prefix", &base
, N_("prefix"),
644 N_("prepend prefix to each pathname in the archive")),
645 { OPTION_CALLBACK
, 0, "add-file", args
, N_("file"),
646 N_("add untracked file to archive"), 0, add_file_cb
,
648 { OPTION_CALLBACK
, 0, "add-virtual-file", args
,
649 N_("path:content"), N_("add untracked file to archive"), 0,
650 add_file_cb
, (intptr_t)&base
},
651 OPT_STRING('o', "output", &output
, N_("file"),
652 N_("write the archive to this file")),
653 OPT_BOOL(0, "worktree-attributes", &worktree_attributes
,
654 N_("read .gitattributes in working directory")),
655 OPT__VERBOSE(&verbose
, N_("report archived files on stderr")),
656 { OPTION_STRING
, 0, "mtime", &mtime_option
, N_("time"),
657 N_("set modification time of archive entries"),
659 OPT_NUMBER_CALLBACK(&compression_level
,
660 N_("set compression level"), number_callback
),
662 OPT_BOOL('l', "list", &list
,
663 N_("list supported archive formats")),
665 OPT_STRING(0, "remote", &remote
, N_("repo"),
666 N_("retrieve the archive from remote repository <repo>")),
667 OPT_STRING(0, "exec", &exec
, N_("command"),
668 N_("path to the remote git-upload-archive command")),
672 argc
= parse_options(argc
, argv
, NULL
, opts
, archive_usage
, 0);
675 die(_("Unexpected option --remote"));
677 die(_("the option '%s' requires '%s'"), "--exec", "--remote");
679 die(_("Unexpected option --output"));
680 if (is_remote
&& args
->extra_files
.nr
)
681 die(_("options '%s' and '%s' cannot be used together"), "--add-file", "--remote");
687 for (i
= 0; i
< nr_archivers
; i
++)
688 if (!is_remote
|| archivers
[i
]->flags
& ARCHIVER_REMOTE
)
689 printf("%s\n", archivers
[i
]->name
);
693 if (!format
&& name_hint
)
694 format
= archive_format_from_filename(name_hint
);
698 /* We need at least one parameter -- tree-ish */
700 usage_with_options(archive_usage
, opts
);
701 *ar
= lookup_archiver(format
);
702 if (!*ar
|| (is_remote
&& !((*ar
)->flags
& ARCHIVER_REMOTE
)))
703 die(_("Unknown archive format '%s'"), format
);
705 args
->compression_level
= Z_DEFAULT_COMPRESSION
;
706 if (compression_level
!= -1) {
707 int levels_ok
= (*ar
)->flags
& ARCHIVER_WANT_COMPRESSION_LEVELS
;
708 int high_ok
= (*ar
)->flags
& ARCHIVER_HIGH_COMPRESSION_LEVELS
;
709 if (levels_ok
&& (compression_level
<= 9 || high_ok
))
710 args
->compression_level
= compression_level
;
712 die(_("Argument not supported for format '%s': -%d"),
713 format
, compression_level
);
716 args
->verbose
= verbose
;
718 args
->baselen
= strlen(base
);
719 args
->worktree_attributes
= worktree_attributes
;
720 args
->mtime_option
= mtime_option
;
725 int write_archive(int argc
, const char **argv
, const char *prefix
,
726 struct repository
*repo
,
727 const char *name_hint
, int remote
)
729 const struct archiver
*ar
= NULL
;
730 struct pretty_print_describe_status describe_status
= {0};
731 struct pretty_print_context ctx
= {0};
732 struct archiver_args args
;
735 git_config_get_bool("uploadarchive.allowunreachable", &remote_allow_unreachable
);
736 git_config(git_default_config
, NULL
);
738 describe_status
.max_invocations
= 1;
739 ctx
.date_mode
.type
= DATE_NORMAL
;
740 ctx
.abbrev
= DEFAULT_ABBREV
;
741 ctx
.describe_status
= &describe_status
;
742 args
.pretty_ctx
= &ctx
;
744 args
.prefix
= prefix
;
745 string_list_init_dup(&args
.extra_files
);
746 argc
= parse_archive_args(argc
, argv
, &ar
, &args
, name_hint
, remote
);
747 if (!startup_info
->have_repository
) {
749 * We know this will die() with an error, so we could just
750 * die ourselves; but its error message will be more specific
751 * than what we could write here.
753 setup_git_directory();
756 parse_treeish_arg(argv
, &args
, remote
);
757 parse_pathspec_arg(argv
+ 1, &args
);
759 rc
= ar
->write_archive(ar
, &args
);
761 string_list_clear_func(&args
.extra_files
, extra_file_info_clear
);
763 clear_pathspec(&args
.pathspec
);
768 static int match_extension(const char *filename
, const char *ext
)
770 int prefixlen
= strlen(filename
) - strlen(ext
);
773 * We need 1 character for the '.', and 1 character to ensure that the
774 * prefix is non-empty (k.e., we don't match .tar.gz with no actual
777 if (prefixlen
< 2 || filename
[prefixlen
- 1] != '.')
779 return !strcmp(filename
+ prefixlen
, ext
);
782 const char *archive_format_from_filename(const char *filename
)
786 for (i
= 0; i
< nr_archivers
; i
++)
787 if (match_extension(filename
, archivers
[i
]->name
))
788 return archivers
[i
]->name
;