4 #include "parse-options.h"
6 #include "argv-array.h"
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]"),
15 static char line_termination = '\n';
16 static int update_flags;
19 * Parse one whitespace- or NUL-terminated, possibly C-quoted argument
20 * and append the result to arg. Return a pointer to the terminator.
21 * Die if there is an error in how the argument is C-quoted. This
22 * function is only used if not -z.
24 static const char *parse_arg(const char *next, struct strbuf *arg)
27 const char *orig = next;
29 if (unquote_c_style(arg, next, &next))
30 die("badly quoted argument: %s", orig);
31 if (*next && !isspace(*next))
32 die("unexpected character after quoted argument: %s", orig);
34 while (*next && !isspace(*next))
35 strbuf_addch(arg, *next++);
42 * Parse the reference name immediately after "command SP". If not
43 * -z, then handle C-quoting. Return a pointer to a newly allocated
44 * string containing the name of the reference, or NULL if there was
45 * an error. Update *next to point at the character that terminates
46 * the argument. Die if C-quoting is malformed or the reference name
49 static char *parse_refname(struct strbuf *input, const char **next)
51 struct strbuf ref = STRBUF_INIT;
53 if (line_termination) {
54 /* Without -z, use the next argument */
55 *next = parse_arg(*next, &ref);
57 /* With -z, use everything up to the next NUL */
58 strbuf_addstr(&ref, *next);
67 if (check_refname_format(ref.buf, REFNAME_ALLOW_ONELEVEL))
68 die("invalid ref format: %s", ref.buf);
70 return strbuf_detach(&ref, NULL);
74 * The value being parsed is <oldvalue> (as opposed to <newvalue>; the
75 * difference affects which error messages are generated):
77 #define PARSE_SHA1_OLD 0x01
80 * For backwards compatibility, accept an empty string for update's
81 * <newvalue> in binary mode to be equivalent to specifying zeros.
83 #define PARSE_SHA1_ALLOW_EMPTY 0x02
86 * Parse an argument separator followed by the next argument, if any.
87 * If there is an argument, convert it to a SHA-1, write it to sha1,
88 * set *next to point at the character terminating the argument, and
89 * return 0. If there is no argument at all (not even the empty
90 * string), return 1 and leave *next unchanged. If the value is
91 * provided but cannot be converted to a SHA-1, die. flags can
92 * include PARSE_SHA1_OLD and/or PARSE_SHA1_ALLOW_EMPTY.
94 static int parse_next_sha1(struct strbuf *input, const char **next,
96 const char *command, const char *refname,
99 struct strbuf arg = STRBUF_INIT;
102 if (*next == input->buf + input->len)
105 if (line_termination) {
106 /* Without -z, consume SP and use next argument */
107 if (!**next || **next == line_termination)
110 die("%s %s: expected SP but got: %s",
111 command, refname, *next);
113 *next = parse_arg(*next, &arg);
115 if (get_sha1(arg.buf, sha1))
118 /* Without -z, an empty value means all zeros: */
122 /* With -z, read the next NUL-terminated line */
124 die("%s %s: expected NUL but got: %s",
125 command, refname, *next);
127 if (*next == input->buf + input->len)
129 strbuf_addstr(&arg, *next);
133 if (get_sha1(arg.buf, sha1))
135 } else if (flags & PARSE_SHA1_ALLOW_EMPTY) {
136 /* With -z, treat an empty value as all zeros: */
137 warning("%s %s: missing <newvalue>, treating as zero",
142 * With -z, an empty non-required value means
149 strbuf_release(&arg);
154 die(flags & PARSE_SHA1_OLD ?
155 "%s %s: invalid <oldvalue>: %s" :
156 "%s %s: invalid <newvalue>: %s",
157 command, refname, arg.buf);
160 die(flags & PARSE_SHA1_OLD ?
161 "%s %s: unexpected end of input when reading <oldvalue>" :
162 "%s %s: unexpected end of input when reading <newvalue>",
168 * The following five parse_cmd_*() functions parse the corresponding
169 * command. In each case, next points at the character following the
170 * command name and the following space. They each return a pointer
171 * to the character terminating the command, and die with an
172 * explanatory message if there are any parsing problems. All of
173 * these functions handle either text or binary format input,
174 * depending on how line_termination is set.
177 static const char *parse_cmd_update(struct ref_transaction *transaction,
178 struct strbuf *input, const char *next)
180 struct strbuf err = STRBUF_INIT;
182 unsigned char new_sha1[20];
183 unsigned char old_sha1[20];
186 refname = parse_refname(input, &next);
188 die("update: missing <ref>");
190 if (parse_next_sha1(input, &next, new_sha1, "update", refname,
191 PARSE_SHA1_ALLOW_EMPTY))
192 die("update %s: missing <newvalue>", refname);
194 have_old = !parse_next_sha1(input, &next, old_sha1, "update", refname,
197 if (*next != line_termination)
198 die("update %s: extra input: %s", refname, next);
200 if (ref_transaction_update(transaction, refname, new_sha1, old_sha1,
201 update_flags, have_old, &err))
206 strbuf_release(&err);
211 static const char *parse_cmd_create(struct ref_transaction *transaction,
212 struct strbuf *input, const char *next)
214 struct strbuf err = STRBUF_INIT;
216 unsigned char new_sha1[20];
218 refname = parse_refname(input, &next);
220 die("create: missing <ref>");
222 if (parse_next_sha1(input, &next, new_sha1, "create", refname, 0))
223 die("create %s: missing <newvalue>", refname);
225 if (is_null_sha1(new_sha1))
226 die("create %s: zero <newvalue>", refname);
228 if (*next != line_termination)
229 die("create %s: extra input: %s", refname, next);
231 if (ref_transaction_create(transaction, refname, new_sha1,
237 strbuf_release(&err);
242 static const char *parse_cmd_delete(struct ref_transaction *transaction,
243 struct strbuf *input, const char *next)
245 struct strbuf err = STRBUF_INIT;
247 unsigned char old_sha1[20];
250 refname = parse_refname(input, &next);
252 die("delete: missing <ref>");
254 if (parse_next_sha1(input, &next, old_sha1, "delete", refname,
258 if (is_null_sha1(old_sha1))
259 die("delete %s: zero <oldvalue>", refname);
263 if (*next != line_termination)
264 die("delete %s: extra input: %s", refname, next);
266 if (ref_transaction_delete(transaction, refname, old_sha1,
267 update_flags, have_old, &err))
272 strbuf_release(&err);
277 static const char *parse_cmd_verify(struct ref_transaction *transaction,
278 struct strbuf *input, const char *next)
280 struct strbuf err = STRBUF_INIT;
282 unsigned char new_sha1[20];
283 unsigned char old_sha1[20];
286 refname = parse_refname(input, &next);
288 die("verify: missing <ref>");
290 if (parse_next_sha1(input, &next, old_sha1, "verify", refname,
295 hashcpy(new_sha1, old_sha1);
299 if (*next != line_termination)
300 die("verify %s: extra input: %s", refname, next);
302 if (ref_transaction_update(transaction, refname, new_sha1, old_sha1,
303 update_flags, have_old, &err))
308 strbuf_release(&err);
313 static const char *parse_cmd_option(struct strbuf *input, const char *next)
315 if (!strncmp(next, "no-deref", 8) && next[8] == line_termination)
316 update_flags |= REF_NODEREF;
318 die("option unknown: %s", next);
322 static void update_refs_stdin(struct ref_transaction *transaction)
324 struct strbuf input = STRBUF_INIT;
327 if (strbuf_read(&input, 0, 1000) < 0)
328 die_errno("could not read from stdin");
330 /* Read each line dispatch its command */
331 while (next < input.buf + input.len) {
332 if (*next == line_termination)
333 die("empty command in input");
334 else if (isspace(*next))
335 die("whitespace before command: %s", next);
336 else if (starts_with(next, "update "))
337 next = parse_cmd_update(transaction, &input, next + 7);
338 else if (starts_with(next, "create "))
339 next = parse_cmd_create(transaction, &input, next + 7);
340 else if (starts_with(next, "delete "))
341 next = parse_cmd_delete(transaction, &input, next + 7);
342 else if (starts_with(next, "verify "))
343 next = parse_cmd_verify(transaction, &input, next + 7);
344 else if (starts_with(next, "option "))
345 next = parse_cmd_option(&input, next + 7);
347 die("unknown command: %s", next);
352 strbuf_release(&input);
355 int cmd_update_ref(int argc, const char **argv, const char *prefix)
357 const char *refname, *oldval, *msg = NULL;
358 unsigned char sha1[20], oldsha1[20];
359 int delete = 0, no_deref = 0, read_stdin = 0, end_null = 0, flags = 0;
360 struct option options[] = {
361 OPT_STRING( 'm', NULL, &msg, N_("reason"), N_("reason of the update")),
362 OPT_BOOL('d', NULL, &delete, N_("delete the reference")),
363 OPT_BOOL( 0 , "no-deref", &no_deref,
364 N_("update <refname> not the one it points to")),
365 OPT_BOOL('z', NULL, &end_null, N_("stdin has NUL-terminated arguments")),
366 OPT_BOOL( 0 , "stdin", &read_stdin, N_("read updates from stdin")),
370 git_config(git_default_config, NULL);
371 argc = parse_options(argc, argv, prefix, options, git_update_ref_usage,
374 die("Refusing to perform update with empty message.");
377 struct strbuf err = STRBUF_INIT;
378 struct ref_transaction *transaction;
380 transaction = ref_transaction_begin(&err);
383 if (delete || no_deref || argc > 0)
384 usage_with_options(git_update_ref_usage, options);
386 line_termination = '\0';
387 update_refs_stdin(transaction);
388 if (ref_transaction_commit(transaction, msg, &err))
390 ref_transaction_free(transaction);
391 strbuf_release(&err);
396 usage_with_options(git_update_ref_usage, options);
399 if (argc < 1 || argc > 2)
400 usage_with_options(git_update_ref_usage, options);
405 if (argc < 2 || argc > 3)
406 usage_with_options(git_update_ref_usage, options);
410 if (get_sha1(value, sha1))
411 die("%s: not a valid SHA1", value);
414 hashclr(oldsha1); /* all-zero hash in case oldval is the empty string */
415 if (oldval && *oldval && get_sha1(oldval, oldsha1))
416 die("%s: not a valid old SHA1", oldval);
421 return delete_ref(refname, oldval ? oldsha1 : NULL, flags);
423 return update_ref(msg, refname, sha1, oldval ? oldsha1 : NULL,
424 flags, UPDATE_REFS_DIE_ON_ERR);