1 #include "git-compat-util.h"
5 #include "environment.h"
10 #include "object-store.h"
12 #include "tree-walk.h"
15 #include "parse-options.h"
16 #include "unpack-trees.h"
20 static char const * const archive_usage
[] = {
21 N_("git archive [<options>] <tree-ish> [<path>...]"),
23 N_("git archive --remote <repo> [--exec <cmd>] [<options>] <tree-ish> [<path>...]"),
24 N_("git archive --remote <repo> [--exec <cmd>] --list"),
28 static const struct archiver
**archivers
;
29 static int nr_archivers
;
30 static int alloc_archivers
;
31 static int remote_allow_unreachable
;
33 void register_archiver(struct archiver
*ar
)
35 ALLOC_GROW(archivers
, nr_archivers
+ 1, alloc_archivers
);
36 archivers
[nr_archivers
++] = ar
;
39 void init_archivers(void)
45 static void format_subst(const struct commit
*commit
,
46 const char *src
, size_t len
,
47 struct strbuf
*buf
, struct pretty_print_context
*ctx
)
50 struct strbuf fmt
= STRBUF_INIT
;
53 to_free
= strbuf_detach(buf
, NULL
);
57 b
= memmem(src
, len
, "$Format:", 8);
60 c
= memchr(b
+ 8, '$', (src
+ len
) - b
- 8);
65 strbuf_add(&fmt
, b
+ 8, c
- b
- 8);
67 strbuf_add(buf
, src
, b
- src
);
68 repo_format_commit_message(the_repository
, commit
, fmt
.buf
,
73 strbuf_add(buf
, src
, len
);
78 static void *object_file_to_archive(const struct archiver_args
*args
,
80 const struct object_id
*oid
,
82 enum object_type
*type
,
86 const struct commit
*commit
= args
->convert
? args
->commit
: NULL
;
87 struct checkout_metadata meta
;
89 init_checkout_metadata(&meta
, args
->refname
,
90 args
->commit_oid
? args
->commit_oid
:
91 (args
->tree
? &args
->tree
->object
.oid
: NULL
), oid
);
93 path
+= args
->baselen
;
94 buffer
= repo_read_object_file(the_repository
, oid
, type
, sizep
);
95 if (buffer
&& S_ISREG(mode
)) {
96 struct strbuf buf
= STRBUF_INIT
;
99 strbuf_attach(&buf
, buffer
, *sizep
, *sizep
+ 1);
100 convert_to_working_tree(args
->repo
->index
, path
, buf
.buf
, buf
.len
, &buf
, &meta
);
102 format_subst(commit
, buf
.buf
, buf
.len
, &buf
, args
->pretty_ctx
);
103 buffer
= strbuf_detach(&buf
, &size
);
111 struct directory
*up
;
112 struct object_id oid
;
115 char path
[FLEX_ARRAY
];
118 struct archiver_context
{
119 struct archiver_args
*args
;
120 write_archive_entry_fn_t write_entry
;
121 struct directory
*bottom
;
124 static const struct attr_check
*get_archive_attrs(struct index_state
*istate
,
127 static struct attr_check
*check
;
129 check
= attr_check_initl("export-ignore", "export-subst", NULL
);
130 git_check_attr(istate
, NULL
, path
, check
);
134 static int check_attr_export_ignore(const struct attr_check
*check
)
136 return check
&& ATTR_TRUE(check
->items
[0].value
);
139 static int check_attr_export_subst(const struct attr_check
*check
)
141 return check
&& ATTR_TRUE(check
->items
[1].value
);
144 static int write_archive_entry(const struct object_id
*oid
, const char *base
,
145 int baselen
, const char *filename
, unsigned mode
,
148 static struct strbuf path
= STRBUF_INIT
;
149 struct archiver_context
*c
= context
;
150 struct archiver_args
*args
= c
->args
;
151 write_archive_entry_fn_t write_entry
= c
->write_entry
;
153 const char *path_without_prefix
;
156 enum object_type type
;
160 strbuf_grow(&path
, PATH_MAX
);
161 strbuf_add(&path
, args
->base
, args
->baselen
);
162 strbuf_add(&path
, base
, baselen
);
163 strbuf_addstr(&path
, filename
);
164 if (S_ISDIR(mode
) || S_ISGITLINK(mode
))
165 strbuf_addch(&path
, '/');
166 path_without_prefix
= path
.buf
+ args
->baselen
;
168 if (!S_ISDIR(mode
)) {
169 const struct attr_check
*check
;
170 check
= get_archive_attrs(args
->repo
->index
, path_without_prefix
);
171 if (check_attr_export_ignore(check
))
173 args
->convert
= check_attr_export_subst(check
);
177 static struct strbuf new_path
= STRBUF_INIT
;
178 static struct strbuf buf
= STRBUF_INIT
;
181 rel
= relative_path(path_without_prefix
, args
->prefix
, &buf
);
184 * We don't add an entry for the current working
185 * directory when we are at the root; skip it also when
186 * we're in a subdirectory or submodule. Skip entries
189 if (!strcmp(rel
, "./") || starts_with(rel
, "../"))
190 return S_ISDIR(mode
) ? READ_TREE_RECURSIVE
: 0;
192 /* rel can refer to path, so don't edit it in place */
193 strbuf_reset(&new_path
);
194 strbuf_add(&new_path
, args
->base
, args
->baselen
);
195 strbuf_addstr(&new_path
, rel
);
196 strbuf_swap(&path
, &new_path
);
200 fprintf(stderr
, "%.*s\n", (int)path
.len
, path
.buf
);
202 if (S_ISDIR(mode
) || S_ISGITLINK(mode
)) {
203 err
= write_entry(args
, oid
, path
.buf
, path
.len
, mode
, NULL
, 0);
206 return (S_ISDIR(mode
) ? READ_TREE_RECURSIVE
: 0);
210 if (S_ISREG(mode
) && !args
->convert
&&
211 oid_object_info(args
->repo
, oid
, &size
) == OBJ_BLOB
&&
212 size
> big_file_threshold
)
213 return write_entry(args
, oid
, path
.buf
, path
.len
, mode
, NULL
, size
);
215 buffer
= object_file_to_archive(args
, path
.buf
, oid
, mode
, &type
, &size
);
217 return error(_("cannot read '%s'"), oid_to_hex(oid
));
218 err
= write_entry(args
, oid
, path
.buf
, path
.len
, mode
, buffer
, size
);
223 static void queue_directory(const struct object_id
*oid
,
224 struct strbuf
*base
, const char *filename
,
225 unsigned mode
, struct archiver_context
*c
)
228 size_t len
= st_add4(base
->len
, 1, strlen(filename
), 1);
229 d
= xmalloc(st_add(sizeof(*d
), len
));
231 d
->baselen
= base
->len
;
234 d
->len
= xsnprintf(d
->path
, len
, "%.*s%s/", (int)base
->len
, base
->buf
, filename
);
235 oidcpy(&d
->oid
, oid
);
238 static int write_directory(struct archiver_context
*c
)
240 struct directory
*d
= c
->bottom
;
246 d
->path
[d
->len
- 1] = '\0'; /* no trailing slash */
248 write_directory(c
) ||
249 write_archive_entry(&d
->oid
, d
->path
, d
->baselen
,
250 d
->path
+ d
->baselen
, d
->mode
,
251 c
) != READ_TREE_RECURSIVE
;
256 static int queue_or_write_archive_entry(const struct object_id
*oid
,
257 struct strbuf
*base
, const char *filename
,
258 unsigned mode
, void *context
)
260 struct archiver_context
*c
= context
;
263 !(base
->len
>= c
->bottom
->len
&&
264 !strncmp(base
->buf
, c
->bottom
->path
, c
->bottom
->len
))) {
265 struct directory
*next
= c
->bottom
->up
;
271 size_t baselen
= base
->len
;
272 const struct attr_check
*check
;
274 /* Borrow base, but restore its original value when done. */
275 strbuf_addstr(base
, filename
);
276 strbuf_addch(base
, '/');
277 check
= get_archive_attrs(c
->args
->repo
->index
, base
->buf
);
278 strbuf_setlen(base
, baselen
);
280 if (check_attr_export_ignore(check
))
282 queue_directory(oid
, base
, filename
, mode
, c
);
283 return READ_TREE_RECURSIVE
;
286 if (write_directory(c
))
288 return write_archive_entry(oid
, base
->buf
, base
->len
, filename
, mode
,
292 struct extra_file_info
{
298 int write_archive_entries(struct archiver_args
*args
,
299 write_archive_entry_fn_t write_entry
)
301 struct archiver_context context
;
302 struct unpack_trees_options opts
;
305 struct strbuf path_in_archive
= STRBUF_INIT
;
306 struct strbuf content
= STRBUF_INIT
;
307 struct object_id fake_oid
;
310 oidcpy(&fake_oid
, null_oid());
312 if (args
->baselen
> 0 && args
->base
[args
->baselen
- 1] == '/') {
313 size_t len
= args
->baselen
;
315 while (len
> 1 && args
->base
[len
- 2] == '/')
318 fprintf(stderr
, "%.*s\n", (int)len
, args
->base
);
319 err
= write_entry(args
, &args
->tree
->object
.oid
, args
->base
,
320 len
, 040777, NULL
, 0);
325 memset(&context
, 0, sizeof(context
));
327 context
.write_entry
= write_entry
;
330 * Setup index and instruct attr to read index only
332 if (!args
->worktree_attributes
) {
333 memset(&opts
, 0, sizeof(opts
));
336 opts
.src_index
= args
->repo
->index
;
337 opts
.dst_index
= args
->repo
->index
;
338 opts
.fn
= oneway_merge
;
339 init_tree_desc(&t
, args
->tree
->buffer
, args
->tree
->size
);
340 if (unpack_trees(1, &t
, &opts
))
342 git_attr_set_direction(GIT_ATTR_INDEX
);
345 err
= read_tree(args
->repo
, args
->tree
,
347 queue_or_write_archive_entry
,
349 if (err
== READ_TREE_RECURSIVE
)
351 while (context
.bottom
) {
352 struct directory
*next
= context
.bottom
->up
;
353 free(context
.bottom
);
354 context
.bottom
= next
;
357 for (i
= 0; i
< args
->extra_files
.nr
; i
++) {
358 struct string_list_item
*item
= args
->extra_files
.items
+ i
;
359 char *path
= item
->string
;
360 struct extra_file_info
*info
= item
->util
;
362 put_be64(fake_oid
.hash
, i
+ 1);
364 if (!info
->content
) {
365 strbuf_reset(&path_in_archive
);
367 strbuf_addstr(&path_in_archive
, info
->base
);
368 strbuf_addstr(&path_in_archive
, basename(path
));
370 strbuf_reset(&content
);
371 if (strbuf_read_file(&content
, path
, info
->stat
.st_size
) < 0)
372 err
= error_errno(_("cannot read '%s'"), path
);
374 err
= write_entry(args
, &fake_oid
, path_in_archive
.buf
,
376 canon_mode(info
->stat
.st_mode
),
377 content
.buf
, content
.len
);
379 err
= write_entry(args
, &fake_oid
,
381 canon_mode(info
->stat
.st_mode
),
382 info
->content
, info
->stat
.st_size
);
388 strbuf_release(&path_in_archive
);
389 strbuf_release(&content
);
394 static const struct archiver
*lookup_archiver(const char *name
)
401 for (i
= 0; i
< nr_archivers
; i
++) {
402 if (!strcmp(name
, archivers
[i
]->name
))
408 struct path_exists_context
{
409 struct pathspec pathspec
;
410 struct archiver_args
*args
;
413 static int reject_entry(const struct object_id
*oid UNUSED
,
415 const char *filename
, unsigned mode
,
419 struct path_exists_context
*ctx
= context
;
422 struct strbuf sb
= STRBUF_INIT
;
423 strbuf_addbuf(&sb
, base
);
424 strbuf_addstr(&sb
, filename
);
425 if (!match_pathspec(ctx
->args
->repo
->index
,
427 sb
.buf
, sb
.len
, 0, NULL
, 1))
428 ret
= READ_TREE_RECURSIVE
;
434 static int reject_outside(const struct object_id
*oid UNUSED
,
435 struct strbuf
*base
, const char *filename
,
436 unsigned mode
, void *context
)
438 struct archiver_args
*args
= context
;
439 struct strbuf buf
= STRBUF_INIT
;
440 struct strbuf path
= STRBUF_INIT
;
444 return READ_TREE_RECURSIVE
;
446 strbuf_addbuf(&path
, base
);
447 strbuf_addstr(&path
, filename
);
448 if (starts_with(relative_path(path
.buf
, args
->prefix
, &buf
), "../"))
450 strbuf_release(&buf
);
451 strbuf_release(&path
);
455 static int path_exists(struct archiver_args
*args
, const char *path
)
457 const char *paths
[] = { path
, NULL
};
458 struct path_exists_context ctx
;
462 parse_pathspec(&ctx
.pathspec
, 0, PATHSPEC_PREFER_CWD
,
463 args
->prefix
, paths
);
464 ctx
.pathspec
.recursive
= 1;
465 if (args
->prefix
&& read_tree(args
->repo
, args
->tree
, &ctx
.pathspec
,
466 reject_outside
, args
))
467 die(_("pathspec '%s' matches files outside the "
468 "current directory"), path
);
469 ret
= read_tree(args
->repo
, args
->tree
,
472 clear_pathspec(&ctx
.pathspec
);
476 static void parse_pathspec_arg(const char **pathspec
,
477 struct archiver_args
*ar_args
)
480 * must be consistent with parse_pathspec in path_exists()
481 * Also if pathspec patterns are dependent, we're in big
482 * trouble as we test each one separately
484 parse_pathspec(&ar_args
->pathspec
, 0, PATHSPEC_PREFER_CWD
,
485 ar_args
->prefix
, pathspec
);
486 ar_args
->pathspec
.recursive
= 1;
489 if (**pathspec
&& !path_exists(ar_args
, *pathspec
))
490 die(_("pathspec '%s' did not match any files"), *pathspec
);
496 static void parse_treeish_arg(const char **argv
,
497 struct archiver_args
*ar_args
, int remote
)
499 const char *name
= argv
[0];
500 const struct object_id
*commit_oid
;
503 const struct commit
*commit
;
504 struct object_id oid
;
507 /* Remotes are only allowed to fetch actual refs */
508 if (remote
&& !remote_allow_unreachable
) {
509 const char *colon
= strchrnul(name
, ':');
510 int refnamelen
= colon
- name
;
512 if (!repo_dwim_ref(the_repository
, name
, refnamelen
, &oid
, &ref
, 0))
513 die(_("no such ref: %.*s"), refnamelen
, name
);
515 repo_dwim_ref(the_repository
, name
, strlen(name
), &oid
, &ref
,
519 if (repo_get_oid(the_repository
, name
, &oid
))
520 die(_("not a valid object name: %s"), name
);
522 commit
= lookup_commit_reference_gently(ar_args
->repo
, &oid
, 1);
524 commit_oid
= &commit
->object
.oid
;
525 archive_time
= commit
->date
;
528 archive_time
= time(NULL
);
530 if (ar_args
->mtime_option
)
531 archive_time
= approxidate(ar_args
->mtime_option
);
533 tree
= parse_tree_indirect(&oid
);
535 die(_("not a tree object: %s"), oid_to_hex(&oid
));
537 ar_args
->refname
= ref
;
538 ar_args
->tree
= tree
;
539 ar_args
->commit_oid
= commit_oid
;
540 ar_args
->commit
= commit
;
541 ar_args
->time
= archive_time
;
544 static void extra_file_info_clear(void *util
, const char *str UNUSED
)
546 struct extra_file_info
*info
= util
;
552 static int add_file_cb(const struct option
*opt
, const char *arg
, int unset
)
554 struct archiver_args
*args
= opt
->value
;
555 const char **basep
= (const char **)opt
->defval
;
556 const char *base
= *basep
;
558 struct string_list_item
*item
;
559 struct extra_file_info
*info
;
562 string_list_clear_func(&args
->extra_files
,
563 extra_file_info_clear
);
570 info
= xmalloc(sizeof(*info
));
571 info
->base
= xstrdup_or_null(base
);
573 if (!strcmp(opt
->long_name
, "add-file")) {
574 path
= prefix_filename(args
->prefix
, arg
);
575 if (stat(path
, &info
->stat
))
576 die(_("File not found: %s"), path
);
577 if (!S_ISREG(info
->stat
.st_mode
))
578 die(_("Not a regular file: %s"), path
);
579 info
->content
= NULL
; /* read the file later */
580 } else if (!strcmp(opt
->long_name
, "add-virtual-file")) {
581 struct strbuf buf
= STRBUF_INIT
;
586 else if (unquote_c_style(&buf
, p
, &p
) < 0)
587 die(_("unclosed quote: '%s'"), arg
);
590 die(_("missing colon: '%s'"), arg
);
593 die(_("empty file name: '%s'"), arg
);
596 strbuf_detach(&buf
, NULL
) : xstrndup(arg
, p
- arg
);
600 path
= prefix_filename(args
->prefix
, path
);
603 memset(&info
->stat
, 0, sizeof(info
->stat
));
604 info
->stat
.st_mode
= S_IFREG
| 0644;
605 info
->content
= xstrdup(p
+ 1);
606 info
->stat
.st_size
= strlen(info
->content
);
608 BUG("add_file_cb() called for %s", opt
->long_name
);
610 item
= string_list_append_nodup(&args
->extra_files
, path
);
616 static int number_callback(const struct option
*opt
, const char *arg
, int unset
)
618 BUG_ON_OPT_NEG(unset
);
619 *(int *)opt
->value
= strtol(arg
, NULL
, 10);
623 static int parse_archive_args(int argc
, const char **argv
,
624 const struct archiver
**ar
, struct archiver_args
*args
,
625 const char *name_hint
, int is_remote
)
627 const char *format
= NULL
;
628 const char *base
= NULL
;
629 const char *remote
= NULL
;
630 const char *exec
= NULL
;
631 const char *output
= NULL
;
632 const char *mtime_option
= NULL
;
633 int compression_level
= -1;
637 int worktree_attributes
= 0;
638 struct option opts
[] = {
640 OPT_STRING(0, "format", &format
, N_("fmt"), N_("archive format")),
641 OPT_STRING(0, "prefix", &base
, N_("prefix"),
642 N_("prepend prefix to each pathname in the archive")),
643 { OPTION_CALLBACK
, 0, "add-file", args
, N_("file"),
644 N_("add untracked file to archive"), 0, add_file_cb
,
646 { OPTION_CALLBACK
, 0, "add-virtual-file", args
,
647 N_("path:content"), N_("add untracked file to archive"), 0,
648 add_file_cb
, (intptr_t)&base
},
649 OPT_STRING('o', "output", &output
, N_("file"),
650 N_("write the archive to this file")),
651 OPT_BOOL(0, "worktree-attributes", &worktree_attributes
,
652 N_("read .gitattributes in working directory")),
653 OPT__VERBOSE(&verbose
, N_("report archived files on stderr")),
654 { OPTION_STRING
, 0, "mtime", &mtime_option
, N_("time"),
655 N_("set modification time of archive entries"),
657 OPT_NUMBER_CALLBACK(&compression_level
,
658 N_("set compression level"), number_callback
),
660 OPT_BOOL('l', "list", &list
,
661 N_("list supported archive formats")),
663 OPT_STRING(0, "remote", &remote
, N_("repo"),
664 N_("retrieve the archive from remote repository <repo>")),
665 OPT_STRING(0, "exec", &exec
, N_("command"),
666 N_("path to the remote git-upload-archive command")),
670 argc
= parse_options(argc
, argv
, NULL
, opts
, archive_usage
, 0);
673 die(_("Unexpected option --remote"));
675 die(_("the option '%s' requires '%s'"), "--exec", "--remote");
677 die(_("Unexpected option --output"));
678 if (is_remote
&& args
->extra_files
.nr
)
679 die(_("options '%s' and '%s' cannot be used together"), "--add-file", "--remote");
685 for (i
= 0; i
< nr_archivers
; i
++)
686 if (!is_remote
|| archivers
[i
]->flags
& ARCHIVER_REMOTE
)
687 printf("%s\n", archivers
[i
]->name
);
691 if (!format
&& name_hint
)
692 format
= archive_format_from_filename(name_hint
);
696 /* We need at least one parameter -- tree-ish */
698 usage_with_options(archive_usage
, opts
);
699 *ar
= lookup_archiver(format
);
700 if (!*ar
|| (is_remote
&& !((*ar
)->flags
& ARCHIVER_REMOTE
)))
701 die(_("Unknown archive format '%s'"), format
);
703 args
->compression_level
= Z_DEFAULT_COMPRESSION
;
704 if (compression_level
!= -1) {
705 int levels_ok
= (*ar
)->flags
& ARCHIVER_WANT_COMPRESSION_LEVELS
;
706 int high_ok
= (*ar
)->flags
& ARCHIVER_HIGH_COMPRESSION_LEVELS
;
707 if (levels_ok
&& (compression_level
<= 9 || high_ok
))
708 args
->compression_level
= compression_level
;
710 die(_("Argument not supported for format '%s': -%d"),
711 format
, compression_level
);
714 args
->verbose
= verbose
;
716 args
->baselen
= strlen(base
);
717 args
->worktree_attributes
= worktree_attributes
;
718 args
->mtime_option
= mtime_option
;
723 int write_archive(int argc
, const char **argv
, const char *prefix
,
724 struct repository
*repo
,
725 const char *name_hint
, int remote
)
727 const struct archiver
*ar
= NULL
;
728 struct pretty_print_describe_status describe_status
= {0};
729 struct pretty_print_context ctx
= {0};
730 struct archiver_args args
;
733 git_config_get_bool("uploadarchive.allowunreachable", &remote_allow_unreachable
);
734 git_config(git_default_config
, NULL
);
736 describe_status
.max_invocations
= 1;
737 ctx
.date_mode
.type
= DATE_NORMAL
;
738 ctx
.abbrev
= DEFAULT_ABBREV
;
739 ctx
.describe_status
= &describe_status
;
740 args
.pretty_ctx
= &ctx
;
742 args
.prefix
= prefix
;
743 string_list_init_dup(&args
.extra_files
);
744 argc
= parse_archive_args(argc
, argv
, &ar
, &args
, name_hint
, remote
);
745 if (!startup_info
->have_repository
) {
747 * We know this will die() with an error, so we could just
748 * die ourselves; but its error message will be more specific
749 * than what we could write here.
751 setup_git_directory();
754 parse_treeish_arg(argv
, &args
, remote
);
755 parse_pathspec_arg(argv
+ 1, &args
);
757 rc
= ar
->write_archive(ar
, &args
);
759 string_list_clear_func(&args
.extra_files
, extra_file_info_clear
);
761 clear_pathspec(&args
.pathspec
);
766 static int match_extension(const char *filename
, const char *ext
)
768 int prefixlen
= strlen(filename
) - strlen(ext
);
771 * We need 1 character for the '.', and 1 character to ensure that the
772 * prefix is non-empty (k.e., we don't match .tar.gz with no actual
775 if (prefixlen
< 2 || filename
[prefixlen
- 1] != '.')
777 return !strcmp(filename
+ prefixlen
, ext
);
780 const char *archive_format_from_filename(const char *filename
)
784 for (i
= 0; i
< nr_archivers
; i
++)
785 if (match_extension(filename
, archivers
[i
]->name
))
786 return archivers
[i
]->name
;