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