git.oblomov.eu Git - git/blob - builtin/update-ref.c

   1 #include "cache.h"
   2 #include "refs.h"
   3 #include "builtin.h"
   4 #include "parse-options.h"
   5 #include "quote.h"
   6 #include "argv-array.h"
   7
   8 static const char * const git_update_ref_usage[] = {
   9         N_("git update-ref [options] -d <refname> [<oldval>]"),
  10         N_("git update-ref [options]    <refname> <newval> [<oldval>]"),
  11         N_("git update-ref [options] --stdin [-z]"),
  12         NULL
  13 };
  14
  15 static struct ref_transaction *transaction;
  16
  17 static char line_termination = '\n';
  18 static int update_flags;
  19 static struct strbuf err = STRBUF_INIT;
  20
  21 /*
  22  * Parse one whitespace- or NUL-terminated, possibly C-quoted argument
  23  * and append the result to arg.  Return a pointer to the terminator.
  24  * Die if there is an error in how the argument is C-quoted.  This
  25  * function is only used if not -z.
  26  */
  27 static const char *parse_arg(const char *next, struct strbuf *arg)
  28 {
  29         if (*next == '"') {
  30                 const char *orig = next;
  31
  32                 if (unquote_c_style(arg, next, &next))
  33                         die("badly quoted argument: %s", orig);
  34                 if (*next && !isspace(*next))
  35                         die("unexpected character after quoted argument: %s", orig);
  36         } else {
  37                 while (*next && !isspace(*next))
  38                         strbuf_addch(arg, *next++);
  39         }
  40
  41         return next;
  42 }
  43
  44 /*
  45  * Parse the reference name immediately after "command SP".  If not
  46  * -z, then handle C-quoting.  Return a pointer to a newly allocated
  47  * string containing the name of the reference, or NULL if there was
  48  * an error.  Update *next to point at the character that terminates
  49  * the argument.  Die if C-quoting is malformed or the reference name
  50  * is invalid.
  51  */
  52 static char *parse_refname(struct strbuf *input, const char **next)
  53 {
  54         struct strbuf ref = STRBUF_INIT;
  55
  56         if (line_termination) {
  57                 /* Without -z, use the next argument */
  58                 *next = parse_arg(*next, &ref);
  59         } else {
  60                 /* With -z, use everything up to the next NUL */
  61                 strbuf_addstr(&ref, *next);
  62                 *next += ref.len;
  63         }
  64
  65         if (!ref.len) {
  66                 strbuf_release(&ref);
  67                 return NULL;
  68         }
  69
  70         if (check_refname_format(ref.buf, REFNAME_ALLOW_ONELEVEL))
  71                 die("invalid ref format: %s", ref.buf);
  72
  73         return strbuf_detach(&ref, NULL);
  74 }
  75
  76 /*
  77  * The value being parsed is <oldvalue> (as opposed to <newvalue>; the
  78  * difference affects which error messages are generated):
  79  */
  80 #define PARSE_SHA1_OLD 0x01
  81
  82 /*
  83  * For backwards compatibility, accept an empty string for update's
  84  * <newvalue> in binary mode to be equivalent to specifying zeros.
  85  */
  86 #define PARSE_SHA1_ALLOW_EMPTY 0x02
  87
  88 /*
  89  * Parse an argument separator followed by the next argument, if any.
  90  * If there is an argument, convert it to a SHA-1, write it to sha1,
  91  * set *next to point at the character terminating the argument, and
  92  * return 0.  If there is no argument at all (not even the empty
  93  * string), return 1 and leave *next unchanged.  If the value is
  94  * provided but cannot be converted to a SHA-1, die.  flags can
  95  * include PARSE_SHA1_OLD and/or PARSE_SHA1_ALLOW_EMPTY.
  96  */
  97 static int parse_next_sha1(struct strbuf *input, const char **next,
  98                            unsigned char *sha1,
  99                            const char *command, const char *refname,
 100                            int flags)
 101 {
 102         struct strbuf arg = STRBUF_INIT;
 103         int ret = 0;
 104
 105         if (*next == input->buf + input->len)
 106                 goto eof;
 107
 108         if (line_termination) {
 109                 /* Without -z, consume SP and use next argument */
 110                 if (!**next || **next == line_termination)
 111                         return 1;
 112                 if (**next != ' ')
 113                         die("%s %s: expected SP but got: %s",
 114                             command, refname, *next);
 115                 (*next)++;
 116                 *next = parse_arg(*next, &arg);
 117                 if (arg.len) {
 118                         if (get_sha1(arg.buf, sha1))
 119                                 goto invalid;
 120                 } else {
 121                         /* Without -z, an empty value means all zeros: */
 122                         hashclr(sha1);
 123                 }
 124         } else {
 125                 /* With -z, read the next NUL-terminated line */
 126                 if (**next)
 127                         die("%s %s: expected NUL but got: %s",
 128                             command, refname, *next);
 129                 (*next)++;
 130                 if (*next == input->buf + input->len)
 131                         goto eof;
 132                 strbuf_addstr(&arg, *next);
 133                 *next += arg.len;
 134
 135                 if (arg.len) {
 136                         if (get_sha1(arg.buf, sha1))
 137                                 goto invalid;
 138                 } else if (flags & PARSE_SHA1_ALLOW_EMPTY) {
 139                         /* With -z, treat an empty value as all zeros: */
 140                         warning("%s %s: missing <newvalue>, treating as zero",
 141                                 command, refname);
 142                         hashclr(sha1);
 143                 } else {
 144                         /*
 145                          * With -z, an empty non-required value means
 146                          * unspecified:
 147                          */
 148                         ret = 1;
 149                 }
 150         }
 151
 152         strbuf_release(&arg);
 153
 154         return ret;
 155
 156  invalid:
 157         die(flags & PARSE_SHA1_OLD ?
 158             "%s %s: invalid <oldvalue>: %s" :
 159             "%s %s: invalid <newvalue>: %s",
 160             command, refname, arg.buf);
 161
 162  eof:
 163         die(flags & PARSE_SHA1_OLD ?
 164             "%s %s: unexpected end of input when reading <oldvalue>" :
 165             "%s %s: unexpected end of input when reading <newvalue>",
 166             command, refname);
 167 }
 168
 169
 170 /*
 171  * The following five parse_cmd_*() functions parse the corresponding
 172  * command.  In each case, next points at the character following the
 173  * command name and the following space.  They each return a pointer
 174  * to the character terminating the command, and die with an
 175  * explanatory message if there are any parsing problems.  All of
 176  * these functions handle either text or binary format input,
 177  * depending on how line_termination is set.
 178  */
 179
 180 static const char *parse_cmd_update(struct strbuf *input, const char *next)
 181 {
 182         char *refname;
 183         unsigned char new_sha1[20];
 184         unsigned char old_sha1[20];
 185         int have_old;
 186
 187         refname = parse_refname(input, &next);
 188         if (!refname)
 189                 die("update: missing <ref>");
 190
 191         if (parse_next_sha1(input, &next, new_sha1, "update", refname,
 192                             PARSE_SHA1_ALLOW_EMPTY))
 193                 die("update %s: missing <newvalue>", refname);
 194
 195         have_old = !parse_next_sha1(input, &next, old_sha1, "update", refname,
 196                                     PARSE_SHA1_OLD);
 197
 198         if (*next != line_termination)
 199                 die("update %s: extra input: %s", refname, next);
 200
 201         if (ref_transaction_update(transaction, refname, new_sha1, old_sha1,
 202                                    update_flags, have_old, &err))
 203                 die("%s", err.buf);
 204
 205         update_flags = 0;
 206         free(refname);
 207
 208         return next;
 209 }
 210
 211 static const char *parse_cmd_create(struct strbuf *input, const char *next)
 212 {
 213         char *refname;
 214         unsigned char new_sha1[20];
 215
 216         refname = parse_refname(input, &next);
 217         if (!refname)
 218                 die("create: missing <ref>");
 219
 220         if (parse_next_sha1(input, &next, new_sha1, "create", refname, 0))
 221                 die("create %s: missing <newvalue>", refname);
 222
 223         if (is_null_sha1(new_sha1))
 224                 die("create %s: zero <newvalue>", refname);
 225
 226         if (*next != line_termination)
 227                 die("create %s: extra input: %s", refname, next);
 228
 229         if (ref_transaction_create(transaction, refname, new_sha1,
 230                                    update_flags, &err))
 231                 die("%s", err.buf);
 232
 233         update_flags = 0;
 234         free(refname);
 235
 236         return next;
 237 }
 238
 239 static const char *parse_cmd_delete(struct strbuf *input, const char *next)
 240 {
 241         char *refname;
 242         unsigned char old_sha1[20];
 243         int have_old;
 244
 245         refname = parse_refname(input, &next);
 246         if (!refname)
 247                 die("delete: missing <ref>");
 248
 249         if (parse_next_sha1(input, &next, old_sha1, "delete", refname,
 250                             PARSE_SHA1_OLD)) {
 251                 have_old = 0;
 252         } else {
 253                 if (is_null_sha1(old_sha1))
 254                         die("delete %s: zero <oldvalue>", refname);
 255                 have_old = 1;
 256         }
 257
 258         if (*next != line_termination)
 259                 die("delete %s: extra input: %s", refname, next);
 260
 261         ref_transaction_delete(transaction, refname, old_sha1,
 262                                update_flags, have_old);
 263
 264         update_flags = 0;
 265         free(refname);
 266
 267         return next;
 268 }
 269
 270 static const char *parse_cmd_verify(struct strbuf *input, const char *next)
 271 {
 272         char *refname;
 273         unsigned char new_sha1[20];
 274         unsigned char old_sha1[20];
 275         int have_old;
 276
 277         refname = parse_refname(input, &next);
 278         if (!refname)
 279                 die("verify: missing <ref>");
 280
 281         if (parse_next_sha1(input, &next, old_sha1, "verify", refname,
 282                             PARSE_SHA1_OLD)) {
 283                 hashclr(new_sha1);
 284                 have_old = 0;
 285         } else {
 286                 hashcpy(new_sha1, old_sha1);
 287                 have_old = 1;
 288         }
 289
 290         if (*next != line_termination)
 291                 die("verify %s: extra input: %s", refname, next);
 292
 293         if (ref_transaction_update(transaction, refname, new_sha1, old_sha1,
 294                                    update_flags, have_old, &err))
 295                 die("%s", err.buf);
 296
 297         update_flags = 0;
 298         free(refname);
 299
 300         return next;
 301 }
 302
 303 static const char *parse_cmd_option(struct strbuf *input, const char *next)
 304 {
 305         if (!strncmp(next, "no-deref", 8) && next[8] == line_termination)
 306                 update_flags |= REF_NODEREF;
 307         else
 308                 die("option unknown: %s", next);
 309         return next + 8;
 310 }
 311
 312 static void update_refs_stdin(void)
 313 {
 314         struct strbuf input = STRBUF_INIT;
 315         const char *next;
 316
 317         if (strbuf_read(&input, 0, 1000) < 0)
 318                 die_errno("could not read from stdin");
 319         next = input.buf;
 320         /* Read each line dispatch its command */
 321         while (next < input.buf + input.len) {
 322                 if (*next == line_termination)
 323                         die("empty command in input");
 324                 else if (isspace(*next))
 325                         die("whitespace before command: %s", next);
 326                 else if (starts_with(next, "update "))
 327                         next = parse_cmd_update(&input, next + 7);
 328                 else if (starts_with(next, "create "))
 329                         next = parse_cmd_create(&input, next + 7);
 330                 else if (starts_with(next, "delete "))
 331                         next = parse_cmd_delete(&input, next + 7);
 332                 else if (starts_with(next, "verify "))
 333                         next = parse_cmd_verify(&input, next + 7);
 334                 else if (starts_with(next, "option "))
 335                         next = parse_cmd_option(&input, next + 7);
 336                 else
 337                         die("unknown command: %s", next);
 338
 339                 next++;
 340         }
 341
 342         strbuf_release(&input);
 343 }
 344
 345 int cmd_update_ref(int argc, const char **argv, const char *prefix)
 346 {
 347         const char *refname, *oldval, *msg = NULL;
 348         unsigned char sha1[20], oldsha1[20];
 349         int delete = 0, no_deref = 0, read_stdin = 0, end_null = 0, flags = 0;
 350         struct option options[] = {
 351                 OPT_STRING( 'm', NULL, &msg, N_("reason"), N_("reason of the update")),
 352                 OPT_BOOL('d', NULL, &delete, N_("delete the reference")),
 353                 OPT_BOOL( 0 , "no-deref", &no_deref,
 354                                         N_("update <refname> not the one it points to")),
 355                 OPT_BOOL('z', NULL, &end_null, N_("stdin has NUL-terminated arguments")),
 356                 OPT_BOOL( 0 , "stdin", &read_stdin, N_("read updates from stdin")),
 357                 OPT_END(),
 358         };
 359
 360         git_config(git_default_config, NULL);
 361         argc = parse_options(argc, argv, prefix, options, git_update_ref_usage,
 362                              0);
 363         if (msg && !*msg)
 364                 die("Refusing to perform update with empty message.");
 365
 366         if (read_stdin) {
 367                 transaction = ref_transaction_begin();
 368                 if (delete || no_deref || argc > 0)
 369                         usage_with_options(git_update_ref_usage, options);
 370                 if (end_null)
 371                         line_termination = '\0';
 372                 update_refs_stdin();
 373                 if (ref_transaction_commit(transaction, msg, &err))
 374                         die("%s", err.buf);
 375                 ref_transaction_free(transaction);
 376                 return 0;
 377         }
 378
 379         if (end_null)
 380                 usage_with_options(git_update_ref_usage, options);
 381
 382         if (delete) {
 383                 if (argc < 1 || argc > 2)
 384                         usage_with_options(git_update_ref_usage, options);
 385                 refname = argv[0];
 386                 oldval = argv[1];
 387         } else {
 388                 const char *value;
 389                 if (argc < 2 || argc > 3)
 390                         usage_with_options(git_update_ref_usage, options);
 391                 refname = argv[0];
 392                 value = argv[1];
 393                 oldval = argv[2];
 394                 if (get_sha1(value, sha1))
 395                         die("%s: not a valid SHA1", value);
 396         }
 397
 398         hashclr(oldsha1); /* all-zero hash in case oldval is the empty string */
 399         if (oldval && *oldval && get_sha1(oldval, oldsha1))
 400                 die("%s: not a valid old SHA1", oldval);
 401
 402         if (no_deref)
 403                 flags = REF_NODEREF;
 404         if (delete)
 405                 return delete_ref(refname, oldval ? oldsha1 : NULL, flags);
 406         else
 407                 return update_ref(msg, refname, sha1, oldval ? oldsha1 : NULL,
 408                                   flags, UPDATE_REFS_DIE_ON_ERR);
 409 }