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         ref_transaction_create(transaction, refname, new_sha1, update_flags);
 230
 231         update_flags = 0;
 232         free(refname);
 233
 234         return next;
 235 }
 236
 237 static const char *parse_cmd_delete(struct strbuf *input, const char *next)
 238 {
 239         char *refname;
 240         unsigned char old_sha1[20];
 241         int have_old;
 242
 243         refname = parse_refname(input, &next);
 244         if (!refname)
 245                 die("delete: missing <ref>");
 246
 247         if (parse_next_sha1(input, &next, old_sha1, "delete", refname,
 248                             PARSE_SHA1_OLD)) {
 249                 have_old = 0;
 250         } else {
 251                 if (is_null_sha1(old_sha1))
 252                         die("delete %s: zero <oldvalue>", refname);
 253                 have_old = 1;
 254         }
 255
 256         if (*next != line_termination)
 257                 die("delete %s: extra input: %s", refname, next);
 258
 259         ref_transaction_delete(transaction, refname, old_sha1,
 260                                update_flags, have_old);
 261
 262         update_flags = 0;
 263         free(refname);
 264
 265         return next;
 266 }
 267
 268 static const char *parse_cmd_verify(struct strbuf *input, const char *next)
 269 {
 270         char *refname;
 271         unsigned char new_sha1[20];
 272         unsigned char old_sha1[20];
 273         int have_old;
 274
 275         refname = parse_refname(input, &next);
 276         if (!refname)
 277                 die("verify: missing <ref>");
 278
 279         if (parse_next_sha1(input, &next, old_sha1, "verify", refname,
 280                             PARSE_SHA1_OLD)) {
 281                 hashclr(new_sha1);
 282                 have_old = 0;
 283         } else {
 284                 hashcpy(new_sha1, old_sha1);
 285                 have_old = 1;
 286         }
 287
 288         if (*next != line_termination)
 289                 die("verify %s: extra input: %s", refname, next);
 290
 291         if (ref_transaction_update(transaction, refname, new_sha1, old_sha1,
 292                                    update_flags, have_old, &err))
 293                 die("%s", err.buf);
 294
 295         update_flags = 0;
 296         free(refname);
 297
 298         return next;
 299 }
 300
 301 static const char *parse_cmd_option(struct strbuf *input, const char *next)
 302 {
 303         if (!strncmp(next, "no-deref", 8) && next[8] == line_termination)
 304                 update_flags |= REF_NODEREF;
 305         else
 306                 die("option unknown: %s", next);
 307         return next + 8;
 308 }
 309
 310 static void update_refs_stdin(void)
 311 {
 312         struct strbuf input = STRBUF_INIT;
 313         const char *next;
 314
 315         if (strbuf_read(&input, 0, 1000) < 0)
 316                 die_errno("could not read from stdin");
 317         next = input.buf;
 318         /* Read each line dispatch its command */
 319         while (next < input.buf + input.len) {
 320                 if (*next == line_termination)
 321                         die("empty command in input");
 322                 else if (isspace(*next))
 323                         die("whitespace before command: %s", next);
 324                 else if (starts_with(next, "update "))
 325                         next = parse_cmd_update(&input, next + 7);
 326                 else if (starts_with(next, "create "))
 327                         next = parse_cmd_create(&input, next + 7);
 328                 else if (starts_with(next, "delete "))
 329                         next = parse_cmd_delete(&input, next + 7);
 330                 else if (starts_with(next, "verify "))
 331                         next = parse_cmd_verify(&input, next + 7);
 332                 else if (starts_with(next, "option "))
 333                         next = parse_cmd_option(&input, next + 7);
 334                 else
 335                         die("unknown command: %s", next);
 336
 337                 next++;
 338         }
 339
 340         strbuf_release(&input);
 341 }
 342
 343 int cmd_update_ref(int argc, const char **argv, const char *prefix)
 344 {
 345         const char *refname, *oldval, *msg = NULL;
 346         unsigned char sha1[20], oldsha1[20];
 347         int delete = 0, no_deref = 0, read_stdin = 0, end_null = 0, flags = 0;
 348         struct option options[] = {
 349                 OPT_STRING( 'm', NULL, &msg, N_("reason"), N_("reason of the update")),
 350                 OPT_BOOL('d', NULL, &delete, N_("delete the reference")),
 351                 OPT_BOOL( 0 , "no-deref", &no_deref,
 352                                         N_("update <refname> not the one it points to")),
 353                 OPT_BOOL('z', NULL, &end_null, N_("stdin has NUL-terminated arguments")),
 354                 OPT_BOOL( 0 , "stdin", &read_stdin, N_("read updates from stdin")),
 355                 OPT_END(),
 356         };
 357
 358         git_config(git_default_config, NULL);
 359         argc = parse_options(argc, argv, prefix, options, git_update_ref_usage,
 360                              0);
 361         if (msg && !*msg)
 362                 die("Refusing to perform update with empty message.");
 363
 364         if (read_stdin) {
 365                 transaction = ref_transaction_begin();
 366                 if (delete || no_deref || argc > 0)
 367                         usage_with_options(git_update_ref_usage, options);
 368                 if (end_null)
 369                         line_termination = '\0';
 370                 update_refs_stdin();
 371                 if (ref_transaction_commit(transaction, msg, &err))
 372                         die("%s", err.buf);
 373                 ref_transaction_free(transaction);
 374                 return 0;
 375         }
 376
 377         if (end_null)
 378                 usage_with_options(git_update_ref_usage, options);
 379
 380         if (delete) {
 381                 if (argc < 1 || argc > 2)
 382                         usage_with_options(git_update_ref_usage, options);
 383                 refname = argv[0];
 384                 oldval = argv[1];
 385         } else {
 386                 const char *value;
 387                 if (argc < 2 || argc > 3)
 388                         usage_with_options(git_update_ref_usage, options);
 389                 refname = argv[0];
 390                 value = argv[1];
 391                 oldval = argv[2];
 392                 if (get_sha1(value, sha1))
 393                         die("%s: not a valid SHA1", value);
 394         }
 395
 396         hashclr(oldsha1); /* all-zero hash in case oldval is the empty string */
 397         if (oldval && *oldval && get_sha1(oldval, oldsha1))
 398                 die("%s: not a valid old SHA1", oldval);
 399
 400         if (no_deref)
 401                 flags = REF_NODEREF;
 402         if (delete)
 403                 return delete_ref(refname, oldval ? oldsha1 : NULL, flags);
 404         else
 405                 return update_ref(msg, refname, sha1, oldval ? oldsha1 : NULL,
 406                                   flags, UPDATE_REFS_DIE_ON_ERR);
 407 }