Andrew's git - gitweb.git/blob - builtin/cat-file.c

   1/*
   2 * GIT - The information manager from hell
   3 *
   4 * Copyright (C) Linus Torvalds, 2005
   5 */
   6#include "cache.h"
   7#include "exec_cmd.h"
   8#include "tag.h"
   9#include "tree.h"
  10#include "builtin.h"
  11#include "parse-options.h"
  12#include "diff.h"
  13#include "userdiff.h"
  14#include "streaming.h"
  15
  16static int cat_one_file(int opt, const char *exp_type, const char *obj_name)
  17{
  18        unsigned char sha1[20];
  19        enum object_type type;
  20        char *buf;
  21        unsigned long size;
  22        struct object_context obj_context;
  23
  24        if (get_sha1_with_context(obj_name, 0, sha1, &obj_context))
  25                die("Not a valid object name %s", obj_name);
  26
  27        buf = NULL;
  28        switch (opt) {
  29        case 't':
  30                type = sha1_object_info(sha1, NULL);
  31                if (type > 0) {
  32                        printf("%s\n", typename(type));
  33                        return 0;
  34                }
  35                break;
  36
  37        case 's':
  38                type = sha1_object_info(sha1, &size);
  39                if (type > 0) {
  40                        printf("%lu\n", size);
  41                        return 0;
  42                }
  43                break;
  44
  45        case 'e':
  46                return !has_sha1_file(sha1);
  47
  48        case 'c':
  49                if (!obj_context.path[0])
  50                        die("git cat-file --textconv %s: <object> must be <sha1:path>",
  51                            obj_name);
  52
  53                if (textconv_object(obj_context.path, obj_context.mode, sha1, 1, &buf, &size))
  54                        break;
  55
  56        case 'p':
  57                type = sha1_object_info(sha1, NULL);
  58                if (type < 0)
  59                        die("Not a valid object name %s", obj_name);
  60
  61                /* custom pretty-print here */
  62                if (type == OBJ_TREE) {
  63                        const char *ls_args[3] = { NULL };
  64                        ls_args[0] =  "ls-tree";
  65                        ls_args[1] =  obj_name;
  66                        return cmd_ls_tree(2, ls_args, NULL);
  67                }
  68
  69                if (type == OBJ_BLOB)
  70                        return stream_blob_to_fd(1, sha1, NULL, 0);
  71                buf = read_sha1_file(sha1, &type, &size);
  72                if (!buf)
  73                        die("Cannot read object %s", obj_name);
  74
  75                /* otherwise just spit out the data */
  76                break;
  77
  78        case 0:
  79                if (type_from_string(exp_type) == OBJ_BLOB) {
  80                        unsigned char blob_sha1[20];
  81                        if (sha1_object_info(sha1, NULL) == OBJ_TAG) {
  82                                enum object_type type;
  83                                unsigned long size;
  84                                char *buffer = read_sha1_file(sha1, &type, &size);
  85                                if (memcmp(buffer, "object ", 7) ||
  86                                    get_sha1_hex(buffer + 7, blob_sha1))
  87                                        die("%s not a valid tag", sha1_to_hex(sha1));
  88                                free(buffer);
  89                        } else
  90                                hashcpy(blob_sha1, sha1);
  91
  92                        if (sha1_object_info(blob_sha1, NULL) == OBJ_BLOB)
  93                                return stream_blob_to_fd(1, blob_sha1, NULL, 0);
  94                        /*
  95                         * we attempted to dereference a tag to a blob
  96                         * and failed; there may be new dereference
  97                         * mechanisms this code is not aware of.
  98                         * fall-back to the usual case.
  99                         */
 100                }
 101                buf = read_object_with_reference(sha1, exp_type, &size, NULL);
 102                break;
 103
 104        default:
 105                die("git cat-file: unknown option: %s", exp_type);
 106        }
 107
 108        if (!buf)
 109                die("git cat-file %s: bad file", obj_name);
 110
 111        write_or_die(1, buf, size);
 112        return 0;
 113}
 114
 115struct expand_data {
 116        unsigned char sha1[20];
 117        enum object_type type;
 118        unsigned long size;
 119        unsigned long disk_size;
 120        const char *rest;
 121
 122        /*
 123         * If mark_query is true, we do not expand anything, but rather
 124         * just mark the object_info with items we wish to query.
 125         */
 126        int mark_query;
 127
 128        /*
 129         * Whether to split the input on whitespace before feeding it to
 130         * get_sha1; this is decided during the mark_query phase based on
 131         * whether we have a %(rest) token in our format.
 132         */
 133        int split_on_whitespace;
 134
 135        /*
 136         * After a mark_query run, this object_info is set up to be
 137         * passed to sha1_object_info_extended. It will point to the data
 138         * elements above, so you can retrieve the response from there.
 139         */
 140        struct object_info info;
 141};
 142
 143static int is_atom(const char *atom, const char *s, int slen)
 144{
 145        int alen = strlen(atom);
 146        return alen == slen && !memcmp(atom, s, alen);
 147}
 148
 149static void expand_atom(struct strbuf *sb, const char *atom, int len,
 150                        void *vdata)
 151{
 152        struct expand_data *data = vdata;
 153
 154        if (is_atom("objectname", atom, len)) {
 155                if (!data->mark_query)
 156                        strbuf_addstr(sb, sha1_to_hex(data->sha1));
 157        } else if (is_atom("objecttype", atom, len)) {
 158                if (data->mark_query)
 159                        data->info.typep = &data->type;
 160                else
 161                        strbuf_addstr(sb, typename(data->type));
 162        } else if (is_atom("objectsize", atom, len)) {
 163                if (data->mark_query)
 164                        data->info.sizep = &data->size;
 165                else
 166                        strbuf_addf(sb, "%lu", data->size);
 167        } else if (is_atom("objectsize:disk", atom, len)) {
 168                if (data->mark_query)
 169                        data->info.disk_sizep = &data->disk_size;
 170                else
 171                        strbuf_addf(sb, "%lu", data->disk_size);
 172        } else if (is_atom("rest", atom, len)) {
 173                if (data->mark_query)
 174                        data->split_on_whitespace = 1;
 175                else if (data->rest)
 176                        strbuf_addstr(sb, data->rest);
 177        } else
 178                die("unknown format element: %.*s", len, atom);
 179}
 180
 181static size_t expand_format(struct strbuf *sb, const char *start, void *data)
 182{
 183        const char *end;
 184
 185        if (*start != '(')
 186                return 0;
 187        end = strchr(start + 1, ')');
 188        if (!end)
 189                die("format element '%s' does not end in ')'", start);
 190
 191        expand_atom(sb, start + 1, end - start - 1, data);
 192
 193        return end - start + 1;
 194}
 195
 196static void print_object_or_die(int fd, const unsigned char *sha1,
 197                                enum object_type type, unsigned long size)
 198{
 199        if (type == OBJ_BLOB) {
 200                if (stream_blob_to_fd(fd, sha1, NULL, 0) < 0)
 201                        die("unable to stream %s to stdout", sha1_to_hex(sha1));
 202        }
 203        else {
 204                enum object_type rtype;
 205                unsigned long rsize;
 206                void *contents;
 207
 208                contents = read_sha1_file(sha1, &rtype, &rsize);
 209                if (!contents)
 210                        die("object %s disappeared", sha1_to_hex(sha1));
 211                if (rtype != type)
 212                        die("object %s changed type!?", sha1_to_hex(sha1));
 213                if (rsize != size)
 214                        die("object %s change size!?", sha1_to_hex(sha1));
 215
 216                write_or_die(fd, contents, size);
 217                free(contents);
 218        }
 219}
 220
 221struct batch_options {
 222        int enabled;
 223        int print_contents;
 224        const char *format;
 225};
 226
 227static int batch_one_object(const char *obj_name, struct batch_options *opt,
 228                            struct expand_data *data)
 229{
 230        struct strbuf buf = STRBUF_INIT;
 231
 232        if (!obj_name)
 233           return 1;
 234
 235        if (get_sha1(obj_name, data->sha1)) {
 236                printf("%s missing\n", obj_name);
 237                fflush(stdout);
 238                return 0;
 239        }
 240
 241        if (sha1_object_info_extended(data->sha1, &data->info) < 0) {
 242                printf("%s missing\n", obj_name);
 243                fflush(stdout);
 244                return 0;
 245        }
 246
 247        strbuf_expand(&buf, opt->format, expand_format, data);
 248        strbuf_addch(&buf, '\n');
 249        write_or_die(1, buf.buf, buf.len);
 250        strbuf_release(&buf);
 251
 252        if (opt->print_contents) {
 253                print_object_or_die(1, data->sha1, data->type, data->size);
 254                write_or_die(1, "\n", 1);
 255        }
 256        return 0;
 257}
 258
 259static int batch_objects(struct batch_options *opt)
 260{
 261        struct strbuf buf = STRBUF_INIT;
 262        struct expand_data data;
 263
 264        if (!opt->format)
 265                opt->format = "%(objectname) %(objecttype) %(objectsize)";
 266
 267        /*
 268         * Expand once with our special mark_query flag, which will prime the
 269         * object_info to be handed to sha1_object_info_extended for each
 270         * object.
 271         */
 272        memset(&data, 0, sizeof(data));
 273        data.mark_query = 1;
 274        strbuf_expand(&buf, opt->format, expand_format, &data);
 275        data.mark_query = 0;
 276
 277        /*
 278         * We are going to call get_sha1 on a potentially very large number of
 279         * objects. In most large cases, these will be actual object sha1s. The
 280         * cost to double-check that each one is not also a ref (just so we can
 281         * warn) ends up dwarfing the actual cost of the object lookups
 282         * themselves. We can work around it by just turning off the warning.
 283         */
 284        warn_on_object_refname_ambiguity = 0;
 285
 286        while (strbuf_getline(&buf, stdin, '\n') != EOF) {
 287                int error;
 288
 289                if (data.split_on_whitespace) {
 290                        /*
 291                         * Split at first whitespace, tying off the beginning
 292                         * of the string and saving the remainder (or NULL) in
 293                         * data.rest.
 294                         */
 295                        char *p = strpbrk(buf.buf, " \t");
 296                        if (p) {
 297                                while (*p && strchr(" \t", *p))
 298                                        *p++ = '\0';
 299                        }
 300                        data.rest = p;
 301                }
 302
 303                error = batch_one_object(buf.buf, opt, &data);
 304                if (error)
 305                        return error;
 306        }
 307
 308        return 0;
 309}
 310
 311static const char * const cat_file_usage[] = {
 312        N_("git cat-file (-t|-s|-e|-p|<type>|--textconv) <object>"),
 313        N_("git cat-file (--batch|--batch-check) < <list_of_objects>"),
 314        NULL
 315};
 316
 317static int git_cat_file_config(const char *var, const char *value, void *cb)
 318{
 319        if (userdiff_config(var, value) < 0)
 320                return -1;
 321
 322        return git_default_config(var, value, cb);
 323}
 324
 325static int batch_option_callback(const struct option *opt,
 326                                 const char *arg,
 327                                 int unset)
 328{
 329        struct batch_options *bo = opt->value;
 330
 331        if (unset) {
 332                memset(bo, 0, sizeof(*bo));
 333                return 0;
 334        }
 335
 336        bo->enabled = 1;
 337        bo->print_contents = !strcmp(opt->long_name, "batch");
 338        bo->format = arg;
 339
 340        return 0;
 341}
 342
 343int cmd_cat_file(int argc, const char **argv, const char *prefix)
 344{
 345        int opt = 0;
 346        const char *exp_type = NULL, *obj_name = NULL;
 347        struct batch_options batch = {0};
 348
 349        const struct option options[] = {
 350                OPT_GROUP(N_("<type> can be one of: blob, tree, commit, tag")),
 351                OPT_SET_INT('t', NULL, &opt, N_("show object type"), 't'),
 352                OPT_SET_INT('s', NULL, &opt, N_("show object size"), 's'),
 353                OPT_SET_INT('e', NULL, &opt,
 354                            N_("exit with zero when there's no error"), 'e'),
 355                OPT_SET_INT('p', NULL, &opt, N_("pretty-print object's content"), 'p'),
 356                OPT_SET_INT(0, "textconv", &opt,
 357                            N_("for blob objects, run textconv on object's content"), 'c'),
 358                { OPTION_CALLBACK, 0, "batch", &batch, "format",
 359                        N_("show info and content of objects fed from the standard input"),
 360                        PARSE_OPT_OPTARG, batch_option_callback },
 361                { OPTION_CALLBACK, 0, "batch-check", &batch, "format",
 362                        N_("show info about objects fed from the standard input"),
 363                        PARSE_OPT_OPTARG, batch_option_callback },
 364                OPT_END()
 365        };
 366
 367        git_config(git_cat_file_config, NULL);
 368
 369        if (argc != 3 && argc != 2)
 370                usage_with_options(cat_file_usage, options);
 371
 372        argc = parse_options(argc, argv, prefix, options, cat_file_usage, 0);
 373
 374        if (opt) {
 375                if (argc == 1)
 376                        obj_name = argv[0];
 377                else
 378                        usage_with_options(cat_file_usage, options);
 379        }
 380        if (!opt && !batch.enabled) {
 381                if (argc == 2) {
 382                        exp_type = argv[0];
 383                        obj_name = argv[1];
 384                } else
 385                        usage_with_options(cat_file_usage, options);
 386        }
 387        if (batch.enabled && (opt || argc)) {
 388                usage_with_options(cat_file_usage, options);
 389        }
 390
 391        if (batch.enabled)
 392                return batch_objects(&batch);
 393
 394        return cat_one_file(opt, exp_type, obj_name);
 395}