unicode: update the width tables to Unicode 15
[git.git] / archive.c
blob9aeaf2bd87dfb884479f6e6a1b609d082ac39896
1 #include "cache.h"
2 #include "config.h"
3 #include "refs.h"
4 #include "object-store.h"
5 #include "commit.h"
6 #include "tree-walk.h"
7 #include "attr.h"
8 #include "archive.h"
9 #include "parse-options.h"
10 #include "unpack-trees.h"
11 #include "dir.h"
12 #include "quote.h"
14 static char const * const archive_usage[] = {
15 N_("git archive [<options>] <tree-ish> [<path>...]"),
16 "git archive --list",
17 N_("git archive --remote <repo> [--exec <cmd>] [<options>] <tree-ish> [<path>...]"),
18 N_("git archive --remote <repo> [--exec <cmd>] --list"),
19 NULL
22 static const struct archiver **archivers;
23 static int nr_archivers;
24 static int alloc_archivers;
25 static int remote_allow_unreachable;
27 void register_archiver(struct archiver *ar)
29 ALLOC_GROW(archivers, nr_archivers + 1, alloc_archivers);
30 archivers[nr_archivers++] = ar;
33 void init_archivers(void)
35 init_tar_archiver();
36 init_zip_archiver();
39 static void format_subst(const struct commit *commit,
40 const char *src, size_t len,
41 struct strbuf *buf, struct pretty_print_context *ctx)
43 char *to_free = NULL;
44 struct strbuf fmt = STRBUF_INIT;
46 if (src == buf->buf)
47 to_free = strbuf_detach(buf, NULL);
48 for (;;) {
49 const char *b, *c;
51 b = memmem(src, len, "$Format:", 8);
52 if (!b)
53 break;
54 c = memchr(b + 8, '$', (src + len) - b - 8);
55 if (!c)
56 break;
58 strbuf_reset(&fmt);
59 strbuf_add(&fmt, b + 8, c - b - 8);
61 strbuf_add(buf, src, b - src);
62 format_commit_message(commit, fmt.buf, buf, ctx);
63 len -= c + 1 - src;
64 src = c + 1;
66 strbuf_add(buf, src, len);
67 strbuf_release(&fmt);
68 free(to_free);
71 static void *object_file_to_archive(const struct archiver_args *args,
72 const char *path,
73 const struct object_id *oid,
74 unsigned int mode,
75 enum object_type *type,
76 unsigned long *sizep)
78 void *buffer;
79 const struct commit *commit = args->convert ? args->commit : NULL;
80 struct checkout_metadata meta;
82 init_checkout_metadata(&meta, args->refname,
83 args->commit_oid ? args->commit_oid :
84 (args->tree ? &args->tree->object.oid : NULL), oid);
86 path += args->baselen;
87 buffer = read_object_file(oid, type, sizep);
88 if (buffer && S_ISREG(mode)) {
89 struct strbuf buf = STRBUF_INIT;
90 size_t size = 0;
92 strbuf_attach(&buf, buffer, *sizep, *sizep + 1);
93 convert_to_working_tree(args->repo->index, path, buf.buf, buf.len, &buf, &meta);
94 if (commit)
95 format_subst(commit, buf.buf, buf.len, &buf, args->pretty_ctx);
96 buffer = strbuf_detach(&buf, &size);
97 *sizep = size;
100 return buffer;
103 struct directory {
104 struct directory *up;
105 struct object_id oid;
106 int baselen, len;
107 unsigned mode;
108 char path[FLEX_ARRAY];
111 struct archiver_context {
112 struct archiver_args *args;
113 write_archive_entry_fn_t write_entry;
114 struct directory *bottom;
117 static const struct attr_check *get_archive_attrs(struct index_state *istate,
118 const char *path)
120 static struct attr_check *check;
121 if (!check)
122 check = attr_check_initl("export-ignore", "export-subst", NULL);
123 git_check_attr(istate, NULL, path, check);
124 return check;
127 static int check_attr_export_ignore(const struct attr_check *check)
129 return check && ATTR_TRUE(check->items[0].value);
132 static int check_attr_export_subst(const struct attr_check *check)
134 return check && ATTR_TRUE(check->items[1].value);
137 static int write_archive_entry(const struct object_id *oid, const char *base,
138 int baselen, const char *filename, unsigned mode,
139 void *context)
141 static struct strbuf path = STRBUF_INIT;
142 struct archiver_context *c = context;
143 struct archiver_args *args = c->args;
144 write_archive_entry_fn_t write_entry = c->write_entry;
145 int err;
146 const char *path_without_prefix;
147 unsigned long size;
148 void *buffer;
149 enum object_type type;
151 args->convert = 0;
152 strbuf_reset(&path);
153 strbuf_grow(&path, PATH_MAX);
154 strbuf_add(&path, args->base, args->baselen);
155 strbuf_add(&path, base, baselen);
156 strbuf_addstr(&path, filename);
157 if (S_ISDIR(mode) || S_ISGITLINK(mode))
158 strbuf_addch(&path, '/');
159 path_without_prefix = path.buf + args->baselen;
161 if (!S_ISDIR(mode)) {
162 const struct attr_check *check;
163 check = get_archive_attrs(args->repo->index, path_without_prefix);
164 if (check_attr_export_ignore(check))
165 return 0;
166 args->convert = check_attr_export_subst(check);
169 if (args->verbose)
170 fprintf(stderr, "%.*s\n", (int)path.len, path.buf);
172 if (S_ISDIR(mode) || S_ISGITLINK(mode)) {
173 err = write_entry(args, oid, path.buf, path.len, mode, NULL, 0);
174 if (err)
175 return err;
176 return (S_ISDIR(mode) ? READ_TREE_RECURSIVE : 0);
179 /* Stream it? */
180 if (S_ISREG(mode) && !args->convert &&
181 oid_object_info(args->repo, oid, &size) == OBJ_BLOB &&
182 size > big_file_threshold)
183 return write_entry(args, oid, path.buf, path.len, mode, NULL, size);
185 buffer = object_file_to_archive(args, path.buf, oid, mode, &type, &size);
186 if (!buffer)
187 return error(_("cannot read '%s'"), oid_to_hex(oid));
188 err = write_entry(args, oid, path.buf, path.len, mode, buffer, size);
189 free(buffer);
190 return err;
193 static void queue_directory(const struct object_id *oid,
194 struct strbuf *base, const char *filename,
195 unsigned mode, struct archiver_context *c)
197 struct directory *d;
198 size_t len = st_add4(base->len, 1, strlen(filename), 1);
199 d = xmalloc(st_add(sizeof(*d), len));
200 d->up = c->bottom;
201 d->baselen = base->len;
202 d->mode = mode;
203 c->bottom = d;
204 d->len = xsnprintf(d->path, len, "%.*s%s/", (int)base->len, base->buf, filename);
205 oidcpy(&d->oid, oid);
208 static int write_directory(struct archiver_context *c)
210 struct directory *d = c->bottom;
211 int ret;
213 if (!d)
214 return 0;
215 c->bottom = d->up;
216 d->path[d->len - 1] = '\0'; /* no trailing slash */
217 ret =
218 write_directory(c) ||
219 write_archive_entry(&d->oid, d->path, d->baselen,
220 d->path + d->baselen, d->mode,
221 c) != READ_TREE_RECURSIVE;
222 free(d);
223 return ret ? -1 : 0;
226 static int queue_or_write_archive_entry(const struct object_id *oid,
227 struct strbuf *base, const char *filename,
228 unsigned mode, void *context)
230 struct archiver_context *c = context;
232 while (c->bottom &&
233 !(base->len >= c->bottom->len &&
234 !strncmp(base->buf, c->bottom->path, c->bottom->len))) {
235 struct directory *next = c->bottom->up;
236 free(c->bottom);
237 c->bottom = next;
240 if (S_ISDIR(mode)) {
241 size_t baselen = base->len;
242 const struct attr_check *check;
244 /* Borrow base, but restore its original value when done. */
245 strbuf_addstr(base, filename);
246 strbuf_addch(base, '/');
247 check = get_archive_attrs(c->args->repo->index, base->buf);
248 strbuf_setlen(base, baselen);
250 if (check_attr_export_ignore(check))
251 return 0;
252 queue_directory(oid, base, filename, mode, c);
253 return READ_TREE_RECURSIVE;
256 if (write_directory(c))
257 return -1;
258 return write_archive_entry(oid, base->buf, base->len, filename, mode,
259 context);
262 struct extra_file_info {
263 char *base;
264 struct stat stat;
265 void *content;
268 int write_archive_entries(struct archiver_args *args,
269 write_archive_entry_fn_t write_entry)
271 struct archiver_context context;
272 struct unpack_trees_options opts;
273 struct tree_desc t;
274 int err;
275 struct strbuf path_in_archive = STRBUF_INIT;
276 struct strbuf content = STRBUF_INIT;
277 struct object_id fake_oid;
278 int i;
280 oidcpy(&fake_oid, null_oid());
282 if (args->baselen > 0 && args->base[args->baselen - 1] == '/') {
283 size_t len = args->baselen;
285 while (len > 1 && args->base[len - 2] == '/')
286 len--;
287 if (args->verbose)
288 fprintf(stderr, "%.*s\n", (int)len, args->base);
289 err = write_entry(args, &args->tree->object.oid, args->base,
290 len, 040777, NULL, 0);
291 if (err)
292 return err;
295 memset(&context, 0, sizeof(context));
296 context.args = args;
297 context.write_entry = write_entry;
300 * Setup index and instruct attr to read index only
302 if (!args->worktree_attributes) {
303 memset(&opts, 0, sizeof(opts));
304 opts.index_only = 1;
305 opts.head_idx = -1;
306 opts.src_index = args->repo->index;
307 opts.dst_index = args->repo->index;
308 opts.fn = oneway_merge;
309 init_tree_desc(&t, args->tree->buffer, args->tree->size);
310 if (unpack_trees(1, &t, &opts))
311 return -1;
312 git_attr_set_direction(GIT_ATTR_INDEX);
315 err = read_tree(args->repo, args->tree,
316 &args->pathspec,
317 queue_or_write_archive_entry,
318 &context);
319 if (err == READ_TREE_RECURSIVE)
320 err = 0;
321 while (context.bottom) {
322 struct directory *next = context.bottom->up;
323 free(context.bottom);
324 context.bottom = next;
327 for (i = 0; i < args->extra_files.nr; i++) {
328 struct string_list_item *item = args->extra_files.items + i;
329 char *path = item->string;
330 struct extra_file_info *info = item->util;
332 put_be64(fake_oid.hash, i + 1);
334 if (!info->content) {
335 strbuf_reset(&path_in_archive);
336 if (info->base)
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(_("cannot read '%s'"), path);
343 else
344 err = write_entry(args, &fake_oid, path_in_archive.buf,
345 path_in_archive.len,
346 canon_mode(info->stat.st_mode),
347 content.buf, content.len);
348 } else {
349 err = write_entry(args, &fake_oid,
350 path, strlen(path),
351 canon_mode(info->stat.st_mode),
352 info->content, info->stat.st_size);
355 if (err)
356 break;
358 strbuf_release(&path_in_archive);
359 strbuf_release(&content);
361 return err;
364 static const struct archiver *lookup_archiver(const char *name)
366 int i;
368 if (!name)
369 return NULL;
371 for (i = 0; i < nr_archivers; i++) {
372 if (!strcmp(name, archivers[i]->name))
373 return archivers[i];
375 return NULL;
378 struct path_exists_context {
379 struct pathspec pathspec;
380 struct archiver_args *args;
383 static int reject_entry(const struct object_id *oid UNUSED,
384 struct strbuf *base,
385 const char *filename, unsigned mode,
386 void *context)
388 int ret = -1;
389 struct path_exists_context *ctx = context;
391 if (S_ISDIR(mode)) {
392 struct strbuf sb = STRBUF_INIT;
393 strbuf_addbuf(&sb, base);
394 strbuf_addstr(&sb, filename);
395 if (!match_pathspec(ctx->args->repo->index,
396 &ctx->pathspec,
397 sb.buf, sb.len, 0, NULL, 1))
398 ret = READ_TREE_RECURSIVE;
399 strbuf_release(&sb);
401 return ret;
404 static int path_exists(struct archiver_args *args, const char *path)
406 const char *paths[] = { path, NULL };
407 struct path_exists_context ctx;
408 int ret;
410 ctx.args = args;
411 parse_pathspec(&ctx.pathspec, 0, 0, "", paths);
412 ctx.pathspec.recursive = 1;
413 ret = read_tree(args->repo, args->tree,
414 &ctx.pathspec,
415 reject_entry, &ctx);
416 clear_pathspec(&ctx.pathspec);
417 return ret != 0;
420 static void parse_pathspec_arg(const char **pathspec,
421 struct archiver_args *ar_args)
424 * must be consistent with parse_pathspec in path_exists()
425 * Also if pathspec patterns are dependent, we're in big
426 * trouble as we test each one separately
428 parse_pathspec(&ar_args->pathspec, 0,
429 PATHSPEC_PREFER_FULL,
430 "", pathspec);
431 ar_args->pathspec.recursive = 1;
432 if (pathspec) {
433 while (*pathspec) {
434 if (**pathspec && !path_exists(ar_args, *pathspec))
435 die(_("pathspec '%s' did not match any files"), *pathspec);
436 pathspec++;
441 static void parse_treeish_arg(const char **argv,
442 struct archiver_args *ar_args, const char *prefix,
443 int remote)
445 const char *name = argv[0];
446 const struct object_id *commit_oid;
447 time_t archive_time;
448 struct tree *tree;
449 const struct commit *commit;
450 struct object_id oid;
451 char *ref = NULL;
453 /* Remotes are only allowed to fetch actual refs */
454 if (remote && !remote_allow_unreachable) {
455 const char *colon = strchrnul(name, ':');
456 int refnamelen = colon - name;
458 if (!dwim_ref(name, refnamelen, &oid, &ref, 0))
459 die(_("no such ref: %.*s"), refnamelen, name);
460 } else {
461 dwim_ref(name, strlen(name), &oid, &ref, 0);
464 if (get_oid(name, &oid))
465 die(_("not a valid object name: %s"), name);
467 commit = lookup_commit_reference_gently(ar_args->repo, &oid, 1);
468 if (commit) {
469 commit_oid = &commit->object.oid;
470 archive_time = commit->date;
471 } else {
472 commit_oid = NULL;
473 archive_time = time(NULL);
475 if (ar_args->mtime_option)
476 archive_time = approxidate(ar_args->mtime_option);
478 tree = parse_tree_indirect(&oid);
479 if (!tree)
480 die(_("not a tree object: %s"), oid_to_hex(&oid));
482 if (prefix) {
483 struct object_id tree_oid;
484 unsigned short mode;
485 int err;
487 err = get_tree_entry(ar_args->repo,
488 &tree->object.oid,
489 prefix, &tree_oid,
490 &mode);
491 if (err || !S_ISDIR(mode))
492 die(_("current working directory is untracked"));
494 tree = parse_tree_indirect(&tree_oid);
496 ar_args->refname = ref;
497 ar_args->tree = tree;
498 ar_args->commit_oid = commit_oid;
499 ar_args->commit = commit;
500 ar_args->time = archive_time;
503 static void extra_file_info_clear(void *util, const char *str UNUSED)
505 struct extra_file_info *info = util;
506 free(info->base);
507 free(info->content);
508 free(info);
511 static int add_file_cb(const struct option *opt, const char *arg, int unset)
513 struct archiver_args *args = opt->value;
514 const char **basep = (const char **)opt->defval;
515 const char *base = *basep;
516 char *path;
517 struct string_list_item *item;
518 struct extra_file_info *info;
520 if (unset) {
521 string_list_clear_func(&args->extra_files,
522 extra_file_info_clear);
523 return 0;
526 if (!arg)
527 return -1;
529 info = xmalloc(sizeof(*info));
530 info->base = xstrdup_or_null(base);
532 if (!strcmp(opt->long_name, "add-file")) {
533 path = prefix_filename(args->prefix, arg);
534 if (stat(path, &info->stat))
535 die(_("File not found: %s"), path);
536 if (!S_ISREG(info->stat.st_mode))
537 die(_("Not a regular file: %s"), path);
538 info->content = NULL; /* read the file later */
539 } else if (!strcmp(opt->long_name, "add-virtual-file")) {
540 struct strbuf buf = STRBUF_INIT;
541 const char *p = arg;
543 if (*p != '"')
544 p = strchr(p, ':');
545 else if (unquote_c_style(&buf, p, &p) < 0)
546 die(_("unclosed quote: '%s'"), arg);
548 if (!p || *p != ':')
549 die(_("missing colon: '%s'"), arg);
551 if (p == arg)
552 die(_("empty file name: '%s'"), arg);
554 path = buf.len ?
555 strbuf_detach(&buf, NULL) : xstrndup(arg, p - arg);
557 if (args->prefix) {
558 char *save = path;
559 path = prefix_filename(args->prefix, path);
560 free(save);
562 memset(&info->stat, 0, sizeof(info->stat));
563 info->stat.st_mode = S_IFREG | 0644;
564 info->content = xstrdup(p + 1);
565 info->stat.st_size = strlen(info->content);
566 } else {
567 BUG("add_file_cb() called for %s", opt->long_name);
569 item = string_list_append_nodup(&args->extra_files, path);
570 item->util = info;
572 return 0;
575 static int number_callback(const struct option *opt, const char *arg, int unset)
577 BUG_ON_OPT_NEG(unset);
578 *(int *)opt->value = strtol(arg, NULL, 10);
579 return 0;
582 static int parse_archive_args(int argc, const char **argv,
583 const struct archiver **ar, struct archiver_args *args,
584 const char *name_hint, int is_remote)
586 const char *format = NULL;
587 const char *base = NULL;
588 const char *remote = NULL;
589 const char *exec = NULL;
590 const char *output = NULL;
591 const char *mtime_option = NULL;
592 int compression_level = -1;
593 int verbose = 0;
594 int i;
595 int list = 0;
596 int worktree_attributes = 0;
597 struct option opts[] = {
598 OPT_GROUP(""),
599 OPT_STRING(0, "format", &format, N_("fmt"), N_("archive format")),
600 OPT_STRING(0, "prefix", &base, N_("prefix"),
601 N_("prepend prefix to each pathname in the archive")),
602 { OPTION_CALLBACK, 0, "add-file", args, N_("file"),
603 N_("add untracked file to archive"), 0, add_file_cb,
604 (intptr_t)&base },
605 { OPTION_CALLBACK, 0, "add-virtual-file", args,
606 N_("path:content"), N_("add untracked file to archive"), 0,
607 add_file_cb, (intptr_t)&base },
608 OPT_STRING('o', "output", &output, N_("file"),
609 N_("write the archive to this file")),
610 OPT_BOOL(0, "worktree-attributes", &worktree_attributes,
611 N_("read .gitattributes in working directory")),
612 OPT__VERBOSE(&verbose, N_("report archived files on stderr")),
613 { OPTION_STRING, 0, "mtime", &mtime_option, N_("time"),
614 N_("set modification time of archive entries"),
615 PARSE_OPT_NONEG },
616 OPT_NUMBER_CALLBACK(&compression_level,
617 N_("set compression level"), number_callback),
618 OPT_GROUP(""),
619 OPT_BOOL('l', "list", &list,
620 N_("list supported archive formats")),
621 OPT_GROUP(""),
622 OPT_STRING(0, "remote", &remote, N_("repo"),
623 N_("retrieve the archive from remote repository <repo>")),
624 OPT_STRING(0, "exec", &exec, N_("command"),
625 N_("path to the remote git-upload-archive command")),
626 OPT_END()
629 argc = parse_options(argc, argv, NULL, opts, archive_usage, 0);
631 if (remote)
632 die(_("Unexpected option --remote"));
633 if (exec)
634 die(_("the option '%s' requires '%s'"), "--exec", "--remote");
635 if (output)
636 die(_("Unexpected option --output"));
637 if (is_remote && args->extra_files.nr)
638 die(_("options '%s' and '%s' cannot be used together"), "--add-file", "--remote");
640 if (!base)
641 base = "";
643 if (list) {
644 for (i = 0; i < nr_archivers; i++)
645 if (!is_remote || archivers[i]->flags & ARCHIVER_REMOTE)
646 printf("%s\n", archivers[i]->name);
647 exit(0);
650 if (!format && name_hint)
651 format = archive_format_from_filename(name_hint);
652 if (!format)
653 format = "tar";
655 /* We need at least one parameter -- tree-ish */
656 if (argc < 1)
657 usage_with_options(archive_usage, opts);
658 *ar = lookup_archiver(format);
659 if (!*ar || (is_remote && !((*ar)->flags & ARCHIVER_REMOTE)))
660 die(_("Unknown archive format '%s'"), format);
662 args->compression_level = Z_DEFAULT_COMPRESSION;
663 if (compression_level != -1) {
664 int levels_ok = (*ar)->flags & ARCHIVER_WANT_COMPRESSION_LEVELS;
665 int high_ok = (*ar)->flags & ARCHIVER_HIGH_COMPRESSION_LEVELS;
666 if (levels_ok && (compression_level <= 9 || high_ok))
667 args->compression_level = compression_level;
668 else {
669 die(_("Argument not supported for format '%s': -%d"),
670 format, compression_level);
673 args->verbose = verbose;
674 args->base = base;
675 args->baselen = strlen(base);
676 args->worktree_attributes = worktree_attributes;
677 args->mtime_option = mtime_option;
679 return argc;
682 int write_archive(int argc, const char **argv, const char *prefix,
683 struct repository *repo,
684 const char *name_hint, int remote)
686 const struct archiver *ar = NULL;
687 struct pretty_print_describe_status describe_status = {0};
688 struct pretty_print_context ctx = {0};
689 struct archiver_args args;
690 int rc;
692 git_config_get_bool("uploadarchive.allowunreachable", &remote_allow_unreachable);
693 git_config(git_default_config, NULL);
695 describe_status.max_invocations = 1;
696 ctx.date_mode.type = DATE_NORMAL;
697 ctx.abbrev = DEFAULT_ABBREV;
698 ctx.describe_status = &describe_status;
699 args.pretty_ctx = &ctx;
700 args.repo = repo;
701 args.prefix = prefix;
702 string_list_init_dup(&args.extra_files);
703 argc = parse_archive_args(argc, argv, &ar, &args, name_hint, remote);
704 if (!startup_info->have_repository) {
706 * We know this will die() with an error, so we could just
707 * die ourselves; but its error message will be more specific
708 * than what we could write here.
710 setup_git_directory();
713 parse_treeish_arg(argv, &args, prefix, remote);
714 parse_pathspec_arg(argv + 1, &args);
716 rc = ar->write_archive(ar, &args);
718 string_list_clear_func(&args.extra_files, extra_file_info_clear);
719 free(args.refname);
720 clear_pathspec(&args.pathspec);
722 return rc;
725 static int match_extension(const char *filename, const char *ext)
727 int prefixlen = strlen(filename) - strlen(ext);
730 * We need 1 character for the '.', and 1 character to ensure that the
731 * prefix is non-empty (k.e., we don't match .tar.gz with no actual
732 * filename).
734 if (prefixlen < 2 || filename[prefixlen - 1] != '.')
735 return 0;
736 return !strcmp(filename + prefixlen, ext);
739 const char *archive_format_from_filename(const char *filename)
741 int i;
743 for (i = 0; i < nr_archivers; i++)
744 if (match_extension(filename, archivers[i]->name))
745 return archivers[i]->name;
746 return NULL;