2 * GIT - The information manager from hell
4 * Copyright (C) Linus Torvalds, 2005
6 #define USE_THE_INDEX_COMPATIBILITY_MACROS
11 #include "parse-options.h"
13 #include "streaming.h"
14 #include "tree-walk.h"
15 #include "oid-array.h"
17 #include "object-store.h"
18 #include "promisor-remote.h"
20 struct batch_options
{
27 int cmdmode
; /* may be 'w' or 'c' for --filters or --textconv */
31 static const char *force_path
;
33 static int filter_object(const char *path
, unsigned mode
,
34 const struct object_id
*oid
,
35 char **buf
, unsigned long *size
)
37 enum object_type type
;
39 *buf
= read_object_file(oid
, &type
, size
);
41 return error(_("cannot read object %s '%s'"),
42 oid_to_hex(oid
), path
);
43 if ((type
== OBJ_BLOB
) && S_ISREG(mode
)) {
44 struct strbuf strbuf
= STRBUF_INIT
;
45 struct checkout_metadata meta
;
47 init_checkout_metadata(&meta
, NULL
, NULL
, oid
);
48 if (convert_to_working_tree(&the_index
, path
, *buf
, *size
, &strbuf
, &meta
)) {
51 *buf
= strbuf_detach(&strbuf
, NULL
);
58 static int stream_blob(const struct object_id
*oid
)
60 if (stream_blob_to_fd(1, oid
, NULL
, 0))
61 die("unable to stream %s to stdout", oid_to_hex(oid
));
65 static int cat_one_file(int opt
, const char *exp_type
, const char *obj_name
,
69 enum object_type type
;
72 struct object_context obj_context
;
73 struct object_info oi
= OBJECT_INFO_INIT
;
74 struct strbuf sb
= STRBUF_INIT
;
75 unsigned flags
= OBJECT_INFO_LOOKUP_REPLACE
;
76 unsigned get_oid_flags
= GET_OID_RECORD_PATH
| GET_OID_ONLY_TO_DIE
;
77 const char *path
= force_path
;
78 const int opt_cw
= (opt
== 'c' || opt
== 'w');
80 get_oid_flags
|= GET_OID_REQUIRE_PATH
;
83 flags
|= OBJECT_INFO_ALLOW_UNKNOWN_TYPE
;
85 if (get_oid_with_context(the_repository
, obj_name
, get_oid_flags
, &oid
,
87 die("Not a valid object name %s", obj_name
);
90 path
= obj_context
.path
;
91 if (obj_context
.mode
== S_IFINVALID
)
92 obj_context
.mode
= 0100644;
98 if (oid_object_info_extended(the_repository
, &oid
, &oi
, flags
) < 0)
99 die("git cat-file: could not get object info");
101 printf("%s\n", sb
.buf
);
109 if (oid_object_info_extended(the_repository
, &oid
, &oi
, flags
) < 0)
110 die("git cat-file: could not get object info");
111 printf("%"PRIuMAX
"\n", (uintmax_t)size
);
115 return !has_object_file(&oid
);
119 if (filter_object(path
, obj_context
.mode
,
125 if (textconv_object(the_repository
, path
, obj_context
.mode
,
126 &oid
, 1, &buf
, &size
))
128 /* else fallthrough */
131 type
= oid_object_info(the_repository
, &oid
, NULL
);
133 die("Not a valid object name %s", obj_name
);
135 /* custom pretty-print here */
136 if (type
== OBJ_TREE
) {
137 const char *ls_args
[3] = { NULL
};
138 ls_args
[0] = "ls-tree";
139 ls_args
[1] = obj_name
;
140 return cmd_ls_tree(2, ls_args
, NULL
);
143 if (type
== OBJ_BLOB
)
144 return stream_blob(&oid
);
145 buf
= read_object_file(&oid
, &type
, &size
);
147 die("Cannot read object %s", obj_name
);
149 /* otherwise just spit out the data */
153 if (type_from_string(exp_type
) == OBJ_BLOB
) {
154 struct object_id blob_oid
;
155 if (oid_object_info(the_repository
, &oid
, NULL
) == OBJ_TAG
) {
156 char *buffer
= read_object_file(&oid
, &type
,
159 if (!skip_prefix(buffer
, "object ", &target
) ||
160 get_oid_hex(target
, &blob_oid
))
161 die("%s not a valid tag", oid_to_hex(&oid
));
164 oidcpy(&blob_oid
, &oid
);
166 if (oid_object_info(the_repository
, &blob_oid
, NULL
) == OBJ_BLOB
)
167 return stream_blob(&blob_oid
);
169 * we attempted to dereference a tag to a blob
170 * and failed; there may be new dereference
171 * mechanisms this code is not aware of.
172 * fall-back to the usual case.
175 buf
= read_object_with_reference(the_repository
,
176 &oid
, exp_type
, &size
, NULL
);
180 die("git cat-file: unknown option: %s", exp_type
);
184 die("git cat-file %s: bad file", obj_name
);
186 write_or_die(1, buf
, size
);
188 free(obj_context
.path
);
193 struct object_id oid
;
194 enum object_type type
;
198 struct object_id delta_base_oid
;
201 * If mark_query is true, we do not expand anything, but rather
202 * just mark the object_info with items we wish to query.
207 * Whether to split the input on whitespace before feeding it to
208 * get_sha1; this is decided during the mark_query phase based on
209 * whether we have a %(rest) token in our format.
211 int split_on_whitespace
;
214 * After a mark_query run, this object_info is set up to be
215 * passed to oid_object_info_extended. It will point to the data
216 * elements above, so you can retrieve the response from there.
218 struct object_info info
;
221 * This flag will be true if the requested batch format and options
222 * don't require us to call oid_object_info, which can then be
225 unsigned skip_object_info
: 1;
228 static int is_atom(const char *atom
, const char *s
, int slen
)
230 int alen
= strlen(atom
);
231 return alen
== slen
&& !memcmp(atom
, s
, alen
);
234 static void expand_atom(struct strbuf
*sb
, const char *atom
, int len
,
237 struct expand_data
*data
= vdata
;
239 if (is_atom("objectname", atom
, len
)) {
240 if (!data
->mark_query
)
241 strbuf_addstr(sb
, oid_to_hex(&data
->oid
));
242 } else if (is_atom("objecttype", atom
, len
)) {
243 if (data
->mark_query
)
244 data
->info
.typep
= &data
->type
;
246 strbuf_addstr(sb
, type_name(data
->type
));
247 } else if (is_atom("objectsize", atom
, len
)) {
248 if (data
->mark_query
)
249 data
->info
.sizep
= &data
->size
;
251 strbuf_addf(sb
, "%"PRIuMAX
, (uintmax_t)data
->size
);
252 } else if (is_atom("objectsize:disk", atom
, len
)) {
253 if (data
->mark_query
)
254 data
->info
.disk_sizep
= &data
->disk_size
;
256 strbuf_addf(sb
, "%"PRIuMAX
, (uintmax_t)data
->disk_size
);
257 } else if (is_atom("rest", atom
, len
)) {
258 if (data
->mark_query
)
259 data
->split_on_whitespace
= 1;
261 strbuf_addstr(sb
, data
->rest
);
262 } else if (is_atom("deltabase", atom
, len
)) {
263 if (data
->mark_query
)
264 data
->info
.delta_base_oid
= &data
->delta_base_oid
;
267 oid_to_hex(&data
->delta_base_oid
));
269 die("unknown format element: %.*s", len
, atom
);
272 static size_t expand_format(struct strbuf
*sb
, const char *start
, void *data
)
278 end
= strchr(start
+ 1, ')');
280 die("format element '%s' does not end in ')'", start
);
282 expand_atom(sb
, start
+ 1, end
- start
- 1, data
);
284 return end
- start
+ 1;
287 static void batch_write(struct batch_options
*opt
, const void *data
, int len
)
289 if (opt
->buffer_output
) {
290 if (fwrite(data
, 1, len
, stdout
) != len
)
291 die_errno("unable to write to stdout");
293 write_or_die(1, data
, len
);
296 static void print_object_or_die(struct batch_options
*opt
, struct expand_data
*data
)
298 const struct object_id
*oid
= &data
->oid
;
300 assert(data
->info
.typep
);
302 if (data
->type
== OBJ_BLOB
) {
303 if (opt
->buffer_output
)
310 die("missing path for '%s'", oid_to_hex(oid
));
312 if (opt
->cmdmode
== 'w') {
313 if (filter_object(data
->rest
, 0100644, oid
,
315 die("could not convert '%s' %s",
316 oid_to_hex(oid
), data
->rest
);
317 } else if (opt
->cmdmode
== 'c') {
318 enum object_type type
;
319 if (!textconv_object(the_repository
,
320 data
->rest
, 0100644, oid
,
321 1, &contents
, &size
))
322 contents
= read_object_file(oid
,
326 die("could not convert '%s' %s",
327 oid_to_hex(oid
), data
->rest
);
329 BUG("invalid cmdmode: %c", opt
->cmdmode
);
330 batch_write(opt
, contents
, size
);
337 enum object_type type
;
341 contents
= read_object_file(oid
, &type
, &size
);
343 die("object %s disappeared", oid_to_hex(oid
));
344 if (type
!= data
->type
)
345 die("object %s changed type!?", oid_to_hex(oid
));
346 if (data
->info
.sizep
&& size
!= data
->size
)
347 die("object %s changed size!?", oid_to_hex(oid
));
349 batch_write(opt
, contents
, size
);
355 * If "pack" is non-NULL, then "offset" is the byte offset within the pack from
356 * which the object may be accessed (though note that we may also rely on
357 * data->oid, too). If "pack" is NULL, then offset is ignored.
359 static void batch_object_write(const char *obj_name
,
360 struct strbuf
*scratch
,
361 struct batch_options
*opt
,
362 struct expand_data
*data
,
363 struct packed_git
*pack
,
366 if (!data
->skip_object_info
) {
370 ret
= packed_object_info(the_repository
, pack
, offset
,
373 ret
= oid_object_info_extended(the_repository
,
374 &data
->oid
, &data
->info
,
375 OBJECT_INFO_LOOKUP_REPLACE
);
377 printf("%s missing\n",
378 obj_name
? obj_name
: oid_to_hex(&data
->oid
));
384 strbuf_reset(scratch
);
385 strbuf_expand(scratch
, opt
->format
, expand_format
, data
);
386 strbuf_addch(scratch
, '\n');
387 batch_write(opt
, scratch
->buf
, scratch
->len
);
389 if (opt
->print_contents
) {
390 print_object_or_die(opt
, data
);
391 batch_write(opt
, "\n", 1);
395 static void batch_one_object(const char *obj_name
,
396 struct strbuf
*scratch
,
397 struct batch_options
*opt
,
398 struct expand_data
*data
)
400 struct object_context ctx
;
401 int flags
= opt
->follow_symlinks
? GET_OID_FOLLOW_SYMLINKS
: 0;
402 enum get_oid_result result
;
404 result
= get_oid_with_context(the_repository
, obj_name
,
405 flags
, &data
->oid
, &ctx
);
406 if (result
!= FOUND
) {
409 printf("%s missing\n", obj_name
);
411 case SHORT_NAME_AMBIGUOUS
:
412 printf("%s ambiguous\n", obj_name
);
414 case DANGLING_SYMLINK
:
415 printf("dangling %"PRIuMAX
"\n%s\n",
416 (uintmax_t)strlen(obj_name
), obj_name
);
419 printf("loop %"PRIuMAX
"\n%s\n",
420 (uintmax_t)strlen(obj_name
), obj_name
);
423 printf("notdir %"PRIuMAX
"\n%s\n",
424 (uintmax_t)strlen(obj_name
), obj_name
);
427 BUG("unknown get_sha1_with_context result %d\n",
436 printf("symlink %"PRIuMAX
"\n%s\n",
437 (uintmax_t)ctx
.symlink_path
.len
,
438 ctx
.symlink_path
.buf
);
443 batch_object_write(obj_name
, scratch
, opt
, data
, NULL
, 0);
446 struct object_cb_data
{
447 struct batch_options
*opt
;
448 struct expand_data
*expand
;
450 struct strbuf
*scratch
;
453 static int batch_object_cb(const struct object_id
*oid
, void *vdata
)
455 struct object_cb_data
*data
= vdata
;
456 oidcpy(&data
->expand
->oid
, oid
);
457 batch_object_write(NULL
, data
->scratch
, data
->opt
, data
->expand
,
462 static int collect_loose_object(const struct object_id
*oid
,
466 oid_array_append(data
, oid
);
470 static int collect_packed_object(const struct object_id
*oid
,
471 struct packed_git
*pack
,
475 oid_array_append(data
, oid
);
479 static int batch_unordered_object(const struct object_id
*oid
,
480 struct packed_git
*pack
, off_t offset
,
483 struct object_cb_data
*data
= vdata
;
485 if (oidset_insert(data
->seen
, oid
))
488 oidcpy(&data
->expand
->oid
, oid
);
489 batch_object_write(NULL
, data
->scratch
, data
->opt
, data
->expand
,
494 static int batch_unordered_loose(const struct object_id
*oid
,
498 return batch_unordered_object(oid
, NULL
, 0, data
);
501 static int batch_unordered_packed(const struct object_id
*oid
,
502 struct packed_git
*pack
,
506 return batch_unordered_object(oid
, pack
,
507 nth_packed_object_offset(pack
, pos
),
511 static int batch_objects(struct batch_options
*opt
)
513 struct strbuf input
= STRBUF_INIT
;
514 struct strbuf output
= STRBUF_INIT
;
515 struct expand_data data
;
520 opt
->format
= "%(objectname) %(objecttype) %(objectsize)";
523 * Expand once with our special mark_query flag, which will prime the
524 * object_info to be handed to oid_object_info_extended for each
527 memset(&data
, 0, sizeof(data
));
529 strbuf_expand(&output
, opt
->format
, expand_format
, &data
);
531 strbuf_release(&output
);
533 data
.split_on_whitespace
= 1;
536 * If we are printing out the object, then always fill in the type,
537 * since we will want to decide whether or not to stream.
539 if (opt
->print_contents
)
540 data
.info
.typep
= &data
.type
;
542 if (opt
->all_objects
) {
543 struct object_cb_data cb
;
544 struct object_info empty
= OBJECT_INFO_INIT
;
546 if (!memcmp(&data
.info
, &empty
, sizeof(empty
)))
547 data
.skip_object_info
= 1;
549 if (has_promisor_remote())
550 warning("This repository uses promisor remotes. Some objects may not be loaded.");
552 read_replace_refs
= 0;
556 cb
.scratch
= &output
;
558 if (opt
->unordered
) {
559 struct oidset seen
= OIDSET_INIT
;
563 for_each_loose_object(batch_unordered_loose
, &cb
, 0);
564 for_each_packed_object(batch_unordered_packed
, &cb
,
565 FOR_EACH_OBJECT_PACK_ORDER
);
569 struct oid_array sa
= OID_ARRAY_INIT
;
571 for_each_loose_object(collect_loose_object
, &sa
, 0);
572 for_each_packed_object(collect_packed_object
, &sa
, 0);
574 oid_array_for_each_unique(&sa
, batch_object_cb
, &cb
);
576 oid_array_clear(&sa
);
579 strbuf_release(&output
);
584 * We are going to call get_sha1 on a potentially very large number of
585 * objects. In most large cases, these will be actual object sha1s. The
586 * cost to double-check that each one is not also a ref (just so we can
587 * warn) ends up dwarfing the actual cost of the object lookups
588 * themselves. We can work around it by just turning off the warning.
590 save_warning
= warn_on_object_refname_ambiguity
;
591 warn_on_object_refname_ambiguity
= 0;
593 while (strbuf_getline(&input
, stdin
) != EOF
) {
594 if (data
.split_on_whitespace
) {
596 * Split at first whitespace, tying off the beginning
597 * of the string and saving the remainder (or NULL) in
600 char *p
= strpbrk(input
.buf
, " \t");
602 while (*p
&& strchr(" \t", *p
))
608 batch_one_object(input
.buf
, &output
, opt
, &data
);
611 strbuf_release(&input
);
612 strbuf_release(&output
);
613 warn_on_object_refname_ambiguity
= save_warning
;
617 static int git_cat_file_config(const char *var
, const char *value
, void *cb
)
619 if (userdiff_config(var
, value
) < 0)
622 return git_default_config(var
, value
, cb
);
625 static int batch_option_callback(const struct option
*opt
,
629 struct batch_options
*bo
= opt
->value
;
631 BUG_ON_OPT_NEG(unset
);
634 return error(_("only one batch option may be specified"));
638 bo
->print_contents
= !strcmp(opt
->long_name
, "batch");
644 int cmd_cat_file(int argc
, const char **argv
, const char *prefix
)
649 const char *exp_type
= NULL
, *obj_name
= NULL
;
650 struct batch_options batch
= {0};
651 int unknown_type
= 0;
653 const char * const usage
[] = {
654 N_("git cat-file <type> <object>"),
655 N_("git cat-file (-e | -p) <object>"),
656 N_("git cat-file (-t | -s) [--allow-unknown-type] <object>"),
657 N_("git cat-file (--batch | --batch-check) [--batch-all-objects]\n"
658 " [--buffer] [--follow-symlinks] [--unordered]\n"
659 " [--textconv | --filters]"),
660 N_("git cat-file (--textconv | --filters)\n"
661 " [<rev>:<path|tree-ish> | --path=<path|tree-ish> <rev>]"),
664 const struct option options
[] = {
666 OPT_GROUP(N_("Check object existence or emit object contents")),
667 OPT_CMDMODE('e', NULL
, &opt
,
668 N_("check if <object> exists"), 'e'),
669 OPT_CMDMODE('p', NULL
, &opt
, N_("pretty-print <object> content"), 'p'),
671 OPT_GROUP(N_("Emit [broken] object attributes")),
672 OPT_CMDMODE('t', NULL
, &opt
, N_("show object type (one of 'blob', 'tree', 'commit', 'tag', ...)"), 't'),
673 OPT_CMDMODE('s', NULL
, &opt
, N_("show object size"), 's'),
674 OPT_BOOL(0, "allow-unknown-type", &unknown_type
,
675 N_("allow -s and -t to work with broken/corrupt objects")),
677 OPT_GROUP(N_("Batch objects requested on stdin (or --batch-all-objects)")),
678 OPT_CALLBACK_F(0, "batch", &batch
, N_("format"),
679 N_("show full <object> or <rev> contents"),
680 PARSE_OPT_OPTARG
| PARSE_OPT_NONEG
,
681 batch_option_callback
),
682 OPT_CALLBACK_F(0, "batch-check", &batch
, N_("format"),
683 N_("like --batch, but don't emit <contents>"),
684 PARSE_OPT_OPTARG
| PARSE_OPT_NONEG
,
685 batch_option_callback
),
686 OPT_CMDMODE(0, "batch-all-objects", &opt
,
687 N_("with --batch[-check]: ignores stdin, batches all known objects"), 'b'),
688 /* Batch-specific options */
689 OPT_GROUP(N_("Change or optimize batch output")),
690 OPT_BOOL(0, "buffer", &batch
.buffer_output
, N_("buffer --batch output")),
691 OPT_BOOL(0, "follow-symlinks", &batch
.follow_symlinks
,
692 N_("follow in-tree symlinks")),
693 OPT_BOOL(0, "unordered", &batch
.unordered
,
694 N_("do not order objects before emitting them")),
695 /* Textconv options, stand-ole*/
696 OPT_GROUP(N_("Emit object (blob or tree) with conversion or filter (stand-alone, or with batch)")),
697 OPT_CMDMODE(0, "textconv", &opt
,
698 N_("run textconv on object's content"), 'c'),
699 OPT_CMDMODE(0, "filters", &opt
,
700 N_("run filters on object's content"), 'w'),
701 OPT_STRING(0, "path", &force_path
, N_("blob|tree"),
702 N_("use a <path> for (--textconv | --filters); Not with 'batch'")),
706 git_config(git_cat_file_config
, NULL
);
708 batch
.buffer_output
= -1;
710 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
711 opt_cw
= (opt
== 'c' || opt
== 'w');
712 opt_epts
= (opt
== 'e' || opt
== 'p' || opt
== 't' || opt
== 's');
714 /* --batch-all-objects? */
716 batch
.all_objects
= 1;
718 /* Option compatibility */
719 if (force_path
&& !opt_cw
)
720 usage_msg_optf(_("'%s=<%s>' needs '%s' or '%s'"),
722 "--path", _("path|tree-ish"), "--filters",
725 /* Option compatibility with batch mode */
728 else if (batch
.follow_symlinks
)
729 usage_msg_optf(_("'%s' requires a batch mode"), usage
, options
,
730 "--follow-symlinks");
731 else if (batch
.buffer_output
>= 0)
732 usage_msg_optf(_("'%s' requires a batch mode"), usage
, options
,
734 else if (batch
.all_objects
)
735 usage_msg_optf(_("'%s' requires a batch mode"), usage
, options
,
736 "--batch-all-objects");
739 if (batch
.buffer_output
< 0)
740 batch
.buffer_output
= batch
.all_objects
;
742 /* Return early if we're in batch mode? */
746 else if (opt
&& opt
!= 'b')
747 usage_msg_optf(_("'-%c' is incompatible with batch mode"),
748 usage
, options
, opt
);
750 usage_msg_opt(_("batch modes take no arguments"), usage
,
753 return batch_objects(&batch
);
757 if (!argc
&& opt
== 'c')
758 usage_msg_optf(_("<rev> required with '%s'"),
759 usage
, options
, "--textconv");
760 else if (!argc
&& opt
== 'w')
761 usage_msg_optf(_("<rev> required with '%s'"),
762 usage
, options
, "--filters");
763 else if (!argc
&& opt_epts
)
764 usage_msg_optf(_("<object> required with '-%c'"),
765 usage
, options
, opt
);
769 usage_msg_opt(_("too many arguments"), usage
, options
);
771 usage_with_options(usage
, options
);
772 } else if (argc
!= 2) {
773 usage_msg_optf(_("only two arguments allowed in <type> <object> mode, not %d"),
774 usage
, options
, argc
);
780 if (unknown_type
&& opt
!= 't' && opt
!= 's')
781 die("git cat-file --allow-unknown-type: use with -s or -t");
782 return cat_one_file(opt
, exp_type
, obj_name
, unknown_type
);