]>
Commit | Line | Data |
---|---|---|
66bf85a4 | 1 | #include "cache.h" |
b2141fc1 | 2 | #include "config.h" |
66bf85a4 | 3 | #include "refs.h" |
854b4629 | 4 | #include "builtin.h" |
89942be6 | 5 | #include "parse-options.h" |
c750ba95 BK |
6 | #include "quote.h" |
7 | #include "argv-array.h" | |
66bf85a4 | 8 | |
89942be6 | 9 | static const char * const git_update_ref_usage[] = { |
9c9b4f2f AH |
10 | N_("git update-ref [<options>] -d <refname> [<old-val>]"), |
11 | N_("git update-ref [<options>] <refname> <new-val> [<old-val>]"), | |
12 | N_("git update-ref [<options>] --stdin [-z]"), | |
89942be6 PH |
13 | NULL |
14 | }; | |
152da3df | 15 | |
c750ba95 BK |
16 | static char line_termination = '\n'; |
17 | static int update_flags; | |
144c76fa | 18 | static unsigned create_reflog_flag; |
db7516ab | 19 | static const char *msg; |
c750ba95 | 20 | |
697a4151 MH |
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 | */ | |
c750ba95 BK |
27 | static const char *parse_arg(const char *next, struct strbuf *arg) |
28 | { | |
697a4151 MH |
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 { | |
c750ba95 BK |
37 | while (*next && !isspace(*next)) |
38 | strbuf_addch(arg, *next++); | |
697a4151 | 39 | } |
c750ba95 | 40 | |
c750ba95 BK |
41 | return next; |
42 | } | |
43 | ||
e23d8435 | 44 | /* |
ed410e61 MH |
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. | |
e23d8435 | 51 | */ |
ed410e61 | 52 | static char *parse_refname(struct strbuf *input, const char **next) |
c750ba95 | 53 | { |
ed410e61 MH |
54 | struct strbuf ref = STRBUF_INIT; |
55 | ||
c750ba95 BK |
56 | if (line_termination) { |
57 | /* Without -z, use the next argument */ | |
ed410e61 | 58 | *next = parse_arg(*next, &ref); |
c750ba95 | 59 | } else { |
e23d8435 | 60 | /* With -z, use everything up to the next NUL */ |
ed410e61 MH |
61 | strbuf_addstr(&ref, *next); |
62 | *next += ref.len; | |
63 | } | |
64 | ||
65 | if (!ref.len) { | |
66 | strbuf_release(&ref); | |
67 | return NULL; | |
c750ba95 | 68 | } |
ed410e61 MH |
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); | |
c750ba95 BK |
74 | } |
75 | ||
e23d8435 | 76 | /* |
3afcc463 MH |
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 | |
e23d8435 | 92 | * return 0. If there is no argument at all (not even the empty |
3afcc463 MH |
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. | |
e23d8435 | 96 | */ |
a0bb5535 | 97 | static int parse_next_oid(struct strbuf *input, const char **next, |
98 | struct object_id *oid, | |
99 | const char *command, const char *refname, | |
100 | int flags) | |
c750ba95 | 101 | { |
3afcc463 MH |
102 | struct strbuf arg = STRBUF_INIT; |
103 | int ret = 0; | |
104 | ||
105 | if (*next == input->buf + input->len) | |
106 | goto eof; | |
107 | ||
c750ba95 BK |
108 | if (line_termination) { |
109 | /* Without -z, consume SP and use next argument */ | |
e23d8435 | 110 | if (!**next || **next == line_termination) |
3afcc463 | 111 | return 1; |
e23d8435 | 112 | if (**next != ' ') |
3afcc463 MH |
113 | die("%s %s: expected SP but got: %s", |
114 | command, refname, *next); | |
e23d8435 | 115 | (*next)++; |
3afcc463 MH |
116 | *next = parse_arg(*next, &arg); |
117 | if (arg.len) { | |
a0bb5535 | 118 | if (get_oid(arg.buf, oid)) |
3afcc463 MH |
119 | goto invalid; |
120 | } else { | |
121 | /* Without -z, an empty value means all zeros: */ | |
a0bb5535 | 122 | oidclr(oid); |
3afcc463 | 123 | } |
c750ba95 BK |
124 | } else { |
125 | /* With -z, read the next NUL-terminated line */ | |
e23d8435 | 126 | if (**next) |
3afcc463 MH |
127 | die("%s %s: expected NUL but got: %s", |
128 | command, refname, *next); | |
e23d8435 MH |
129 | (*next)++; |
130 | if (*next == input->buf + input->len) | |
3afcc463 MH |
131 | goto eof; |
132 | strbuf_addstr(&arg, *next); | |
133 | *next += arg.len; | |
134 | ||
135 | if (arg.len) { | |
a0bb5535 | 136 | if (get_oid(arg.buf, oid)) |
3afcc463 MH |
137 | goto invalid; |
138 | } else if (flags & PARSE_SHA1_ALLOW_EMPTY) { | |
139 | /* With -z, treat an empty value as all zeros: */ | |
1fbd5049 MH |
140 | warning("%s %s: missing <newvalue>, treating as zero", |
141 | command, refname); | |
a0bb5535 | 142 | oidclr(oid); |
3afcc463 MH |
143 | } else { |
144 | /* | |
145 | * With -z, an empty non-required value means | |
146 | * unspecified: | |
147 | */ | |
148 | ret = 1; | |
149 | } | |
c750ba95 | 150 | } |
3afcc463 MH |
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 ? | |
726f6916 MH |
164 | "%s %s: unexpected end of input when reading <oldvalue>" : |
165 | "%s %s: unexpected end of input when reading <newvalue>", | |
3afcc463 | 166 | command, refname); |
c750ba95 BK |
167 | } |
168 | ||
e23d8435 MH |
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 | ||
88499b29 JN |
180 | static const char *parse_cmd_update(struct ref_transaction *transaction, |
181 | struct strbuf *input, const char *next) | |
c750ba95 | 182 | { |
ab5ac957 | 183 | struct strbuf err = STRBUF_INIT; |
aebfc133 | 184 | char *refname; |
a0bb5535 | 185 | struct object_id new_oid, old_oid; |
aebfc133 | 186 | int have_old; |
c750ba95 | 187 | |
aebfc133 MH |
188 | refname = parse_refname(input, &next); |
189 | if (!refname) | |
f11b09fb | 190 | die("update: missing <ref>"); |
c750ba95 | 191 | |
a0bb5535 | 192 | if (parse_next_oid(input, &next, &new_oid, "update", refname, |
193 | PARSE_SHA1_ALLOW_EMPTY)) | |
aebfc133 | 194 | die("update %s: missing <newvalue>", refname); |
c750ba95 | 195 | |
a0bb5535 | 196 | have_old = !parse_next_oid(input, &next, &old_oid, "update", refname, |
197 | PARSE_SHA1_OLD); | |
3afcc463 MH |
198 | |
199 | if (*next != line_termination) | |
aebfc133 MH |
200 | die("update %s: extra input: %s", refname, next); |
201 | ||
1d147bdf | 202 | if (ref_transaction_update(transaction, refname, |
89f3bbdd | 203 | &new_oid, have_old ? &old_oid : NULL, |
144c76fa DT |
204 | update_flags | create_reflog_flag, |
205 | msg, &err)) | |
8e34800e | 206 | die("%s", err.buf); |
aebfc133 MH |
207 | |
208 | update_flags = 0; | |
209 | free(refname); | |
ab5ac957 | 210 | strbuf_release(&err); |
c750ba95 | 211 | |
e23d8435 | 212 | return next; |
c750ba95 BK |
213 | } |
214 | ||
88499b29 JN |
215 | static const char *parse_cmd_create(struct ref_transaction *transaction, |
216 | struct strbuf *input, const char *next) | |
c750ba95 | 217 | { |
ab5ac957 | 218 | struct strbuf err = STRBUF_INIT; |
aebfc133 | 219 | char *refname; |
a0bb5535 | 220 | struct object_id new_oid; |
c750ba95 | 221 | |
aebfc133 MH |
222 | refname = parse_refname(input, &next); |
223 | if (!refname) | |
f11b09fb | 224 | die("create: missing <ref>"); |
c750ba95 | 225 | |
a0bb5535 | 226 | if (parse_next_oid(input, &next, &new_oid, "create", refname, 0)) |
aebfc133 | 227 | die("create %s: missing <newvalue>", refname); |
e23d8435 | 228 | |
a0bb5535 | 229 | if (is_null_oid(&new_oid)) |
aebfc133 | 230 | die("create %s: zero <newvalue>", refname); |
c750ba95 | 231 | |
e23d8435 | 232 | if (*next != line_termination) |
aebfc133 MH |
233 | die("create %s: extra input: %s", refname, next); |
234 | ||
89f3bbdd | 235 | if (ref_transaction_create(transaction, refname, &new_oid, |
144c76fa DT |
236 | update_flags | create_reflog_flag, |
237 | msg, &err)) | |
b416af5b | 238 | die("%s", err.buf); |
aebfc133 MH |
239 | |
240 | update_flags = 0; | |
241 | free(refname); | |
ab5ac957 | 242 | strbuf_release(&err); |
e23d8435 MH |
243 | |
244 | return next; | |
c750ba95 BK |
245 | } |
246 | ||
88499b29 JN |
247 | static const char *parse_cmd_delete(struct ref_transaction *transaction, |
248 | struct strbuf *input, const char *next) | |
c750ba95 | 249 | { |
ab5ac957 | 250 | struct strbuf err = STRBUF_INIT; |
aebfc133 | 251 | char *refname; |
a0bb5535 | 252 | struct object_id old_oid; |
aebfc133 | 253 | int have_old; |
c750ba95 | 254 | |
aebfc133 MH |
255 | refname = parse_refname(input, &next); |
256 | if (!refname) | |
f11b09fb | 257 | die("delete: missing <ref>"); |
c750ba95 | 258 | |
a0bb5535 | 259 | if (parse_next_oid(input, &next, &old_oid, "delete", refname, |
260 | PARSE_SHA1_OLD)) { | |
aebfc133 | 261 | have_old = 0; |
3afcc463 | 262 | } else { |
a0bb5535 | 263 | if (is_null_oid(&old_oid)) |
aebfc133 MH |
264 | die("delete %s: zero <oldvalue>", refname); |
265 | have_old = 1; | |
3afcc463 | 266 | } |
c750ba95 | 267 | |
e23d8435 | 268 | if (*next != line_termination) |
aebfc133 MH |
269 | die("delete %s: extra input: %s", refname, next); |
270 | ||
fb5a6bb6 | 271 | if (ref_transaction_delete(transaction, refname, |
89f3bbdd | 272 | have_old ? &old_oid : NULL, |
fb5a6bb6 | 273 | update_flags, msg, &err)) |
8c8bdc0d | 274 | die("%s", err.buf); |
aebfc133 MH |
275 | |
276 | update_flags = 0; | |
277 | free(refname); | |
ab5ac957 | 278 | strbuf_release(&err); |
e23d8435 MH |
279 | |
280 | return next; | |
c750ba95 BK |
281 | } |
282 | ||
88499b29 JN |
283 | static const char *parse_cmd_verify(struct ref_transaction *transaction, |
284 | struct strbuf *input, const char *next) | |
c750ba95 | 285 | { |
ab5ac957 | 286 | struct strbuf err = STRBUF_INIT; |
aebfc133 | 287 | char *refname; |
a0bb5535 | 288 | struct object_id old_oid; |
c750ba95 | 289 | |
aebfc133 MH |
290 | refname = parse_refname(input, &next); |
291 | if (!refname) | |
f11b09fb | 292 | die("verify: missing <ref>"); |
c750ba95 | 293 | |
a0bb5535 | 294 | if (parse_next_oid(input, &next, &old_oid, "verify", refname, |
295 | PARSE_SHA1_OLD)) | |
296 | oidclr(&old_oid); | |
0e729c7e | 297 | |
e23d8435 | 298 | if (*next != line_termination) |
aebfc133 MH |
299 | die("verify %s: extra input: %s", refname, next); |
300 | ||
89f3bbdd | 301 | if (ref_transaction_verify(transaction, refname, &old_oid, |
16180334 | 302 | update_flags, &err)) |
8e34800e | 303 | die("%s", err.buf); |
aebfc133 MH |
304 | |
305 | update_flags = 0; | |
306 | free(refname); | |
ab5ac957 | 307 | strbuf_release(&err); |
e23d8435 MH |
308 | |
309 | return next; | |
c750ba95 BK |
310 | } |
311 | ||
e23d8435 | 312 | static const char *parse_cmd_option(struct strbuf *input, const char *next) |
c750ba95 | 313 | { |
e23d8435 | 314 | if (!strncmp(next, "no-deref", 8) && next[8] == line_termination) |
91774afc | 315 | update_flags |= REF_NO_DEREF; |
c750ba95 BK |
316 | else |
317 | die("option unknown: %s", next); | |
e23d8435 | 318 | return next + 8; |
c750ba95 BK |
319 | } |
320 | ||
88499b29 | 321 | static void update_refs_stdin(struct ref_transaction *transaction) |
c750ba95 | 322 | { |
e23d8435 MH |
323 | struct strbuf input = STRBUF_INIT; |
324 | const char *next; | |
c750ba95 | 325 | |
e23d8435 MH |
326 | if (strbuf_read(&input, 0, 1000) < 0) |
327 | die_errno("could not read from stdin"); | |
328 | next = input.buf; | |
c750ba95 | 329 | /* Read each line dispatch its command */ |
e23d8435 MH |
330 | while (next < input.buf + input.len) { |
331 | if (*next == line_termination) | |
c750ba95 | 332 | die("empty command in input"); |
e23d8435 MH |
333 | else if (isspace(*next)) |
334 | die("whitespace before command: %s", next); | |
335 | else if (starts_with(next, "update ")) | |
88499b29 | 336 | next = parse_cmd_update(transaction, &input, next + 7); |
e23d8435 | 337 | else if (starts_with(next, "create ")) |
88499b29 | 338 | next = parse_cmd_create(transaction, &input, next + 7); |
e23d8435 | 339 | else if (starts_with(next, "delete ")) |
88499b29 | 340 | next = parse_cmd_delete(transaction, &input, next + 7); |
e23d8435 | 341 | else if (starts_with(next, "verify ")) |
88499b29 | 342 | next = parse_cmd_verify(transaction, &input, next + 7); |
e23d8435 MH |
343 | else if (starts_with(next, "option ")) |
344 | next = parse_cmd_option(&input, next + 7); | |
c750ba95 | 345 | else |
e23d8435 MH |
346 | die("unknown command: %s", next); |
347 | ||
348 | next++; | |
349 | } | |
c750ba95 | 350 | |
e23d8435 | 351 | strbuf_release(&input); |
c750ba95 BK |
352 | } |
353 | ||
a633fca0 | 354 | int cmd_update_ref(int argc, const char **argv, const char *prefix) |
66bf85a4 | 355 | { |
db7516ab | 356 | const char *refname, *oldval; |
a0bb5535 | 357 | struct object_id oid, oldoid; |
fec14ec3 MH |
358 | int delete = 0, no_deref = 0, read_stdin = 0, end_null = 0; |
359 | unsigned int flags = 0; | |
144c76fa | 360 | int create_reflog = 0; |
89942be6 | 361 | struct option options[] = { |
82269505 | 362 | OPT_STRING( 'm', NULL, &msg, N_("reason"), N_("reason of the update")), |
d5d09d47 SB |
363 | OPT_BOOL('d', NULL, &delete, N_("delete the reference")), |
364 | OPT_BOOL( 0 , "no-deref", &no_deref, | |
82269505 | 365 | N_("update <refname> not the one it points to")), |
9a86b899 JH |
366 | OPT_BOOL('z', NULL, &end_null, N_("stdin has NUL-terminated arguments")), |
367 | OPT_BOOL( 0 , "stdin", &read_stdin, N_("read updates from stdin")), | |
98c32bd8 | 368 | OPT_BOOL( 0 , "create-reflog", &create_reflog, N_("create a reflog")), |
89942be6 PH |
369 | OPT_END(), |
370 | }; | |
66bf85a4 | 371 | |
ef90d6d4 | 372 | git_config(git_default_config, NULL); |
37782920 SB |
373 | argc = parse_options(argc, argv, prefix, options, git_update_ref_usage, |
374 | 0); | |
89942be6 PH |
375 | if (msg && !*msg) |
376 | die("Refusing to perform update with empty message."); | |
5b16b090 | 377 | |
144c76fa DT |
378 | create_reflog_flag = create_reflog ? REF_FORCE_CREATE_REFLOG : 0; |
379 | ||
c750ba95 | 380 | if (read_stdin) { |
ab5ac957 | 381 | struct strbuf err = STRBUF_INIT; |
88499b29 | 382 | struct ref_transaction *transaction; |
ab5ac957 | 383 | |
93a644ea RS |
384 | transaction = ref_transaction_begin(&err); |
385 | if (!transaction) | |
386 | die("%s", err.buf); | |
c750ba95 BK |
387 | if (delete || no_deref || argc > 0) |
388 | usage_with_options(git_update_ref_usage, options); | |
389 | if (end_null) | |
390 | line_termination = '\0'; | |
88499b29 | 391 | update_refs_stdin(transaction); |
db7516ab | 392 | if (ref_transaction_commit(transaction, &err)) |
8bcd3748 | 393 | die("%s", err.buf); |
33f9fc59 | 394 | ref_transaction_free(transaction); |
93a644ea | 395 | strbuf_release(&err); |
8bcd3748 | 396 | return 0; |
c750ba95 BK |
397 | } |
398 | ||
399 | if (end_null) | |
400 | usage_with_options(git_update_ref_usage, options); | |
401 | ||
ac5409e4 | 402 | if (delete) { |
3fe8dce6 | 403 | if (argc < 1 || argc > 2) |
973a70ea KW |
404 | usage_with_options(git_update_ref_usage, options); |
405 | refname = argv[0]; | |
406 | oldval = argv[1]; | |
407 | } else { | |
408 | const char *value; | |
409 | if (argc < 2 || argc > 3) | |
89942be6 | 410 | usage_with_options(git_update_ref_usage, options); |
973a70ea KW |
411 | refname = argv[0]; |
412 | value = argv[1]; | |
413 | oldval = argv[2]; | |
a0bb5535 | 414 | if (get_oid(value, &oid)) |
973a70ea | 415 | die("%s: not a valid SHA1", value); |
ac5409e4 JH |
416 | } |
417 | ||
e2991c80 MH |
418 | if (oldval) { |
419 | if (!*oldval) | |
420 | /* | |
421 | * The empty string implies that the reference | |
422 | * must not already exist: | |
423 | */ | |
a0bb5535 | 424 | oidclr(&oldoid); |
425 | else if (get_oid(oldval, &oldoid)) | |
e2991c80 MH |
426 | die("%s: not a valid old SHA1", oldval); |
427 | } | |
66bf85a4 | 428 | |
569740bd | 429 | if (no_deref) |
91774afc | 430 | flags = REF_NO_DEREF; |
973a70ea | 431 | if (delete) |
1c03c4d3 MH |
432 | /* |
433 | * For purposes of backwards compatibility, we treat | |
434 | * NULL_SHA1 as "don't care" here: | |
435 | */ | |
de922669 | 436 | return delete_ref(msg, refname, |
2616a5e5 | 437 | (oldval && !is_null_oid(&oldoid)) ? &oldoid : NULL, |
1c03c4d3 | 438 | flags); |
973a70ea | 439 | else |
ae077771 | 440 | return update_ref(msg, refname, &oid, oldval ? &oldoid : NULL, |
144c76fa DT |
441 | flags | create_reflog_flag, |
442 | UPDATE_REFS_DIE_ON_ERR); | |
66bf85a4 | 443 | } |