1 #include "git-compat-util.h"
8 #include "object-store.h"
10 #include "tree-walk.h"
13 #include "parse-options.h"
14 #include "unpack-trees.h"
18 static char const * const archive_usage
[] = {
19 N_("git archive [<options>] <tree-ish> [<path>...]"),
21 N_("git archive --remote <repo> [--exec <cmd>] [<options>] <tree-ish> [<path>...]"),
22 N_("git archive --remote <repo> [--exec <cmd>] --list"),
26 static const struct archiver
**archivers
;
27 static int nr_archivers
;
28 static int alloc_archivers
;
29 static int remote_allow_unreachable
;
31 void register_archiver(struct archiver
*ar
)
33 ALLOC_GROW(archivers
, nr_archivers
+ 1, alloc_archivers
);
34 archivers
[nr_archivers
++] = ar
;
37 void init_archivers(void)
43 static void format_subst(const struct commit
*commit
,
44 const char *src
, size_t len
,
45 struct strbuf
*buf
, struct pretty_print_context
*ctx
)
48 struct strbuf fmt
= STRBUF_INIT
;
51 to_free
= strbuf_detach(buf
, NULL
);
55 b
= memmem(src
, len
, "$Format:", 8);
58 c
= memchr(b
+ 8, '$', (src
+ len
) - b
- 8);
63 strbuf_add(&fmt
, b
+ 8, c
- b
- 8);
65 strbuf_add(buf
, src
, b
- src
);
66 format_commit_message(commit
, fmt
.buf
, buf
, ctx
);
70 strbuf_add(buf
, src
, len
);
75 static void *object_file_to_archive(const struct archiver_args
*args
,
77 const struct object_id
*oid
,
79 enum object_type
*type
,
83 const struct commit
*commit
= args
->convert
? args
->commit
: NULL
;
84 struct checkout_metadata meta
;
86 init_checkout_metadata(&meta
, args
->refname
,
87 args
->commit_oid
? args
->commit_oid
:
88 (args
->tree
? &args
->tree
->object
.oid
: NULL
), oid
);
90 path
+= args
->baselen
;
91 buffer
= read_object_file(oid
, type
, sizep
);
92 if (buffer
&& S_ISREG(mode
)) {
93 struct strbuf buf
= STRBUF_INIT
;
96 strbuf_attach(&buf
, buffer
, *sizep
, *sizep
+ 1);
97 convert_to_working_tree(args
->repo
->index
, path
, buf
.buf
, buf
.len
, &buf
, &meta
);
99 format_subst(commit
, buf
.buf
, buf
.len
, &buf
, args
->pretty_ctx
);
100 buffer
= strbuf_detach(&buf
, &size
);
108 struct directory
*up
;
109 struct object_id oid
;
112 char path
[FLEX_ARRAY
];
115 struct archiver_context
{
116 struct archiver_args
*args
;
117 write_archive_entry_fn_t write_entry
;
118 struct directory
*bottom
;
121 static const struct attr_check
*get_archive_attrs(struct index_state
*istate
,
124 static struct attr_check
*check
;
126 check
= attr_check_initl("export-ignore", "export-subst", NULL
);
127 git_check_attr(istate
, NULL
, path
, check
);
131 static int check_attr_export_ignore(const struct attr_check
*check
)
133 return check
&& ATTR_TRUE(check
->items
[0].value
);
136 static int check_attr_export_subst(const struct attr_check
*check
)
138 return check
&& ATTR_TRUE(check
->items
[1].value
);
141 static int write_archive_entry(const struct object_id
*oid
, const char *base
,
142 int baselen
, const char *filename
, unsigned mode
,
145 static struct strbuf path
= STRBUF_INIT
;
146 struct archiver_context
*c
= context
;
147 struct archiver_args
*args
= c
->args
;
148 write_archive_entry_fn_t write_entry
= c
->write_entry
;
150 const char *path_without_prefix
;
153 enum object_type type
;
157 strbuf_grow(&path
, PATH_MAX
);
158 strbuf_add(&path
, args
->base
, args
->baselen
);
159 strbuf_add(&path
, base
, baselen
);
160 strbuf_addstr(&path
, filename
);
161 if (S_ISDIR(mode
) || S_ISGITLINK(mode
))
162 strbuf_addch(&path
, '/');
163 path_without_prefix
= path
.buf
+ args
->baselen
;
165 if (!S_ISDIR(mode
)) {
166 const struct attr_check
*check
;
167 check
= get_archive_attrs(args
->repo
->index
, path_without_prefix
);
168 if (check_attr_export_ignore(check
))
170 args
->convert
= check_attr_export_subst(check
);
174 fprintf(stderr
, "%.*s\n", (int)path
.len
, path
.buf
);
176 if (S_ISDIR(mode
) || S_ISGITLINK(mode
)) {
177 err
= write_entry(args
, oid
, path
.buf
, path
.len
, mode
, NULL
, 0);
180 return (S_ISDIR(mode
) ? READ_TREE_RECURSIVE
: 0);
184 if (S_ISREG(mode
) && !args
->convert
&&
185 oid_object_info(args
->repo
, oid
, &size
) == OBJ_BLOB
&&
186 size
> big_file_threshold
)
187 return write_entry(args
, oid
, path
.buf
, path
.len
, mode
, NULL
, size
);
189 buffer
= object_file_to_archive(args
, path
.buf
, oid
, mode
, &type
, &size
);
191 return error(_("cannot read '%s'"), oid_to_hex(oid
));
192 err
= write_entry(args
, oid
, path
.buf
, path
.len
, mode
, buffer
, size
);
197 static void queue_directory(const struct object_id
*oid
,
198 struct strbuf
*base
, const char *filename
,
199 unsigned mode
, struct archiver_context
*c
)
202 size_t len
= st_add4(base
->len
, 1, strlen(filename
), 1);
203 d
= xmalloc(st_add(sizeof(*d
), len
));
205 d
->baselen
= base
->len
;
208 d
->len
= xsnprintf(d
->path
, len
, "%.*s%s/", (int)base
->len
, base
->buf
, filename
);
209 oidcpy(&d
->oid
, oid
);
212 static int write_directory(struct archiver_context
*c
)
214 struct directory
*d
= c
->bottom
;
220 d
->path
[d
->len
- 1] = '\0'; /* no trailing slash */
222 write_directory(c
) ||
223 write_archive_entry(&d
->oid
, d
->path
, d
->baselen
,
224 d
->path
+ d
->baselen
, d
->mode
,
225 c
) != READ_TREE_RECURSIVE
;
230 static int queue_or_write_archive_entry(const struct object_id
*oid
,
231 struct strbuf
*base
, const char *filename
,
232 unsigned mode
, void *context
)
234 struct archiver_context
*c
= context
;
237 !(base
->len
>= c
->bottom
->len
&&
238 !strncmp(base
->buf
, c
->bottom
->path
, c
->bottom
->len
))) {
239 struct directory
*next
= c
->bottom
->up
;
245 size_t baselen
= base
->len
;
246 const struct attr_check
*check
;
248 /* Borrow base, but restore its original value when done. */
249 strbuf_addstr(base
, filename
);
250 strbuf_addch(base
, '/');
251 check
= get_archive_attrs(c
->args
->repo
->index
, base
->buf
);
252 strbuf_setlen(base
, baselen
);
254 if (check_attr_export_ignore(check
))
256 queue_directory(oid
, base
, filename
, mode
, c
);
257 return READ_TREE_RECURSIVE
;
260 if (write_directory(c
))
262 return write_archive_entry(oid
, base
->buf
, base
->len
, filename
, mode
,
266 struct extra_file_info
{
272 int write_archive_entries(struct archiver_args
*args
,
273 write_archive_entry_fn_t write_entry
)
275 struct archiver_context context
;
276 struct unpack_trees_options opts
;
279 struct strbuf path_in_archive
= STRBUF_INIT
;
280 struct strbuf content
= STRBUF_INIT
;
281 struct object_id fake_oid
;
284 oidcpy(&fake_oid
, null_oid());
286 if (args
->baselen
> 0 && args
->base
[args
->baselen
- 1] == '/') {
287 size_t len
= args
->baselen
;
289 while (len
> 1 && args
->base
[len
- 2] == '/')
292 fprintf(stderr
, "%.*s\n", (int)len
, args
->base
);
293 err
= write_entry(args
, &args
->tree
->object
.oid
, args
->base
,
294 len
, 040777, NULL
, 0);
299 memset(&context
, 0, sizeof(context
));
301 context
.write_entry
= write_entry
;
304 * Setup index and instruct attr to read index only
306 if (!args
->worktree_attributes
) {
307 memset(&opts
, 0, sizeof(opts
));
310 opts
.src_index
= args
->repo
->index
;
311 opts
.dst_index
= args
->repo
->index
;
312 opts
.fn
= oneway_merge
;
313 init_tree_desc(&t
, args
->tree
->buffer
, args
->tree
->size
);
314 if (unpack_trees(1, &t
, &opts
))
316 git_attr_set_direction(GIT_ATTR_INDEX
);
319 err
= read_tree(args
->repo
, args
->tree
,
321 queue_or_write_archive_entry
,
323 if (err
== READ_TREE_RECURSIVE
)
325 while (context
.bottom
) {
326 struct directory
*next
= context
.bottom
->up
;
327 free(context
.bottom
);
328 context
.bottom
= next
;
331 for (i
= 0; i
< args
->extra_files
.nr
; i
++) {
332 struct string_list_item
*item
= args
->extra_files
.items
+ i
;
333 char *path
= item
->string
;
334 struct extra_file_info
*info
= item
->util
;
336 put_be64(fake_oid
.hash
, i
+ 1);
338 if (!info
->content
) {
339 strbuf_reset(&path_in_archive
);
341 strbuf_addstr(&path_in_archive
, info
->base
);
342 strbuf_addstr(&path_in_archive
, basename(path
));
344 strbuf_reset(&content
);
345 if (strbuf_read_file(&content
, path
, info
->stat
.st_size
) < 0)
346 err
= error_errno(_("cannot read '%s'"), path
);
348 err
= write_entry(args
, &fake_oid
, path_in_archive
.buf
,
350 canon_mode(info
->stat
.st_mode
),
351 content
.buf
, content
.len
);
353 err
= write_entry(args
, &fake_oid
,
355 canon_mode(info
->stat
.st_mode
),
356 info
->content
, info
->stat
.st_size
);
362 strbuf_release(&path_in_archive
);
363 strbuf_release(&content
);
368 static const struct archiver
*lookup_archiver(const char *name
)
375 for (i
= 0; i
< nr_archivers
; i
++) {
376 if (!strcmp(name
, archivers
[i
]->name
))
382 struct path_exists_context
{
383 struct pathspec pathspec
;
384 struct archiver_args
*args
;
387 static int reject_entry(const struct object_id
*oid UNUSED
,
389 const char *filename
, unsigned mode
,
393 struct path_exists_context
*ctx
= context
;
396 struct strbuf sb
= STRBUF_INIT
;
397 strbuf_addbuf(&sb
, base
);
398 strbuf_addstr(&sb
, filename
);
399 if (!match_pathspec(ctx
->args
->repo
->index
,
401 sb
.buf
, sb
.len
, 0, NULL
, 1))
402 ret
= READ_TREE_RECURSIVE
;
408 static int path_exists(struct archiver_args
*args
, const char *path
)
410 const char *paths
[] = { path
, NULL
};
411 struct path_exists_context ctx
;
415 parse_pathspec(&ctx
.pathspec
, 0, 0, "", paths
);
416 ctx
.pathspec
.recursive
= 1;
417 ret
= read_tree(args
->repo
, args
->tree
,
420 clear_pathspec(&ctx
.pathspec
);
424 static void parse_pathspec_arg(const char **pathspec
,
425 struct archiver_args
*ar_args
)
428 * must be consistent with parse_pathspec in path_exists()
429 * Also if pathspec patterns are dependent, we're in big
430 * trouble as we test each one separately
432 parse_pathspec(&ar_args
->pathspec
, 0,
433 PATHSPEC_PREFER_FULL
,
435 ar_args
->pathspec
.recursive
= 1;
438 if (**pathspec
&& !path_exists(ar_args
, *pathspec
))
439 die(_("pathspec '%s' did not match any files"), *pathspec
);
445 static void parse_treeish_arg(const char **argv
,
446 struct archiver_args
*ar_args
, const char *prefix
,
449 const char *name
= argv
[0];
450 const struct object_id
*commit_oid
;
453 const struct commit
*commit
;
454 struct object_id oid
;
457 /* Remotes are only allowed to fetch actual refs */
458 if (remote
&& !remote_allow_unreachable
) {
459 const char *colon
= strchrnul(name
, ':');
460 int refnamelen
= colon
- name
;
462 if (!dwim_ref(name
, refnamelen
, &oid
, &ref
, 0))
463 die(_("no such ref: %.*s"), refnamelen
, name
);
465 dwim_ref(name
, strlen(name
), &oid
, &ref
, 0);
468 if (get_oid(name
, &oid
))
469 die(_("not a valid object name: %s"), name
);
471 commit
= lookup_commit_reference_gently(ar_args
->repo
, &oid
, 1);
473 commit_oid
= &commit
->object
.oid
;
474 archive_time
= commit
->date
;
477 archive_time
= time(NULL
);
479 if (ar_args
->mtime_option
)
480 archive_time
= approxidate(ar_args
->mtime_option
);
482 tree
= parse_tree_indirect(&oid
);
484 die(_("not a tree object: %s"), oid_to_hex(&oid
));
487 struct object_id tree_oid
;
491 err
= get_tree_entry(ar_args
->repo
,
495 if (err
|| !S_ISDIR(mode
))
496 die(_("current working directory is untracked"));
498 tree
= parse_tree_indirect(&tree_oid
);
500 ar_args
->refname
= ref
;
501 ar_args
->tree
= tree
;
502 ar_args
->commit_oid
= commit_oid
;
503 ar_args
->commit
= commit
;
504 ar_args
->time
= archive_time
;
507 static void extra_file_info_clear(void *util
, const char *str UNUSED
)
509 struct extra_file_info
*info
= util
;
515 static int add_file_cb(const struct option
*opt
, const char *arg
, int unset
)
517 struct archiver_args
*args
= opt
->value
;
518 const char **basep
= (const char **)opt
->defval
;
519 const char *base
= *basep
;
521 struct string_list_item
*item
;
522 struct extra_file_info
*info
;
525 string_list_clear_func(&args
->extra_files
,
526 extra_file_info_clear
);
533 info
= xmalloc(sizeof(*info
));
534 info
->base
= xstrdup_or_null(base
);
536 if (!strcmp(opt
->long_name
, "add-file")) {
537 path
= prefix_filename(args
->prefix
, arg
);
538 if (stat(path
, &info
->stat
))
539 die(_("File not found: %s"), path
);
540 if (!S_ISREG(info
->stat
.st_mode
))
541 die(_("Not a regular file: %s"), path
);
542 info
->content
= NULL
; /* read the file later */
543 } else if (!strcmp(opt
->long_name
, "add-virtual-file")) {
544 struct strbuf buf
= STRBUF_INIT
;
549 else if (unquote_c_style(&buf
, p
, &p
) < 0)
550 die(_("unclosed quote: '%s'"), arg
);
553 die(_("missing colon: '%s'"), arg
);
556 die(_("empty file name: '%s'"), arg
);
559 strbuf_detach(&buf
, NULL
) : xstrndup(arg
, p
- arg
);
563 path
= prefix_filename(args
->prefix
, path
);
566 memset(&info
->stat
, 0, sizeof(info
->stat
));
567 info
->stat
.st_mode
= S_IFREG
| 0644;
568 info
->content
= xstrdup(p
+ 1);
569 info
->stat
.st_size
= strlen(info
->content
);
571 BUG("add_file_cb() called for %s", opt
->long_name
);
573 item
= string_list_append_nodup(&args
->extra_files
, path
);
579 static int number_callback(const struct option
*opt
, const char *arg
, int unset
)
581 BUG_ON_OPT_NEG(unset
);
582 *(int *)opt
->value
= strtol(arg
, NULL
, 10);
586 static int parse_archive_args(int argc
, const char **argv
,
587 const struct archiver
**ar
, struct archiver_args
*args
,
588 const char *name_hint
, int is_remote
)
590 const char *format
= NULL
;
591 const char *base
= NULL
;
592 const char *remote
= NULL
;
593 const char *exec
= NULL
;
594 const char *output
= NULL
;
595 const char *mtime_option
= NULL
;
596 int compression_level
= -1;
600 int worktree_attributes
= 0;
601 struct option opts
[] = {
603 OPT_STRING(0, "format", &format
, N_("fmt"), N_("archive format")),
604 OPT_STRING(0, "prefix", &base
, N_("prefix"),
605 N_("prepend prefix to each pathname in the archive")),
606 { OPTION_CALLBACK
, 0, "add-file", args
, N_("file"),
607 N_("add untracked file to archive"), 0, add_file_cb
,
609 { OPTION_CALLBACK
, 0, "add-virtual-file", args
,
610 N_("path:content"), N_("add untracked file to archive"), 0,
611 add_file_cb
, (intptr_t)&base
},
612 OPT_STRING('o', "output", &output
, N_("file"),
613 N_("write the archive to this file")),
614 OPT_BOOL(0, "worktree-attributes", &worktree_attributes
,
615 N_("read .gitattributes in working directory")),
616 OPT__VERBOSE(&verbose
, N_("report archived files on stderr")),
617 { OPTION_STRING
, 0, "mtime", &mtime_option
, N_("time"),
618 N_("set modification time of archive entries"),
620 OPT_NUMBER_CALLBACK(&compression_level
,
621 N_("set compression level"), number_callback
),
623 OPT_BOOL('l', "list", &list
,
624 N_("list supported archive formats")),
626 OPT_STRING(0, "remote", &remote
, N_("repo"),
627 N_("retrieve the archive from remote repository <repo>")),
628 OPT_STRING(0, "exec", &exec
, N_("command"),
629 N_("path to the remote git-upload-archive command")),
633 argc
= parse_options(argc
, argv
, NULL
, opts
, archive_usage
, 0);
636 die(_("Unexpected option --remote"));
638 die(_("the option '%s' requires '%s'"), "--exec", "--remote");
640 die(_("Unexpected option --output"));
641 if (is_remote
&& args
->extra_files
.nr
)
642 die(_("options '%s' and '%s' cannot be used together"), "--add-file", "--remote");
648 for (i
= 0; i
< nr_archivers
; i
++)
649 if (!is_remote
|| archivers
[i
]->flags
& ARCHIVER_REMOTE
)
650 printf("%s\n", archivers
[i
]->name
);
654 if (!format
&& name_hint
)
655 format
= archive_format_from_filename(name_hint
);
659 /* We need at least one parameter -- tree-ish */
661 usage_with_options(archive_usage
, opts
);
662 *ar
= lookup_archiver(format
);
663 if (!*ar
|| (is_remote
&& !((*ar
)->flags
& ARCHIVER_REMOTE
)))
664 die(_("Unknown archive format '%s'"), format
);
666 args
->compression_level
= Z_DEFAULT_COMPRESSION
;
667 if (compression_level
!= -1) {
668 int levels_ok
= (*ar
)->flags
& ARCHIVER_WANT_COMPRESSION_LEVELS
;
669 int high_ok
= (*ar
)->flags
& ARCHIVER_HIGH_COMPRESSION_LEVELS
;
670 if (levels_ok
&& (compression_level
<= 9 || high_ok
))
671 args
->compression_level
= compression_level
;
673 die(_("Argument not supported for format '%s': -%d"),
674 format
, compression_level
);
677 args
->verbose
= verbose
;
679 args
->baselen
= strlen(base
);
680 args
->worktree_attributes
= worktree_attributes
;
681 args
->mtime_option
= mtime_option
;
686 int write_archive(int argc
, const char **argv
, const char *prefix
,
687 struct repository
*repo
,
688 const char *name_hint
, int remote
)
690 const struct archiver
*ar
= NULL
;
691 struct pretty_print_describe_status describe_status
= {0};
692 struct pretty_print_context ctx
= {0};
693 struct archiver_args args
;
696 git_config_get_bool("uploadarchive.allowunreachable", &remote_allow_unreachable
);
697 git_config(git_default_config
, NULL
);
699 describe_status
.max_invocations
= 1;
700 ctx
.date_mode
.type
= DATE_NORMAL
;
701 ctx
.abbrev
= DEFAULT_ABBREV
;
702 ctx
.describe_status
= &describe_status
;
703 args
.pretty_ctx
= &ctx
;
705 args
.prefix
= prefix
;
706 string_list_init_dup(&args
.extra_files
);
707 argc
= parse_archive_args(argc
, argv
, &ar
, &args
, name_hint
, remote
);
708 if (!startup_info
->have_repository
) {
710 * We know this will die() with an error, so we could just
711 * die ourselves; but its error message will be more specific
712 * than what we could write here.
714 setup_git_directory();
717 parse_treeish_arg(argv
, &args
, prefix
, remote
);
718 parse_pathspec_arg(argv
+ 1, &args
);
720 rc
= ar
->write_archive(ar
, &args
);
722 string_list_clear_func(&args
.extra_files
, extra_file_info_clear
);
724 clear_pathspec(&args
.pathspec
);
729 static int match_extension(const char *filename
, const char *ext
)
731 int prefixlen
= strlen(filename
) - strlen(ext
);
734 * We need 1 character for the '.', and 1 character to ensure that the
735 * prefix is non-empty (k.e., we don't match .tar.gz with no actual
738 if (prefixlen
< 2 || filename
[prefixlen
- 1] != '.')
740 return !strcmp(filename
+ prefixlen
, ext
);
743 const char *archive_format_from_filename(const char *filename
)
747 for (i
= 0; i
< nr_archivers
; i
++)
748 if (match_extension(filename
, archivers
[i
]->name
))
749 return archivers
[i
]->name
;