]>
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 | 6 | #include "quote.h" |
dbbcd44f | 7 | #include "strvec.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 | 16 | static char line_termination = '\n'; |
e4c34855 | 17 | static unsigned int update_flags; |
d345e9fb | 18 | static unsigned int default_flags; |
144c76fa | 19 | static unsigned create_reflog_flag; |
db7516ab | 20 | static const char *msg; |
c750ba95 | 21 | |
697a4151 MH |
22 | /* |
23 | * Parse one whitespace- or NUL-terminated, possibly C-quoted argument | |
24 | * and append the result to arg. Return a pointer to the terminator. | |
25 | * Die if there is an error in how the argument is C-quoted. This | |
26 | * function is only used if not -z. | |
27 | */ | |
c750ba95 BK |
28 | static const char *parse_arg(const char *next, struct strbuf *arg) |
29 | { | |
697a4151 MH |
30 | if (*next == '"') { |
31 | const char *orig = next; | |
32 | ||
33 | if (unquote_c_style(arg, next, &next)) | |
34 | die("badly quoted argument: %s", orig); | |
35 | if (*next && !isspace(*next)) | |
36 | die("unexpected character after quoted argument: %s", orig); | |
37 | } else { | |
c750ba95 BK |
38 | while (*next && !isspace(*next)) |
39 | strbuf_addch(arg, *next++); | |
697a4151 | 40 | } |
c750ba95 | 41 | |
c750ba95 BK |
42 | return next; |
43 | } | |
44 | ||
e23d8435 | 45 | /* |
ed410e61 MH |
46 | * Parse the reference name immediately after "command SP". If not |
47 | * -z, then handle C-quoting. Return a pointer to a newly allocated | |
48 | * string containing the name of the reference, or NULL if there was | |
49 | * an error. Update *next to point at the character that terminates | |
50 | * the argument. Die if C-quoting is malformed or the reference name | |
51 | * is invalid. | |
e23d8435 | 52 | */ |
5ae6c5a7 | 53 | static char *parse_refname(const char **next) |
c750ba95 | 54 | { |
ed410e61 MH |
55 | struct strbuf ref = STRBUF_INIT; |
56 | ||
c750ba95 BK |
57 | if (line_termination) { |
58 | /* Without -z, use the next argument */ | |
ed410e61 | 59 | *next = parse_arg(*next, &ref); |
c750ba95 | 60 | } else { |
e23d8435 | 61 | /* With -z, use everything up to the next NUL */ |
ed410e61 MH |
62 | strbuf_addstr(&ref, *next); |
63 | *next += ref.len; | |
64 | } | |
65 | ||
66 | if (!ref.len) { | |
67 | strbuf_release(&ref); | |
68 | return NULL; | |
c750ba95 | 69 | } |
ed410e61 MH |
70 | |
71 | if (check_refname_format(ref.buf, REFNAME_ALLOW_ONELEVEL)) | |
72 | die("invalid ref format: %s", ref.buf); | |
73 | ||
74 | return strbuf_detach(&ref, NULL); | |
c750ba95 BK |
75 | } |
76 | ||
e23d8435 | 77 | /* |
3afcc463 MH |
78 | * The value being parsed is <oldvalue> (as opposed to <newvalue>; the |
79 | * difference affects which error messages are generated): | |
80 | */ | |
81 | #define PARSE_SHA1_OLD 0x01 | |
82 | ||
83 | /* | |
84 | * For backwards compatibility, accept an empty string for update's | |
85 | * <newvalue> in binary mode to be equivalent to specifying zeros. | |
86 | */ | |
87 | #define PARSE_SHA1_ALLOW_EMPTY 0x02 | |
88 | ||
89 | /* | |
90 | * Parse an argument separator followed by the next argument, if any. | |
91 | * If there is an argument, convert it to a SHA-1, write it to sha1, | |
92 | * set *next to point at the character terminating the argument, and | |
e23d8435 | 93 | * return 0. If there is no argument at all (not even the empty |
3afcc463 MH |
94 | * string), return 1 and leave *next unchanged. If the value is |
95 | * provided but cannot be converted to a SHA-1, die. flags can | |
96 | * include PARSE_SHA1_OLD and/or PARSE_SHA1_ALLOW_EMPTY. | |
e23d8435 | 97 | */ |
804dba54 | 98 | static int parse_next_oid(const char **next, const char *end, |
a0bb5535 | 99 | struct object_id *oid, |
100 | const char *command, const char *refname, | |
101 | int flags) | |
c750ba95 | 102 | { |
3afcc463 MH |
103 | struct strbuf arg = STRBUF_INIT; |
104 | int ret = 0; | |
105 | ||
804dba54 | 106 | if (*next == end) |
3afcc463 MH |
107 | goto eof; |
108 | ||
c750ba95 BK |
109 | if (line_termination) { |
110 | /* Without -z, consume SP and use next argument */ | |
e23d8435 | 111 | if (!**next || **next == line_termination) |
3afcc463 | 112 | return 1; |
e23d8435 | 113 | if (**next != ' ') |
3afcc463 MH |
114 | die("%s %s: expected SP but got: %s", |
115 | command, refname, *next); | |
e23d8435 | 116 | (*next)++; |
3afcc463 MH |
117 | *next = parse_arg(*next, &arg); |
118 | if (arg.len) { | |
a0bb5535 | 119 | if (get_oid(arg.buf, oid)) |
3afcc463 MH |
120 | goto invalid; |
121 | } else { | |
122 | /* Without -z, an empty value means all zeros: */ | |
a0bb5535 | 123 | oidclr(oid); |
3afcc463 | 124 | } |
c750ba95 BK |
125 | } else { |
126 | /* With -z, read the next NUL-terminated line */ | |
e23d8435 | 127 | if (**next) |
3afcc463 MH |
128 | die("%s %s: expected NUL but got: %s", |
129 | command, refname, *next); | |
e23d8435 | 130 | (*next)++; |
804dba54 | 131 | if (*next == end) |
3afcc463 MH |
132 | goto eof; |
133 | strbuf_addstr(&arg, *next); | |
134 | *next += arg.len; | |
135 | ||
136 | if (arg.len) { | |
a0bb5535 | 137 | if (get_oid(arg.buf, oid)) |
3afcc463 MH |
138 | goto invalid; |
139 | } else if (flags & PARSE_SHA1_ALLOW_EMPTY) { | |
140 | /* With -z, treat an empty value as all zeros: */ | |
1fbd5049 MH |
141 | warning("%s %s: missing <newvalue>, treating as zero", |
142 | command, refname); | |
a0bb5535 | 143 | oidclr(oid); |
3afcc463 MH |
144 | } else { |
145 | /* | |
146 | * With -z, an empty non-required value means | |
147 | * unspecified: | |
148 | */ | |
149 | ret = 1; | |
150 | } | |
c750ba95 | 151 | } |
3afcc463 MH |
152 | |
153 | strbuf_release(&arg); | |
154 | ||
155 | return ret; | |
156 | ||
157 | invalid: | |
158 | die(flags & PARSE_SHA1_OLD ? | |
159 | "%s %s: invalid <oldvalue>: %s" : | |
160 | "%s %s: invalid <newvalue>: %s", | |
161 | command, refname, arg.buf); | |
162 | ||
163 | eof: | |
164 | die(flags & PARSE_SHA1_OLD ? | |
726f6916 MH |
165 | "%s %s: unexpected end of input when reading <oldvalue>" : |
166 | "%s %s: unexpected end of input when reading <newvalue>", | |
3afcc463 | 167 | command, refname); |
c750ba95 BK |
168 | } |
169 | ||
e23d8435 MH |
170 | |
171 | /* | |
172 | * The following five parse_cmd_*() functions parse the corresponding | |
173 | * command. In each case, next points at the character following the | |
174 | * command name and the following space. They each return a pointer | |
175 | * to the character terminating the command, and die with an | |
176 | * explanatory message if there are any parsing problems. All of | |
177 | * these functions handle either text or binary format input, | |
178 | * depending on how line_termination is set. | |
179 | */ | |
180 | ||
94fd491a PS |
181 | static void parse_cmd_update(struct ref_transaction *transaction, |
182 | const char *next, const char *end) | |
c750ba95 | 183 | { |
ab5ac957 | 184 | struct strbuf err = STRBUF_INIT; |
aebfc133 | 185 | char *refname; |
a0bb5535 | 186 | struct object_id new_oid, old_oid; |
aebfc133 | 187 | int have_old; |
c750ba95 | 188 | |
5ae6c5a7 | 189 | refname = parse_refname(&next); |
aebfc133 | 190 | if (!refname) |
f11b09fb | 191 | die("update: missing <ref>"); |
c750ba95 | 192 | |
804dba54 | 193 | if (parse_next_oid(&next, end, &new_oid, "update", refname, |
a0bb5535 | 194 | PARSE_SHA1_ALLOW_EMPTY)) |
aebfc133 | 195 | die("update %s: missing <newvalue>", refname); |
c750ba95 | 196 | |
804dba54 | 197 | have_old = !parse_next_oid(&next, end, &old_oid, "update", refname, |
a0bb5535 | 198 | PARSE_SHA1_OLD); |
3afcc463 MH |
199 | |
200 | if (*next != line_termination) | |
aebfc133 MH |
201 | die("update %s: extra input: %s", refname, next); |
202 | ||
1d147bdf | 203 | if (ref_transaction_update(transaction, refname, |
89f3bbdd | 204 | &new_oid, have_old ? &old_oid : NULL, |
144c76fa DT |
205 | update_flags | create_reflog_flag, |
206 | msg, &err)) | |
8e34800e | 207 | die("%s", err.buf); |
aebfc133 | 208 | |
d345e9fb | 209 | update_flags = default_flags; |
aebfc133 | 210 | free(refname); |
ab5ac957 | 211 | strbuf_release(&err); |
c750ba95 BK |
212 | } |
213 | ||
94fd491a PS |
214 | static void parse_cmd_create(struct ref_transaction *transaction, |
215 | const char *next, const char *end) | |
c750ba95 | 216 | { |
ab5ac957 | 217 | struct strbuf err = STRBUF_INIT; |
aebfc133 | 218 | char *refname; |
a0bb5535 | 219 | struct object_id new_oid; |
c750ba95 | 220 | |
5ae6c5a7 | 221 | refname = parse_refname(&next); |
aebfc133 | 222 | if (!refname) |
f11b09fb | 223 | die("create: missing <ref>"); |
c750ba95 | 224 | |
804dba54 | 225 | if (parse_next_oid(&next, end, &new_oid, "create", refname, 0)) |
aebfc133 | 226 | die("create %s: missing <newvalue>", refname); |
e23d8435 | 227 | |
a0bb5535 | 228 | if (is_null_oid(&new_oid)) |
aebfc133 | 229 | die("create %s: zero <newvalue>", refname); |
c750ba95 | 230 | |
e23d8435 | 231 | if (*next != line_termination) |
aebfc133 MH |
232 | die("create %s: extra input: %s", refname, next); |
233 | ||
89f3bbdd | 234 | if (ref_transaction_create(transaction, refname, &new_oid, |
144c76fa DT |
235 | update_flags | create_reflog_flag, |
236 | msg, &err)) | |
b416af5b | 237 | die("%s", err.buf); |
aebfc133 | 238 | |
d345e9fb | 239 | update_flags = default_flags; |
aebfc133 | 240 | free(refname); |
ab5ac957 | 241 | strbuf_release(&err); |
c750ba95 BK |
242 | } |
243 | ||
94fd491a PS |
244 | static void parse_cmd_delete(struct ref_transaction *transaction, |
245 | const char *next, const char *end) | |
c750ba95 | 246 | { |
ab5ac957 | 247 | struct strbuf err = STRBUF_INIT; |
aebfc133 | 248 | char *refname; |
a0bb5535 | 249 | struct object_id old_oid; |
aebfc133 | 250 | int have_old; |
c750ba95 | 251 | |
5ae6c5a7 | 252 | refname = parse_refname(&next); |
aebfc133 | 253 | if (!refname) |
f11b09fb | 254 | die("delete: missing <ref>"); |
c750ba95 | 255 | |
804dba54 | 256 | if (parse_next_oid(&next, end, &old_oid, "delete", refname, |
a0bb5535 | 257 | PARSE_SHA1_OLD)) { |
aebfc133 | 258 | have_old = 0; |
3afcc463 | 259 | } else { |
a0bb5535 | 260 | if (is_null_oid(&old_oid)) |
aebfc133 MH |
261 | die("delete %s: zero <oldvalue>", refname); |
262 | have_old = 1; | |
3afcc463 | 263 | } |
c750ba95 | 264 | |
e23d8435 | 265 | if (*next != line_termination) |
aebfc133 MH |
266 | die("delete %s: extra input: %s", refname, next); |
267 | ||
fb5a6bb6 | 268 | if (ref_transaction_delete(transaction, refname, |
89f3bbdd | 269 | have_old ? &old_oid : NULL, |
fb5a6bb6 | 270 | update_flags, msg, &err)) |
8c8bdc0d | 271 | die("%s", err.buf); |
aebfc133 | 272 | |
d345e9fb | 273 | update_flags = default_flags; |
aebfc133 | 274 | free(refname); |
ab5ac957 | 275 | strbuf_release(&err); |
c750ba95 BK |
276 | } |
277 | ||
94fd491a PS |
278 | static void parse_cmd_verify(struct ref_transaction *transaction, |
279 | const char *next, const char *end) | |
c750ba95 | 280 | { |
ab5ac957 | 281 | struct strbuf err = STRBUF_INIT; |
aebfc133 | 282 | char *refname; |
a0bb5535 | 283 | struct object_id old_oid; |
c750ba95 | 284 | |
5ae6c5a7 | 285 | refname = parse_refname(&next); |
aebfc133 | 286 | if (!refname) |
f11b09fb | 287 | die("verify: missing <ref>"); |
c750ba95 | 288 | |
804dba54 | 289 | if (parse_next_oid(&next, end, &old_oid, "verify", refname, |
a0bb5535 | 290 | PARSE_SHA1_OLD)) |
291 | oidclr(&old_oid); | |
0e729c7e | 292 | |
e23d8435 | 293 | if (*next != line_termination) |
aebfc133 MH |
294 | die("verify %s: extra input: %s", refname, next); |
295 | ||
89f3bbdd | 296 | if (ref_transaction_verify(transaction, refname, &old_oid, |
16180334 | 297 | update_flags, &err)) |
8e34800e | 298 | die("%s", err.buf); |
aebfc133 | 299 | |
d345e9fb | 300 | update_flags = default_flags; |
aebfc133 | 301 | free(refname); |
ab5ac957 | 302 | strbuf_release(&err); |
c750ba95 BK |
303 | } |
304 | ||
94fd491a PS |
305 | static void parse_cmd_option(struct ref_transaction *transaction, |
306 | const char *next, const char *end) | |
c750ba95 | 307 | { |
aee9be2e SG |
308 | const char *rest; |
309 | if (skip_prefix(next, "no-deref", &rest) && *rest == line_termination) | |
91774afc | 310 | update_flags |= REF_NO_DEREF; |
c750ba95 BK |
311 | else |
312 | die("option unknown: %s", next); | |
313 | } | |
314 | ||
e48cf33b PS |
315 | static void parse_cmd_start(struct ref_transaction *transaction, |
316 | const char *next, const char *end) | |
317 | { | |
318 | if (*next != line_termination) | |
319 | die("start: extra input: %s", next); | |
320 | puts("start: ok"); | |
321 | } | |
322 | ||
323 | static void parse_cmd_prepare(struct ref_transaction *transaction, | |
324 | const char *next, const char *end) | |
325 | { | |
326 | struct strbuf error = STRBUF_INIT; | |
327 | if (*next != line_termination) | |
328 | die("prepare: extra input: %s", next); | |
329 | if (ref_transaction_prepare(transaction, &error)) | |
330 | die("prepare: %s", error.buf); | |
331 | puts("prepare: ok"); | |
332 | } | |
333 | ||
334 | static void parse_cmd_abort(struct ref_transaction *transaction, | |
335 | const char *next, const char *end) | |
336 | { | |
337 | struct strbuf error = STRBUF_INIT; | |
338 | if (*next != line_termination) | |
339 | die("abort: extra input: %s", next); | |
340 | if (ref_transaction_abort(transaction, &error)) | |
341 | die("abort: %s", error.buf); | |
342 | puts("abort: ok"); | |
343 | } | |
344 | ||
345 | static void parse_cmd_commit(struct ref_transaction *transaction, | |
346 | const char *next, const char *end) | |
347 | { | |
348 | struct strbuf error = STRBUF_INIT; | |
349 | if (*next != line_termination) | |
350 | die("commit: extra input: %s", next); | |
351 | if (ref_transaction_commit(transaction, &error)) | |
352 | die("commit: %s", error.buf); | |
353 | puts("commit: ok"); | |
354 | ref_transaction_free(transaction); | |
355 | } | |
356 | ||
357 | enum update_refs_state { | |
358 | /* Non-transactional state open for updates. */ | |
359 | UPDATE_REFS_OPEN, | |
360 | /* A transaction has been started. */ | |
361 | UPDATE_REFS_STARTED, | |
362 | /* References are locked and ready for commit */ | |
363 | UPDATE_REFS_PREPARED, | |
364 | /* Transaction has been committed or closed. */ | |
365 | UPDATE_REFS_CLOSED, | |
366 | }; | |
367 | ||
a65b8ac2 PS |
368 | static const struct parse_cmd { |
369 | const char *prefix; | |
94fd491a PS |
370 | void (*fn)(struct ref_transaction *, const char *, const char *); |
371 | unsigned args; | |
e48cf33b | 372 | enum update_refs_state state; |
a65b8ac2 | 373 | } command[] = { |
e48cf33b PS |
374 | { "update", parse_cmd_update, 3, UPDATE_REFS_OPEN }, |
375 | { "create", parse_cmd_create, 2, UPDATE_REFS_OPEN }, | |
376 | { "delete", parse_cmd_delete, 2, UPDATE_REFS_OPEN }, | |
377 | { "verify", parse_cmd_verify, 2, UPDATE_REFS_OPEN }, | |
378 | { "option", parse_cmd_option, 1, UPDATE_REFS_OPEN }, | |
379 | { "start", parse_cmd_start, 0, UPDATE_REFS_STARTED }, | |
380 | { "prepare", parse_cmd_prepare, 0, UPDATE_REFS_PREPARED }, | |
381 | { "abort", parse_cmd_abort, 0, UPDATE_REFS_CLOSED }, | |
382 | { "commit", parse_cmd_commit, 0, UPDATE_REFS_CLOSED }, | |
a65b8ac2 PS |
383 | }; |
384 | ||
de0e0d65 | 385 | static void update_refs_stdin(void) |
c750ba95 | 386 | { |
de0e0d65 | 387 | struct strbuf input = STRBUF_INIT, err = STRBUF_INIT; |
e48cf33b | 388 | enum update_refs_state state = UPDATE_REFS_OPEN; |
de0e0d65 | 389 | struct ref_transaction *transaction; |
94fd491a | 390 | int i, j; |
de0e0d65 PS |
391 | |
392 | transaction = ref_transaction_begin(&err); | |
393 | if (!transaction) | |
394 | die("%s", err.buf); | |
395 | ||
c750ba95 | 396 | /* Read each line dispatch its command */ |
94fd491a | 397 | while (!strbuf_getwholeline(&input, stdin, line_termination)) { |
a65b8ac2 PS |
398 | const struct parse_cmd *cmd = NULL; |
399 | ||
94fd491a | 400 | if (*input.buf == line_termination) |
c750ba95 | 401 | die("empty command in input"); |
94fd491a PS |
402 | else if (isspace(*input.buf)) |
403 | die("whitespace before command: %s", input.buf); | |
a65b8ac2 PS |
404 | |
405 | for (i = 0; i < ARRAY_SIZE(command); i++) { | |
406 | const char *prefix = command[i].prefix; | |
94fd491a | 407 | char c; |
a65b8ac2 | 408 | |
94fd491a PS |
409 | if (!starts_with(input.buf, prefix)) |
410 | continue; | |
411 | ||
412 | /* | |
413 | * If the command has arguments, verify that it's | |
414 | * followed by a space. Otherwise, it shall be followed | |
415 | * by a line terminator. | |
416 | */ | |
417 | c = command[i].args ? ' ' : line_termination; | |
418 | if (input.buf[strlen(prefix)] != c) | |
a65b8ac2 PS |
419 | continue; |
420 | ||
421 | cmd = &command[i]; | |
422 | break; | |
423 | } | |
424 | if (!cmd) | |
94fd491a PS |
425 | die("unknown command: %s", input.buf); |
426 | ||
427 | /* | |
428 | * Read additional arguments if NUL-terminated. Do not raise an | |
429 | * error in case there is an early EOF to let the command | |
430 | * handle missing arguments with a proper error message. | |
431 | */ | |
432 | for (j = 1; line_termination == '\0' && j < cmd->args; j++) | |
433 | if (strbuf_appendwholeline(&input, stdin, line_termination)) | |
434 | break; | |
435 | ||
e48cf33b PS |
436 | switch (state) { |
437 | case UPDATE_REFS_OPEN: | |
438 | case UPDATE_REFS_STARTED: | |
439 | /* Do not downgrade a transaction to a non-transaction. */ | |
440 | if (cmd->state >= state) | |
441 | state = cmd->state; | |
442 | break; | |
443 | case UPDATE_REFS_PREPARED: | |
444 | if (cmd->state != UPDATE_REFS_CLOSED) | |
445 | die("prepared transactions can only be closed"); | |
446 | state = cmd->state; | |
447 | break; | |
448 | case UPDATE_REFS_CLOSED: | |
449 | die("transaction is closed"); | |
450 | break; | |
451 | } | |
452 | ||
94fd491a PS |
453 | cmd->fn(transaction, input.buf + strlen(cmd->prefix) + !!cmd->args, |
454 | input.buf + input.len); | |
e23d8435 | 455 | } |
c750ba95 | 456 | |
e48cf33b PS |
457 | switch (state) { |
458 | case UPDATE_REFS_OPEN: | |
459 | /* Commit by default if no transaction was requested. */ | |
460 | if (ref_transaction_commit(transaction, &err)) | |
461 | die("%s", err.buf); | |
462 | ref_transaction_free(transaction); | |
463 | break; | |
464 | case UPDATE_REFS_STARTED: | |
465 | case UPDATE_REFS_PREPARED: | |
466 | /* If using a transaction, we want to abort it. */ | |
467 | if (ref_transaction_abort(transaction, &err)) | |
468 | die("%s", err.buf); | |
469 | break; | |
470 | case UPDATE_REFS_CLOSED: | |
471 | /* Otherwise no need to do anything, the transaction was closed already. */ | |
472 | break; | |
473 | } | |
de0e0d65 | 474 | |
de0e0d65 | 475 | strbuf_release(&err); |
e23d8435 | 476 | strbuf_release(&input); |
c750ba95 BK |
477 | } |
478 | ||
a633fca0 | 479 | int cmd_update_ref(int argc, const char **argv, const char *prefix) |
66bf85a4 | 480 | { |
db7516ab | 481 | const char *refname, *oldval; |
a0bb5535 | 482 | struct object_id oid, oldoid; |
fec14ec3 | 483 | int delete = 0, no_deref = 0, read_stdin = 0, end_null = 0; |
144c76fa | 484 | int create_reflog = 0; |
89942be6 | 485 | struct option options[] = { |
82269505 | 486 | OPT_STRING( 'm', NULL, &msg, N_("reason"), N_("reason of the update")), |
d5d09d47 SB |
487 | OPT_BOOL('d', NULL, &delete, N_("delete the reference")), |
488 | OPT_BOOL( 0 , "no-deref", &no_deref, | |
82269505 | 489 | N_("update <refname> not the one it points to")), |
9a86b899 JH |
490 | OPT_BOOL('z', NULL, &end_null, N_("stdin has NUL-terminated arguments")), |
491 | OPT_BOOL( 0 , "stdin", &read_stdin, N_("read updates from stdin")), | |
98c32bd8 | 492 | OPT_BOOL( 0 , "create-reflog", &create_reflog, N_("create a reflog")), |
89942be6 PH |
493 | OPT_END(), |
494 | }; | |
66bf85a4 | 495 | |
ef90d6d4 | 496 | git_config(git_default_config, NULL); |
37782920 SB |
497 | argc = parse_options(argc, argv, prefix, options, git_update_ref_usage, |
498 | 0); | |
89942be6 PH |
499 | if (msg && !*msg) |
500 | die("Refusing to perform update with empty message."); | |
5b16b090 | 501 | |
144c76fa DT |
502 | create_reflog_flag = create_reflog ? REF_FORCE_CREATE_REFLOG : 0; |
503 | ||
d345e9fb EN |
504 | if (no_deref) { |
505 | default_flags = REF_NO_DEREF; | |
506 | update_flags = default_flags; | |
507 | } | |
508 | ||
c750ba95 | 509 | if (read_stdin) { |
d345e9fb | 510 | if (delete || argc > 0) |
c750ba95 BK |
511 | usage_with_options(git_update_ref_usage, options); |
512 | if (end_null) | |
513 | line_termination = '\0'; | |
de0e0d65 | 514 | update_refs_stdin(); |
8bcd3748 | 515 | return 0; |
c750ba95 BK |
516 | } |
517 | ||
518 | if (end_null) | |
519 | usage_with_options(git_update_ref_usage, options); | |
520 | ||
ac5409e4 | 521 | if (delete) { |
3fe8dce6 | 522 | if (argc < 1 || argc > 2) |
973a70ea KW |
523 | usage_with_options(git_update_ref_usage, options); |
524 | refname = argv[0]; | |
525 | oldval = argv[1]; | |
526 | } else { | |
527 | const char *value; | |
528 | if (argc < 2 || argc > 3) | |
89942be6 | 529 | usage_with_options(git_update_ref_usage, options); |
973a70ea KW |
530 | refname = argv[0]; |
531 | value = argv[1]; | |
532 | oldval = argv[2]; | |
a0bb5535 | 533 | if (get_oid(value, &oid)) |
973a70ea | 534 | die("%s: not a valid SHA1", value); |
ac5409e4 JH |
535 | } |
536 | ||
e2991c80 MH |
537 | if (oldval) { |
538 | if (!*oldval) | |
539 | /* | |
540 | * The empty string implies that the reference | |
541 | * must not already exist: | |
542 | */ | |
a0bb5535 | 543 | oidclr(&oldoid); |
544 | else if (get_oid(oldval, &oldoid)) | |
e2991c80 MH |
545 | die("%s: not a valid old SHA1", oldval); |
546 | } | |
66bf85a4 | 547 | |
973a70ea | 548 | if (delete) |
1c03c4d3 MH |
549 | /* |
550 | * For purposes of backwards compatibility, we treat | |
551 | * NULL_SHA1 as "don't care" here: | |
552 | */ | |
de922669 | 553 | return delete_ref(msg, refname, |
2616a5e5 | 554 | (oldval && !is_null_oid(&oldoid)) ? &oldoid : NULL, |
d345e9fb | 555 | default_flags); |
973a70ea | 556 | else |
ae077771 | 557 | return update_ref(msg, refname, &oid, oldval ? &oldoid : NULL, |
d345e9fb | 558 | default_flags | create_reflog_flag, |
144c76fa | 559 | UPDATE_REFS_DIE_ON_ERR); |
66bf85a4 | 560 | } |