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 void init_archivers(void)
38 static void format_subst(const struct commit
*commit
,
39 const char *src
, size_t len
,
40 struct strbuf
*buf
, struct pretty_print_context
*ctx
)
43 struct strbuf fmt
= STRBUF_INIT
;
46 to_free
= strbuf_detach(buf
, NULL
);
50 b
= memmem(src
, len
, "$Format:", 8);
53 c
= memchr(b
+ 8, '$', (src
+ len
) - b
- 8);
58 strbuf_add(&fmt
, b
+ 8, c
- b
- 8);
60 strbuf_add(buf
, src
, b
- src
);
61 format_commit_message(commit
, fmt
.buf
, buf
, ctx
);
65 strbuf_add(buf
, src
, len
);
70 static void *object_file_to_archive(const struct archiver_args
*args
,
72 const struct object_id
*oid
,
74 enum object_type
*type
,
78 const struct commit
*commit
= args
->convert
? args
->commit
: NULL
;
79 struct checkout_metadata meta
;
81 init_checkout_metadata(&meta
, args
->refname
,
82 args
->commit_oid
? args
->commit_oid
:
83 (args
->tree
? &args
->tree
->object
.oid
: NULL
), oid
);
85 path
+= args
->baselen
;
86 buffer
= read_object_file(oid
, type
, sizep
);
87 if (buffer
&& S_ISREG(mode
)) {
88 struct strbuf buf
= STRBUF_INIT
;
91 strbuf_attach(&buf
, buffer
, *sizep
, *sizep
+ 1);
92 convert_to_working_tree(args
->repo
->index
, path
, buf
.buf
, buf
.len
, &buf
, &meta
);
94 format_subst(commit
, buf
.buf
, buf
.len
, &buf
, args
->pretty_ctx
);
95 buffer
= strbuf_detach(&buf
, &size
);
103 struct directory
*up
;
104 struct object_id oid
;
107 char path
[FLEX_ARRAY
];
110 struct archiver_context
{
111 struct archiver_args
*args
;
112 write_archive_entry_fn_t write_entry
;
113 struct directory
*bottom
;
116 static const struct attr_check
*get_archive_attrs(struct index_state
*istate
,
119 static struct attr_check
*check
;
121 check
= attr_check_initl("export-ignore", "export-subst", NULL
);
122 git_check_attr(istate
, path
, check
);
126 static int check_attr_export_ignore(const struct attr_check
*check
)
128 return check
&& ATTR_TRUE(check
->items
[0].value
);
131 static int check_attr_export_subst(const struct attr_check
*check
)
133 return check
&& ATTR_TRUE(check
->items
[1].value
);
136 static int write_archive_entry(const struct object_id
*oid
, const char *base
,
137 int baselen
, const char *filename
, unsigned mode
,
140 static struct strbuf path
= STRBUF_INIT
;
141 struct archiver_context
*c
= context
;
142 struct archiver_args
*args
= c
->args
;
143 write_archive_entry_fn_t write_entry
= c
->write_entry
;
145 const char *path_without_prefix
;
148 enum object_type type
;
152 strbuf_grow(&path
, PATH_MAX
);
153 strbuf_add(&path
, args
->base
, args
->baselen
);
154 strbuf_add(&path
, base
, baselen
);
155 strbuf_addstr(&path
, filename
);
156 if (S_ISDIR(mode
) || S_ISGITLINK(mode
))
157 strbuf_addch(&path
, '/');
158 path_without_prefix
= path
.buf
+ args
->baselen
;
160 if (!S_ISDIR(mode
)) {
161 const struct attr_check
*check
;
162 check
= get_archive_attrs(args
->repo
->index
, path_without_prefix
);
163 if (check_attr_export_ignore(check
))
165 args
->convert
= check_attr_export_subst(check
);
168 if (S_ISDIR(mode
) || S_ISGITLINK(mode
)) {
170 fprintf(stderr
, "%.*s\n", (int)path
.len
, path
.buf
);
171 err
= write_entry(args
, oid
, path
.buf
, path
.len
, mode
, NULL
, 0);
174 return (S_ISDIR(mode
) ? READ_TREE_RECURSIVE
: 0);
178 fprintf(stderr
, "%.*s\n", (int)path
.len
, path
.buf
);
181 if (S_ISREG(mode
) && !args
->convert
&&
182 oid_object_info(args
->repo
, oid
, &size
) == OBJ_BLOB
&&
183 size
> big_file_threshold
)
184 return write_entry(args
, oid
, path
.buf
, path
.len
, mode
, NULL
, size
);
186 buffer
= object_file_to_archive(args
, path
.buf
, oid
, mode
, &type
, &size
);
188 return error(_("cannot read %s"), oid_to_hex(oid
));
189 err
= write_entry(args
, oid
, path
.buf
, path
.len
, mode
, buffer
, size
);
194 static void queue_directory(const unsigned char *sha1
,
195 struct strbuf
*base
, const char *filename
,
196 unsigned mode
, struct archiver_context
*c
)
199 size_t len
= st_add4(base
->len
, 1, strlen(filename
), 1);
200 d
= xmalloc(st_add(sizeof(*d
), len
));
202 d
->baselen
= base
->len
;
205 d
->len
= xsnprintf(d
->path
, len
, "%.*s%s/", (int)base
->len
, base
->buf
, filename
);
206 oidread(&d
->oid
, sha1
);
209 static int write_directory(struct archiver_context
*c
)
211 struct directory
*d
= c
->bottom
;
217 d
->path
[d
->len
- 1] = '\0'; /* no trailing slash */
219 write_directory(c
) ||
220 write_archive_entry(&d
->oid
, d
->path
, d
->baselen
,
221 d
->path
+ d
->baselen
, d
->mode
,
222 c
) != READ_TREE_RECURSIVE
;
227 static int queue_or_write_archive_entry(const struct object_id
*oid
,
228 struct strbuf
*base
, const char *filename
,
229 unsigned mode
, void *context
)
231 struct archiver_context
*c
= context
;
234 !(base
->len
>= c
->bottom
->len
&&
235 !strncmp(base
->buf
, c
->bottom
->path
, c
->bottom
->len
))) {
236 struct directory
*next
= c
->bottom
->up
;
242 size_t baselen
= base
->len
;
243 const struct attr_check
*check
;
245 /* Borrow base, but restore its original value when done. */
246 strbuf_addstr(base
, filename
);
247 strbuf_addch(base
, '/');
248 check
= get_archive_attrs(c
->args
->repo
->index
, base
->buf
);
249 strbuf_setlen(base
, baselen
);
251 if (check_attr_export_ignore(check
))
253 queue_directory(oid
->hash
, base
, filename
,
255 return READ_TREE_RECURSIVE
;
258 if (write_directory(c
))
260 return write_archive_entry(oid
, base
->buf
, base
->len
, filename
, mode
,
264 struct extra_file_info
{
269 int write_archive_entries(struct archiver_args
*args
,
270 write_archive_entry_fn_t write_entry
)
272 struct archiver_context context
;
273 struct unpack_trees_options opts
;
276 struct strbuf path_in_archive
= STRBUF_INIT
;
277 struct strbuf content
= STRBUF_INIT
;
278 struct object_id fake_oid
;
281 oidcpy(&fake_oid
, null_oid());
283 if (args
->baselen
> 0 && args
->base
[args
->baselen
- 1] == '/') {
284 size_t len
= args
->baselen
;
286 while (len
> 1 && args
->base
[len
- 2] == '/')
289 fprintf(stderr
, "%.*s\n", (int)len
, args
->base
);
290 err
= write_entry(args
, &args
->tree
->object
.oid
, args
->base
,
291 len
, 040777, NULL
, 0);
296 memset(&context
, 0, sizeof(context
));
298 context
.write_entry
= write_entry
;
301 * Setup index and instruct attr to read index only
303 if (!args
->worktree_attributes
) {
304 memset(&opts
, 0, sizeof(opts
));
307 opts
.src_index
= args
->repo
->index
;
308 opts
.dst_index
= args
->repo
->index
;
309 opts
.fn
= oneway_merge
;
310 init_tree_desc(&t
, args
->tree
->buffer
, args
->tree
->size
);
311 if (unpack_trees(1, &t
, &opts
))
313 git_attr_set_direction(GIT_ATTR_INDEX
);
316 err
= read_tree(args
->repo
, args
->tree
,
318 queue_or_write_archive_entry
,
320 if (err
== READ_TREE_RECURSIVE
)
322 while (context
.bottom
) {
323 struct directory
*next
= context
.bottom
->up
;
324 free(context
.bottom
);
325 context
.bottom
= next
;
328 for (i
= 0; i
< args
->extra_files
.nr
; i
++) {
329 struct string_list_item
*item
= args
->extra_files
.items
+ i
;
330 char *path
= item
->string
;
331 struct extra_file_info
*info
= item
->util
;
333 put_be64(fake_oid
.hash
, i
+ 1);
335 strbuf_reset(&path_in_archive
);
337 strbuf_addstr(&path_in_archive
, info
->base
);
338 strbuf_addstr(&path_in_archive
, basename(path
));
340 strbuf_reset(&content
);
341 if (strbuf_read_file(&content
, path
, info
->stat
.st_size
) < 0)
342 err
= error_errno(_("could not read '%s'"), path
);
344 err
= write_entry(args
, &fake_oid
, path_in_archive
.buf
,
347 content
.buf
, content
.len
);
351 strbuf_release(&path_in_archive
);
352 strbuf_release(&content
);
357 static const struct archiver
*lookup_archiver(const char *name
)
364 for (i
= 0; i
< nr_archivers
; i
++) {
365 if (!strcmp(name
, archivers
[i
]->name
))
371 struct path_exists_context
{
372 struct pathspec pathspec
;
373 struct archiver_args
*args
;
376 static int reject_entry(const struct object_id
*oid
, struct strbuf
*base
,
377 const char *filename
, unsigned mode
,
381 struct path_exists_context
*ctx
= context
;
384 struct strbuf sb
= STRBUF_INIT
;
385 strbuf_addbuf(&sb
, base
);
386 strbuf_addstr(&sb
, filename
);
387 if (!match_pathspec(ctx
->args
->repo
->index
,
389 sb
.buf
, sb
.len
, 0, NULL
, 1))
390 ret
= READ_TREE_RECURSIVE
;
396 static int path_exists(struct archiver_args
*args
, const char *path
)
398 const char *paths
[] = { path
, NULL
};
399 struct path_exists_context ctx
;
403 parse_pathspec(&ctx
.pathspec
, 0, 0, "", paths
);
404 ctx
.pathspec
.recursive
= 1;
405 ret
= read_tree(args
->repo
, args
->tree
,
408 clear_pathspec(&ctx
.pathspec
);
412 static void parse_pathspec_arg(const char **pathspec
,
413 struct archiver_args
*ar_args
)
416 * must be consistent with parse_pathspec in path_exists()
417 * Also if pathspec patterns are dependent, we're in big
418 * trouble as we test each one separately
420 parse_pathspec(&ar_args
->pathspec
, 0,
421 PATHSPEC_PREFER_FULL
,
423 ar_args
->pathspec
.recursive
= 1;
426 if (**pathspec
&& !path_exists(ar_args
, *pathspec
))
427 die(_("pathspec '%s' did not match any files"), *pathspec
);
433 static void parse_treeish_arg(const char **argv
,
434 struct archiver_args
*ar_args
, const char *prefix
,
437 const char *name
= argv
[0];
438 const struct object_id
*commit_oid
;
441 const struct commit
*commit
;
442 struct object_id oid
;
445 /* Remotes are only allowed to fetch actual refs */
446 if (remote
&& !remote_allow_unreachable
) {
447 const char *colon
= strchrnul(name
, ':');
448 int refnamelen
= colon
- name
;
450 if (!dwim_ref(name
, refnamelen
, &oid
, &ref
, 0))
451 die(_("no such ref: %.*s"), refnamelen
, name
);
453 dwim_ref(name
, strlen(name
), &oid
, &ref
, 0);
456 if (get_oid(name
, &oid
))
457 die(_("not a valid object name: %s"), name
);
459 commit
= lookup_commit_reference_gently(ar_args
->repo
, &oid
, 1);
461 commit_oid
= &commit
->object
.oid
;
462 archive_time
= commit
->date
;
465 archive_time
= time(NULL
);
468 tree
= parse_tree_indirect(&oid
);
470 die(_("not a tree object: %s"), oid_to_hex(&oid
));
473 struct object_id tree_oid
;
477 err
= get_tree_entry(ar_args
->repo
,
481 if (err
|| !S_ISDIR(mode
))
482 die(_("current working directory is untracked"));
484 tree
= parse_tree_indirect(&tree_oid
);
486 ar_args
->refname
= ref
;
487 ar_args
->tree
= tree
;
488 ar_args
->commit_oid
= commit_oid
;
489 ar_args
->commit
= commit
;
490 ar_args
->time
= archive_time
;
493 static void extra_file_info_clear(void *util
, const char *str
)
495 struct extra_file_info
*info
= util
;
500 static int add_file_cb(const struct option
*opt
, const char *arg
, int unset
)
502 struct archiver_args
*args
= opt
->value
;
503 const char **basep
= (const char **)opt
->defval
;
504 const char *base
= *basep
;
506 struct string_list_item
*item
;
507 struct extra_file_info
*info
;
510 string_list_clear_func(&args
->extra_files
,
511 extra_file_info_clear
);
518 path
= prefix_filename(args
->prefix
, arg
);
519 item
= string_list_append_nodup(&args
->extra_files
, path
);
520 item
->util
= info
= xmalloc(sizeof(*info
));
521 info
->base
= xstrdup_or_null(base
);
522 if (stat(path
, &info
->stat
))
523 die(_("File not found: %s"), path
);
524 if (!S_ISREG(info
->stat
.st_mode
))
525 die(_("Not a regular file: %s"), path
);
529 static int number_callback(const struct option
*opt
, const char *arg
, int unset
)
531 BUG_ON_OPT_NEG(unset
);
532 *(int *)opt
->value
= strtol(arg
, NULL
, 10);
536 static int parse_archive_args(int argc
, const char **argv
,
537 const struct archiver
**ar
, struct archiver_args
*args
,
538 const char *name_hint
, int is_remote
)
540 const char *format
= NULL
;
541 const char *base
= NULL
;
542 const char *remote
= NULL
;
543 const char *exec
= NULL
;
544 const char *output
= NULL
;
545 int compression_level
= -1;
549 int worktree_attributes
= 0;
550 struct option opts
[] = {
552 OPT_STRING(0, "format", &format
, N_("fmt"), N_("archive format")),
553 OPT_STRING(0, "prefix", &base
, N_("prefix"),
554 N_("prepend prefix to each pathname in the archive")),
555 { OPTION_CALLBACK
, 0, "add-file", args
, N_("file"),
556 N_("add untracked file to archive"), 0, add_file_cb
,
558 OPT_STRING('o', "output", &output
, N_("file"),
559 N_("write the archive to this file")),
560 OPT_BOOL(0, "worktree-attributes", &worktree_attributes
,
561 N_("read .gitattributes in working directory")),
562 OPT__VERBOSE(&verbose
, N_("report archived files on stderr")),
563 OPT_NUMBER_CALLBACK(&compression_level
,
564 N_("set compression level"), number_callback
),
566 OPT_BOOL('l', "list", &list
,
567 N_("list supported archive formats")),
569 OPT_STRING(0, "remote", &remote
, N_("repo"),
570 N_("retrieve the archive from remote repository <repo>")),
571 OPT_STRING(0, "exec", &exec
, N_("command"),
572 N_("path to the remote git-upload-archive command")),
576 argc
= parse_options(argc
, argv
, NULL
, opts
, archive_usage
, 0);
579 die(_("Unexpected option --remote"));
581 die(_("Option --exec can only be used together with --remote"));
583 die(_("Unexpected option --output"));
584 if (is_remote
&& args
->extra_files
.nr
)
585 die(_("Options --add-file and --remote cannot be used together"));
591 for (i
= 0; i
< nr_archivers
; i
++)
592 if (!is_remote
|| archivers
[i
]->flags
& ARCHIVER_REMOTE
)
593 printf("%s\n", archivers
[i
]->name
);
597 if (!format
&& name_hint
)
598 format
= archive_format_from_filename(name_hint
);
602 /* We need at least one parameter -- tree-ish */
604 usage_with_options(archive_usage
, opts
);
605 *ar
= lookup_archiver(format
);
606 if (!*ar
|| (is_remote
&& !((*ar
)->flags
& ARCHIVER_REMOTE
)))
607 die(_("Unknown archive format '%s'"), format
);
609 args
->compression_level
= Z_DEFAULT_COMPRESSION
;
610 if (compression_level
!= -1) {
611 int levels_ok
= (*ar
)->flags
& ARCHIVER_WANT_COMPRESSION_LEVELS
;
612 int high_ok
= (*ar
)->flags
& ARCHIVER_HIGH_COMPRESSION_LEVELS
;
613 if (levels_ok
&& (compression_level
<= 9 || high_ok
))
614 args
->compression_level
= compression_level
;
616 die(_("Argument not supported for format '%s': -%d"),
617 format
, compression_level
);
620 args
->verbose
= verbose
;
622 args
->baselen
= strlen(base
);
623 args
->worktree_attributes
= worktree_attributes
;
628 int write_archive(int argc
, const char **argv
, const char *prefix
,
629 struct repository
*repo
,
630 const char *name_hint
, int remote
)
632 const struct archiver
*ar
= NULL
;
633 struct pretty_print_describe_status describe_status
= {0};
634 struct pretty_print_context ctx
= {0};
635 struct archiver_args args
;
638 git_config_get_bool("uploadarchive.allowunreachable", &remote_allow_unreachable
);
639 git_config(git_default_config
, NULL
);
641 describe_status
.max_invocations
= 1;
642 ctx
.date_mode
.type
= DATE_NORMAL
;
643 ctx
.abbrev
= DEFAULT_ABBREV
;
644 ctx
.describe_status
= &describe_status
;
645 args
.pretty_ctx
= &ctx
;
647 args
.prefix
= prefix
;
648 string_list_init_dup(&args
.extra_files
);
649 argc
= parse_archive_args(argc
, argv
, &ar
, &args
, name_hint
, remote
);
650 if (!startup_info
->have_repository
) {
652 * We know this will die() with an error, so we could just
653 * die ourselves; but its error message will be more specific
654 * than what we could write here.
656 setup_git_directory();
659 parse_treeish_arg(argv
, &args
, prefix
, remote
);
660 parse_pathspec_arg(argv
+ 1, &args
);
662 rc
= ar
->write_archive(ar
, &args
);
664 string_list_clear_func(&args
.extra_files
, extra_file_info_clear
);
670 static int match_extension(const char *filename
, const char *ext
)
672 int prefixlen
= strlen(filename
) - strlen(ext
);
675 * We need 1 character for the '.', and 1 character to ensure that the
676 * prefix is non-empty (k.e., we don't match .tar.gz with no actual
679 if (prefixlen
< 2 || filename
[prefixlen
- 1] != '.')
681 return !strcmp(filename
+ prefixlen
, ext
);
684 const char *archive_format_from_filename(const char *filename
)
688 for (i
= 0; i
< nr_archivers
; i
++)
689 if (match_extension(filename
, archivers
[i
]->name
))
690 return archivers
[i
]->name
;