1 #include "git-compat-util.h"
7 #include "object-store.h"
12 #include "parse-options.h"
13 #include "unpack-trees.h"
17 static char const * const archive_usage
[] = {
18 N_("git archive [<options>] <tree-ish> [<path>...]"),
20 N_("git archive --remote <repo> [--exec <cmd>] [<options>] <tree-ish> [<path>...]"),
21 N_("git archive --remote <repo> [--exec <cmd>] --list"),
25 static const struct archiver
**archivers
;
26 static int nr_archivers
;
27 static int alloc_archivers
;
28 static int remote_allow_unreachable
;
30 void register_archiver(struct archiver
*ar
)
32 ALLOC_GROW(archivers
, nr_archivers
+ 1, alloc_archivers
);
33 archivers
[nr_archivers
++] = ar
;
36 void init_archivers(void)
42 static void format_subst(const struct commit
*commit
,
43 const char *src
, size_t len
,
44 struct strbuf
*buf
, struct pretty_print_context
*ctx
)
47 struct strbuf fmt
= STRBUF_INIT
;
50 to_free
= strbuf_detach(buf
, NULL
);
54 b
= memmem(src
, len
, "$Format:", 8);
57 c
= memchr(b
+ 8, '$', (src
+ len
) - b
- 8);
62 strbuf_add(&fmt
, b
+ 8, c
- b
- 8);
64 strbuf_add(buf
, src
, b
- src
);
65 format_commit_message(commit
, fmt
.buf
, buf
, ctx
);
69 strbuf_add(buf
, src
, len
);
74 static void *object_file_to_archive(const struct archiver_args
*args
,
76 const struct object_id
*oid
,
78 enum object_type
*type
,
82 const struct commit
*commit
= args
->convert
? args
->commit
: NULL
;
83 struct checkout_metadata meta
;
85 init_checkout_metadata(&meta
, args
->refname
,
86 args
->commit_oid
? args
->commit_oid
:
87 (args
->tree
? &args
->tree
->object
.oid
: NULL
), oid
);
89 path
+= args
->baselen
;
90 buffer
= read_object_file(oid
, type
, sizep
);
91 if (buffer
&& S_ISREG(mode
)) {
92 struct strbuf buf
= STRBUF_INIT
;
95 strbuf_attach(&buf
, buffer
, *sizep
, *sizep
+ 1);
96 convert_to_working_tree(args
->repo
->index
, path
, buf
.buf
, buf
.len
, &buf
, &meta
);
98 format_subst(commit
, buf
.buf
, buf
.len
, &buf
, args
->pretty_ctx
);
99 buffer
= strbuf_detach(&buf
, &size
);
107 struct directory
*up
;
108 struct object_id oid
;
111 char path
[FLEX_ARRAY
];
114 struct archiver_context
{
115 struct archiver_args
*args
;
116 write_archive_entry_fn_t write_entry
;
117 struct directory
*bottom
;
120 static const struct attr_check
*get_archive_attrs(struct index_state
*istate
,
123 static struct attr_check
*check
;
125 check
= attr_check_initl("export-ignore", "export-subst", NULL
);
126 git_check_attr(istate
, NULL
, path
, check
);
130 static int check_attr_export_ignore(const struct attr_check
*check
)
132 return check
&& ATTR_TRUE(check
->items
[0].value
);
135 static int check_attr_export_subst(const struct attr_check
*check
)
137 return check
&& ATTR_TRUE(check
->items
[1].value
);
140 static int write_archive_entry(const struct object_id
*oid
, const char *base
,
141 int baselen
, const char *filename
, unsigned mode
,
144 static struct strbuf path
= STRBUF_INIT
;
145 struct archiver_context
*c
= context
;
146 struct archiver_args
*args
= c
->args
;
147 write_archive_entry_fn_t write_entry
= c
->write_entry
;
149 const char *path_without_prefix
;
152 enum object_type type
;
156 strbuf_grow(&path
, PATH_MAX
);
157 strbuf_add(&path
, args
->base
, args
->baselen
);
158 strbuf_add(&path
, base
, baselen
);
159 strbuf_addstr(&path
, filename
);
160 if (S_ISDIR(mode
) || S_ISGITLINK(mode
))
161 strbuf_addch(&path
, '/');
162 path_without_prefix
= path
.buf
+ args
->baselen
;
164 if (!S_ISDIR(mode
)) {
165 const struct attr_check
*check
;
166 check
= get_archive_attrs(args
->repo
->index
, path_without_prefix
);
167 if (check_attr_export_ignore(check
))
169 args
->convert
= check_attr_export_subst(check
);
173 fprintf(stderr
, "%.*s\n", (int)path
.len
, path
.buf
);
175 if (S_ISDIR(mode
) || S_ISGITLINK(mode
)) {
176 err
= write_entry(args
, oid
, path
.buf
, path
.len
, mode
, NULL
, 0);
179 return (S_ISDIR(mode
) ? READ_TREE_RECURSIVE
: 0);
183 if (S_ISREG(mode
) && !args
->convert
&&
184 oid_object_info(args
->repo
, oid
, &size
) == OBJ_BLOB
&&
185 size
> big_file_threshold
)
186 return write_entry(args
, oid
, path
.buf
, path
.len
, mode
, NULL
, size
);
188 buffer
= object_file_to_archive(args
, path
.buf
, oid
, mode
, &type
, &size
);
190 return error(_("cannot read '%s'"), oid_to_hex(oid
));
191 err
= write_entry(args
, oid
, path
.buf
, path
.len
, mode
, buffer
, size
);
196 static void queue_directory(const struct object_id
*oid
,
197 struct strbuf
*base
, const char *filename
,
198 unsigned mode
, struct archiver_context
*c
)
201 size_t len
= st_add4(base
->len
, 1, strlen(filename
), 1);
202 d
= xmalloc(st_add(sizeof(*d
), len
));
204 d
->baselen
= base
->len
;
207 d
->len
= xsnprintf(d
->path
, len
, "%.*s%s/", (int)base
->len
, base
->buf
, filename
);
208 oidcpy(&d
->oid
, oid
);
211 static int write_directory(struct archiver_context
*c
)
213 struct directory
*d
= c
->bottom
;
219 d
->path
[d
->len
- 1] = '\0'; /* no trailing slash */
221 write_directory(c
) ||
222 write_archive_entry(&d
->oid
, d
->path
, d
->baselen
,
223 d
->path
+ d
->baselen
, d
->mode
,
224 c
) != READ_TREE_RECURSIVE
;
229 static int queue_or_write_archive_entry(const struct object_id
*oid
,
230 struct strbuf
*base
, const char *filename
,
231 unsigned mode
, void *context
)
233 struct archiver_context
*c
= context
;
236 !(base
->len
>= c
->bottom
->len
&&
237 !strncmp(base
->buf
, c
->bottom
->path
, c
->bottom
->len
))) {
238 struct directory
*next
= c
->bottom
->up
;
244 size_t baselen
= base
->len
;
245 const struct attr_check
*check
;
247 /* Borrow base, but restore its original value when done. */
248 strbuf_addstr(base
, filename
);
249 strbuf_addch(base
, '/');
250 check
= get_archive_attrs(c
->args
->repo
->index
, base
->buf
);
251 strbuf_setlen(base
, baselen
);
253 if (check_attr_export_ignore(check
))
255 queue_directory(oid
, base
, filename
, mode
, c
);
256 return READ_TREE_RECURSIVE
;
259 if (write_directory(c
))
261 return write_archive_entry(oid
, base
->buf
, base
->len
, filename
, mode
,
265 struct extra_file_info
{
271 int write_archive_entries(struct archiver_args
*args
,
272 write_archive_entry_fn_t write_entry
)
274 struct archiver_context context
;
275 struct unpack_trees_options opts
;
278 struct strbuf path_in_archive
= STRBUF_INIT
;
279 struct strbuf content
= STRBUF_INIT
;
280 struct object_id fake_oid
;
283 oidcpy(&fake_oid
, null_oid());
285 if (args
->baselen
> 0 && args
->base
[args
->baselen
- 1] == '/') {
286 size_t len
= args
->baselen
;
288 while (len
> 1 && args
->base
[len
- 2] == '/')
291 fprintf(stderr
, "%.*s\n", (int)len
, args
->base
);
292 err
= write_entry(args
, &args
->tree
->object
.oid
, args
->base
,
293 len
, 040777, NULL
, 0);
298 memset(&context
, 0, sizeof(context
));
300 context
.write_entry
= write_entry
;
303 * Setup index and instruct attr to read index only
305 if (!args
->worktree_attributes
) {
306 memset(&opts
, 0, sizeof(opts
));
309 opts
.src_index
= args
->repo
->index
;
310 opts
.dst_index
= args
->repo
->index
;
311 opts
.fn
= oneway_merge
;
312 init_tree_desc(&t
, args
->tree
->buffer
, args
->tree
->size
);
313 if (unpack_trees(1, &t
, &opts
))
315 git_attr_set_direction(GIT_ATTR_INDEX
);
318 err
= read_tree(args
->repo
, args
->tree
,
320 queue_or_write_archive_entry
,
322 if (err
== READ_TREE_RECURSIVE
)
324 while (context
.bottom
) {
325 struct directory
*next
= context
.bottom
->up
;
326 free(context
.bottom
);
327 context
.bottom
= next
;
330 for (i
= 0; i
< args
->extra_files
.nr
; i
++) {
331 struct string_list_item
*item
= args
->extra_files
.items
+ i
;
332 char *path
= item
->string
;
333 struct extra_file_info
*info
= item
->util
;
335 put_be64(fake_oid
.hash
, i
+ 1);
337 if (!info
->content
) {
338 strbuf_reset(&path_in_archive
);
340 strbuf_addstr(&path_in_archive
, info
->base
);
341 strbuf_addstr(&path_in_archive
, basename(path
));
343 strbuf_reset(&content
);
344 if (strbuf_read_file(&content
, path
, info
->stat
.st_size
) < 0)
345 err
= error_errno(_("cannot read '%s'"), path
);
347 err
= write_entry(args
, &fake_oid
, path_in_archive
.buf
,
349 canon_mode(info
->stat
.st_mode
),
350 content
.buf
, content
.len
);
352 err
= write_entry(args
, &fake_oid
,
354 canon_mode(info
->stat
.st_mode
),
355 info
->content
, info
->stat
.st_size
);
361 strbuf_release(&path_in_archive
);
362 strbuf_release(&content
);
367 static const struct archiver
*lookup_archiver(const char *name
)
374 for (i
= 0; i
< nr_archivers
; i
++) {
375 if (!strcmp(name
, archivers
[i
]->name
))
381 struct path_exists_context
{
382 struct pathspec pathspec
;
383 struct archiver_args
*args
;
386 static int reject_entry(const struct object_id
*oid UNUSED
,
388 const char *filename
, unsigned mode
,
392 struct path_exists_context
*ctx
= context
;
395 struct strbuf sb
= STRBUF_INIT
;
396 strbuf_addbuf(&sb
, base
);
397 strbuf_addstr(&sb
, filename
);
398 if (!match_pathspec(ctx
->args
->repo
->index
,
400 sb
.buf
, sb
.len
, 0, NULL
, 1))
401 ret
= READ_TREE_RECURSIVE
;
407 static int path_exists(struct archiver_args
*args
, const char *path
)
409 const char *paths
[] = { path
, NULL
};
410 struct path_exists_context ctx
;
414 parse_pathspec(&ctx
.pathspec
, 0, 0, "", paths
);
415 ctx
.pathspec
.recursive
= 1;
416 ret
= read_tree(args
->repo
, args
->tree
,
419 clear_pathspec(&ctx
.pathspec
);
423 static void parse_pathspec_arg(const char **pathspec
,
424 struct archiver_args
*ar_args
)
427 * must be consistent with parse_pathspec in path_exists()
428 * Also if pathspec patterns are dependent, we're in big
429 * trouble as we test each one separately
431 parse_pathspec(&ar_args
->pathspec
, 0,
432 PATHSPEC_PREFER_FULL
,
434 ar_args
->pathspec
.recursive
= 1;
437 if (**pathspec
&& !path_exists(ar_args
, *pathspec
))
438 die(_("pathspec '%s' did not match any files"), *pathspec
);
444 static void parse_treeish_arg(const char **argv
,
445 struct archiver_args
*ar_args
, const char *prefix
,
448 const char *name
= argv
[0];
449 const struct object_id
*commit_oid
;
452 const struct commit
*commit
;
453 struct object_id oid
;
456 /* Remotes are only allowed to fetch actual refs */
457 if (remote
&& !remote_allow_unreachable
) {
458 const char *colon
= strchrnul(name
, ':');
459 int refnamelen
= colon
- name
;
461 if (!dwim_ref(name
, refnamelen
, &oid
, &ref
, 0))
462 die(_("no such ref: %.*s"), refnamelen
, name
);
464 dwim_ref(name
, strlen(name
), &oid
, &ref
, 0);
467 if (get_oid(name
, &oid
))
468 die(_("not a valid object name: %s"), name
);
470 commit
= lookup_commit_reference_gently(ar_args
->repo
, &oid
, 1);
472 commit_oid
= &commit
->object
.oid
;
473 archive_time
= commit
->date
;
476 archive_time
= time(NULL
);
478 if (ar_args
->mtime_option
)
479 archive_time
= approxidate(ar_args
->mtime_option
);
481 tree
= parse_tree_indirect(&oid
);
483 die(_("not a tree object: %s"), oid_to_hex(&oid
));
486 struct object_id tree_oid
;
490 err
= get_tree_entry(ar_args
->repo
,
494 if (err
|| !S_ISDIR(mode
))
495 die(_("current working directory is untracked"));
497 tree
= parse_tree_indirect(&tree_oid
);
499 ar_args
->refname
= ref
;
500 ar_args
->tree
= tree
;
501 ar_args
->commit_oid
= commit_oid
;
502 ar_args
->commit
= commit
;
503 ar_args
->time
= archive_time
;
506 static void extra_file_info_clear(void *util
, const char *str UNUSED
)
508 struct extra_file_info
*info
= util
;
514 static int add_file_cb(const struct option
*opt
, const char *arg
, int unset
)
516 struct archiver_args
*args
= opt
->value
;
517 const char **basep
= (const char **)opt
->defval
;
518 const char *base
= *basep
;
520 struct string_list_item
*item
;
521 struct extra_file_info
*info
;
524 string_list_clear_func(&args
->extra_files
,
525 extra_file_info_clear
);
532 info
= xmalloc(sizeof(*info
));
533 info
->base
= xstrdup_or_null(base
);
535 if (!strcmp(opt
->long_name
, "add-file")) {
536 path
= prefix_filename(args
->prefix
, arg
);
537 if (stat(path
, &info
->stat
))
538 die(_("File not found: %s"), path
);
539 if (!S_ISREG(info
->stat
.st_mode
))
540 die(_("Not a regular file: %s"), path
);
541 info
->content
= NULL
; /* read the file later */
542 } else if (!strcmp(opt
->long_name
, "add-virtual-file")) {
543 struct strbuf buf
= STRBUF_INIT
;
548 else if (unquote_c_style(&buf
, p
, &p
) < 0)
549 die(_("unclosed quote: '%s'"), arg
);
552 die(_("missing colon: '%s'"), arg
);
555 die(_("empty file name: '%s'"), arg
);
558 strbuf_detach(&buf
, NULL
) : xstrndup(arg
, p
- arg
);
562 path
= prefix_filename(args
->prefix
, path
);
565 memset(&info
->stat
, 0, sizeof(info
->stat
));
566 info
->stat
.st_mode
= S_IFREG
| 0644;
567 info
->content
= xstrdup(p
+ 1);
568 info
->stat
.st_size
= strlen(info
->content
);
570 BUG("add_file_cb() called for %s", opt
->long_name
);
572 item
= string_list_append_nodup(&args
->extra_files
, path
);
578 static int number_callback(const struct option
*opt
, const char *arg
, int unset
)
580 BUG_ON_OPT_NEG(unset
);
581 *(int *)opt
->value
= strtol(arg
, NULL
, 10);
585 static int parse_archive_args(int argc
, const char **argv
,
586 const struct archiver
**ar
, struct archiver_args
*args
,
587 const char *name_hint
, int is_remote
)
589 const char *format
= NULL
;
590 const char *base
= NULL
;
591 const char *remote
= NULL
;
592 const char *exec
= NULL
;
593 const char *output
= NULL
;
594 const char *mtime_option
= NULL
;
595 int compression_level
= -1;
599 int worktree_attributes
= 0;
600 struct option opts
[] = {
602 OPT_STRING(0, "format", &format
, N_("fmt"), N_("archive format")),
603 OPT_STRING(0, "prefix", &base
, N_("prefix"),
604 N_("prepend prefix to each pathname in the archive")),
605 { OPTION_CALLBACK
, 0, "add-file", args
, N_("file"),
606 N_("add untracked file to archive"), 0, add_file_cb
,
608 { OPTION_CALLBACK
, 0, "add-virtual-file", args
,
609 N_("path:content"), N_("add untracked file to archive"), 0,
610 add_file_cb
, (intptr_t)&base
},
611 OPT_STRING('o', "output", &output
, N_("file"),
612 N_("write the archive to this file")),
613 OPT_BOOL(0, "worktree-attributes", &worktree_attributes
,
614 N_("read .gitattributes in working directory")),
615 OPT__VERBOSE(&verbose
, N_("report archived files on stderr")),
616 { OPTION_STRING
, 0, "mtime", &mtime_option
, N_("time"),
617 N_("set modification time of archive entries"),
619 OPT_NUMBER_CALLBACK(&compression_level
,
620 N_("set compression level"), number_callback
),
622 OPT_BOOL('l', "list", &list
,
623 N_("list supported archive formats")),
625 OPT_STRING(0, "remote", &remote
, N_("repo"),
626 N_("retrieve the archive from remote repository <repo>")),
627 OPT_STRING(0, "exec", &exec
, N_("command"),
628 N_("path to the remote git-upload-archive command")),
632 argc
= parse_options(argc
, argv
, NULL
, opts
, archive_usage
, 0);
635 die(_("Unexpected option --remote"));
637 die(_("the option '%s' requires '%s'"), "--exec", "--remote");
639 die(_("Unexpected option --output"));
640 if (is_remote
&& args
->extra_files
.nr
)
641 die(_("options '%s' and '%s' cannot be used together"), "--add-file", "--remote");
647 for (i
= 0; i
< nr_archivers
; i
++)
648 if (!is_remote
|| archivers
[i
]->flags
& ARCHIVER_REMOTE
)
649 printf("%s\n", archivers
[i
]->name
);
653 if (!format
&& name_hint
)
654 format
= archive_format_from_filename(name_hint
);
658 /* We need at least one parameter -- tree-ish */
660 usage_with_options(archive_usage
, opts
);
661 *ar
= lookup_archiver(format
);
662 if (!*ar
|| (is_remote
&& !((*ar
)->flags
& ARCHIVER_REMOTE
)))
663 die(_("Unknown archive format '%s'"), format
);
665 args
->compression_level
= Z_DEFAULT_COMPRESSION
;
666 if (compression_level
!= -1) {
667 int levels_ok
= (*ar
)->flags
& ARCHIVER_WANT_COMPRESSION_LEVELS
;
668 int high_ok
= (*ar
)->flags
& ARCHIVER_HIGH_COMPRESSION_LEVELS
;
669 if (levels_ok
&& (compression_level
<= 9 || high_ok
))
670 args
->compression_level
= compression_level
;
672 die(_("Argument not supported for format '%s': -%d"),
673 format
, compression_level
);
676 args
->verbose
= verbose
;
678 args
->baselen
= strlen(base
);
679 args
->worktree_attributes
= worktree_attributes
;
680 args
->mtime_option
= mtime_option
;
685 int write_archive(int argc
, const char **argv
, const char *prefix
,
686 struct repository
*repo
,
687 const char *name_hint
, int remote
)
689 const struct archiver
*ar
= NULL
;
690 struct pretty_print_describe_status describe_status
= {0};
691 struct pretty_print_context ctx
= {0};
692 struct archiver_args args
;
695 git_config_get_bool("uploadarchive.allowunreachable", &remote_allow_unreachable
);
696 git_config(git_default_config
, NULL
);
698 describe_status
.max_invocations
= 1;
699 ctx
.date_mode
.type
= DATE_NORMAL
;
700 ctx
.abbrev
= DEFAULT_ABBREV
;
701 ctx
.describe_status
= &describe_status
;
702 args
.pretty_ctx
= &ctx
;
704 args
.prefix
= prefix
;
705 string_list_init_dup(&args
.extra_files
);
706 argc
= parse_archive_args(argc
, argv
, &ar
, &args
, name_hint
, remote
);
707 if (!startup_info
->have_repository
) {
709 * We know this will die() with an error, so we could just
710 * die ourselves; but its error message will be more specific
711 * than what we could write here.
713 setup_git_directory();
716 parse_treeish_arg(argv
, &args
, prefix
, remote
);
717 parse_pathspec_arg(argv
+ 1, &args
);
719 rc
= ar
->write_archive(ar
, &args
);
721 string_list_clear_func(&args
.extra_files
, extra_file_info_clear
);
723 clear_pathspec(&args
.pathspec
);
728 static int match_extension(const char *filename
, const char *ext
)
730 int prefixlen
= strlen(filename
) - strlen(ext
);
733 * We need 1 character for the '.', and 1 character to ensure that the
734 * prefix is non-empty (k.e., we don't match .tar.gz with no actual
737 if (prefixlen
< 2 || filename
[prefixlen
- 1] != '.')
739 return !strcmp(filename
+ prefixlen
, ext
);
742 const char *archive_format_from_filename(const char *filename
)
746 for (i
= 0; i
< nr_archivers
; i
++)
747 if (match_extension(filename
, archivers
[i
]->name
))
748 return archivers
[i
]->name
;