]>
Commit | Line | Data |
---|---|---|
66bf85a4 LT |
1 | #include "cache.h" |
2 | #include "refs.h" | |
854b4629 | 3 | #include "builtin.h" |
89942be6 | 4 | #include "parse-options.h" |
c750ba95 BK |
5 | #include "quote.h" |
6 | #include "argv-array.h" | |
66bf85a4 | 7 | |
89942be6 | 8 | static const char * const git_update_ref_usage[] = { |
82269505 NTND |
9 | N_("git update-ref [options] -d <refname> [<oldval>]"), |
10 | N_("git update-ref [options] <refname> <newval> [<oldval>]"), | |
c750ba95 | 11 | N_("git update-ref [options] --stdin [-z]"), |
89942be6 PH |
12 | NULL |
13 | }; | |
152da3df | 14 | |
aebfc133 | 15 | static struct ref_transaction *transaction; |
c750ba95 BK |
16 | |
17 | static char line_termination = '\n'; | |
18 | static int update_flags; | |
19 | ||
697a4151 MH |
20 | /* |
21 | * Parse one whitespace- or NUL-terminated, possibly C-quoted argument | |
22 | * and append the result to arg. Return a pointer to the terminator. | |
23 | * Die if there is an error in how the argument is C-quoted. This | |
24 | * function is only used if not -z. | |
25 | */ | |
c750ba95 BK |
26 | static const char *parse_arg(const char *next, struct strbuf *arg) |
27 | { | |
697a4151 MH |
28 | if (*next == '"') { |
29 | const char *orig = next; | |
30 | ||
31 | if (unquote_c_style(arg, next, &next)) | |
32 | die("badly quoted argument: %s", orig); | |
33 | if (*next && !isspace(*next)) | |
34 | die("unexpected character after quoted argument: %s", orig); | |
35 | } else { | |
c750ba95 BK |
36 | while (*next && !isspace(*next)) |
37 | strbuf_addch(arg, *next++); | |
697a4151 | 38 | } |
c750ba95 | 39 | |
c750ba95 BK |
40 | return next; |
41 | } | |
42 | ||
e23d8435 | 43 | /* |
ed410e61 MH |
44 | * Parse the reference name immediately after "command SP". If not |
45 | * -z, then handle C-quoting. Return a pointer to a newly allocated | |
46 | * string containing the name of the reference, or NULL if there was | |
47 | * an error. Update *next to point at the character that terminates | |
48 | * the argument. Die if C-quoting is malformed or the reference name | |
49 | * is invalid. | |
e23d8435 | 50 | */ |
ed410e61 | 51 | static char *parse_refname(struct strbuf *input, const char **next) |
c750ba95 | 52 | { |
ed410e61 MH |
53 | struct strbuf ref = STRBUF_INIT; |
54 | ||
c750ba95 BK |
55 | if (line_termination) { |
56 | /* Without -z, use the next argument */ | |
ed410e61 | 57 | *next = parse_arg(*next, &ref); |
c750ba95 | 58 | } else { |
e23d8435 | 59 | /* With -z, use everything up to the next NUL */ |
ed410e61 MH |
60 | strbuf_addstr(&ref, *next); |
61 | *next += ref.len; | |
62 | } | |
63 | ||
64 | if (!ref.len) { | |
65 | strbuf_release(&ref); | |
66 | return NULL; | |
c750ba95 | 67 | } |
ed410e61 MH |
68 | |
69 | if (check_refname_format(ref.buf, REFNAME_ALLOW_ONELEVEL)) | |
70 | die("invalid ref format: %s", ref.buf); | |
71 | ||
72 | return strbuf_detach(&ref, NULL); | |
c750ba95 BK |
73 | } |
74 | ||
e23d8435 | 75 | /* |
3afcc463 MH |
76 | * The value being parsed is <oldvalue> (as opposed to <newvalue>; the |
77 | * difference affects which error messages are generated): | |
78 | */ | |
79 | #define PARSE_SHA1_OLD 0x01 | |
80 | ||
81 | /* | |
82 | * For backwards compatibility, accept an empty string for update's | |
83 | * <newvalue> in binary mode to be equivalent to specifying zeros. | |
84 | */ | |
85 | #define PARSE_SHA1_ALLOW_EMPTY 0x02 | |
86 | ||
87 | /* | |
88 | * Parse an argument separator followed by the next argument, if any. | |
89 | * If there is an argument, convert it to a SHA-1, write it to sha1, | |
90 | * set *next to point at the character terminating the argument, and | |
e23d8435 | 91 | * return 0. If there is no argument at all (not even the empty |
3afcc463 MH |
92 | * string), return 1 and leave *next unchanged. If the value is |
93 | * provided but cannot be converted to a SHA-1, die. flags can | |
94 | * include PARSE_SHA1_OLD and/or PARSE_SHA1_ALLOW_EMPTY. | |
e23d8435 | 95 | */ |
3afcc463 MH |
96 | static int parse_next_sha1(struct strbuf *input, const char **next, |
97 | unsigned char *sha1, | |
98 | const char *command, const char *refname, | |
99 | int flags) | |
c750ba95 | 100 | { |
3afcc463 MH |
101 | struct strbuf arg = STRBUF_INIT; |
102 | int ret = 0; | |
103 | ||
104 | if (*next == input->buf + input->len) | |
105 | goto eof; | |
106 | ||
c750ba95 BK |
107 | if (line_termination) { |
108 | /* Without -z, consume SP and use next argument */ | |
e23d8435 | 109 | if (!**next || **next == line_termination) |
3afcc463 | 110 | return 1; |
e23d8435 | 111 | if (**next != ' ') |
3afcc463 MH |
112 | die("%s %s: expected SP but got: %s", |
113 | command, refname, *next); | |
e23d8435 | 114 | (*next)++; |
3afcc463 MH |
115 | *next = parse_arg(*next, &arg); |
116 | if (arg.len) { | |
117 | if (get_sha1(arg.buf, sha1)) | |
118 | goto invalid; | |
119 | } else { | |
120 | /* Without -z, an empty value means all zeros: */ | |
121 | hashclr(sha1); | |
122 | } | |
c750ba95 BK |
123 | } else { |
124 | /* With -z, read the next NUL-terminated line */ | |
e23d8435 | 125 | if (**next) |
3afcc463 MH |
126 | die("%s %s: expected NUL but got: %s", |
127 | command, refname, *next); | |
e23d8435 MH |
128 | (*next)++; |
129 | if (*next == input->buf + input->len) | |
3afcc463 MH |
130 | goto eof; |
131 | strbuf_addstr(&arg, *next); | |
132 | *next += arg.len; | |
133 | ||
134 | if (arg.len) { | |
135 | if (get_sha1(arg.buf, sha1)) | |
136 | goto invalid; | |
137 | } else if (flags & PARSE_SHA1_ALLOW_EMPTY) { | |
138 | /* With -z, treat an empty value as all zeros: */ | |
1fbd5049 MH |
139 | warning("%s %s: missing <newvalue>, treating as zero", |
140 | command, refname); | |
3afcc463 MH |
141 | hashclr(sha1); |
142 | } else { | |
143 | /* | |
144 | * With -z, an empty non-required value means | |
145 | * unspecified: | |
146 | */ | |
147 | ret = 1; | |
148 | } | |
c750ba95 | 149 | } |
3afcc463 MH |
150 | |
151 | strbuf_release(&arg); | |
152 | ||
153 | return ret; | |
154 | ||
155 | invalid: | |
156 | die(flags & PARSE_SHA1_OLD ? | |
157 | "%s %s: invalid <oldvalue>: %s" : | |
158 | "%s %s: invalid <newvalue>: %s", | |
159 | command, refname, arg.buf); | |
160 | ||
161 | eof: | |
162 | die(flags & PARSE_SHA1_OLD ? | |
726f6916 MH |
163 | "%s %s: unexpected end of input when reading <oldvalue>" : |
164 | "%s %s: unexpected end of input when reading <newvalue>", | |
3afcc463 | 165 | command, refname); |
c750ba95 BK |
166 | } |
167 | ||
e23d8435 MH |
168 | |
169 | /* | |
170 | * The following five parse_cmd_*() functions parse the corresponding | |
171 | * command. In each case, next points at the character following the | |
172 | * command name and the following space. They each return a pointer | |
173 | * to the character terminating the command, and die with an | |
174 | * explanatory message if there are any parsing problems. All of | |
175 | * these functions handle either text or binary format input, | |
176 | * depending on how line_termination is set. | |
177 | */ | |
178 | ||
179 | static const char *parse_cmd_update(struct strbuf *input, const char *next) | |
c750ba95 | 180 | { |
aebfc133 MH |
181 | char *refname; |
182 | unsigned char new_sha1[20]; | |
183 | unsigned char old_sha1[20]; | |
184 | int have_old; | |
c750ba95 | 185 | |
aebfc133 MH |
186 | refname = parse_refname(input, &next); |
187 | if (!refname) | |
f11b09fb | 188 | die("update: missing <ref>"); |
c750ba95 | 189 | |
aebfc133 | 190 | if (parse_next_sha1(input, &next, new_sha1, "update", refname, |
3afcc463 | 191 | PARSE_SHA1_ALLOW_EMPTY)) |
aebfc133 | 192 | die("update %s: missing <newvalue>", refname); |
c750ba95 | 193 | |
aebfc133 MH |
194 | have_old = !parse_next_sha1(input, &next, old_sha1, "update", refname, |
195 | PARSE_SHA1_OLD); | |
3afcc463 MH |
196 | |
197 | if (*next != line_termination) | |
aebfc133 MH |
198 | die("update %s: extra input: %s", refname, next); |
199 | ||
200 | ref_transaction_update(transaction, refname, new_sha1, old_sha1, | |
201 | update_flags, have_old); | |
202 | ||
203 | update_flags = 0; | |
204 | free(refname); | |
c750ba95 | 205 | |
e23d8435 | 206 | return next; |
c750ba95 BK |
207 | } |
208 | ||
e23d8435 | 209 | static const char *parse_cmd_create(struct strbuf *input, const char *next) |
c750ba95 | 210 | { |
aebfc133 MH |
211 | char *refname; |
212 | unsigned char new_sha1[20]; | |
c750ba95 | 213 | |
aebfc133 MH |
214 | refname = parse_refname(input, &next); |
215 | if (!refname) | |
f11b09fb | 216 | die("create: missing <ref>"); |
c750ba95 | 217 | |
aebfc133 MH |
218 | if (parse_next_sha1(input, &next, new_sha1, "create", refname, 0)) |
219 | die("create %s: missing <newvalue>", refname); | |
e23d8435 | 220 | |
aebfc133 MH |
221 | if (is_null_sha1(new_sha1)) |
222 | die("create %s: zero <newvalue>", refname); | |
c750ba95 | 223 | |
e23d8435 | 224 | if (*next != line_termination) |
aebfc133 MH |
225 | die("create %s: extra input: %s", refname, next); |
226 | ||
227 | ref_transaction_create(transaction, refname, new_sha1, update_flags); | |
228 | ||
229 | update_flags = 0; | |
230 | free(refname); | |
e23d8435 MH |
231 | |
232 | return next; | |
c750ba95 BK |
233 | } |
234 | ||
e23d8435 | 235 | static const char *parse_cmd_delete(struct strbuf *input, const char *next) |
c750ba95 | 236 | { |
aebfc133 MH |
237 | char *refname; |
238 | unsigned char old_sha1[20]; | |
239 | int have_old; | |
c750ba95 | 240 | |
aebfc133 MH |
241 | refname = parse_refname(input, &next); |
242 | if (!refname) | |
f11b09fb | 243 | die("delete: missing <ref>"); |
c750ba95 | 244 | |
aebfc133 MH |
245 | if (parse_next_sha1(input, &next, old_sha1, "delete", refname, |
246 | PARSE_SHA1_OLD)) { | |
247 | have_old = 0; | |
3afcc463 | 248 | } else { |
aebfc133 MH |
249 | if (is_null_sha1(old_sha1)) |
250 | die("delete %s: zero <oldvalue>", refname); | |
251 | have_old = 1; | |
3afcc463 | 252 | } |
c750ba95 | 253 | |
e23d8435 | 254 | if (*next != line_termination) |
aebfc133 MH |
255 | die("delete %s: extra input: %s", refname, next); |
256 | ||
257 | ref_transaction_delete(transaction, refname, old_sha1, | |
258 | update_flags, have_old); | |
259 | ||
260 | update_flags = 0; | |
261 | free(refname); | |
e23d8435 MH |
262 | |
263 | return next; | |
c750ba95 BK |
264 | } |
265 | ||
e23d8435 | 266 | static const char *parse_cmd_verify(struct strbuf *input, const char *next) |
c750ba95 | 267 | { |
aebfc133 MH |
268 | char *refname; |
269 | unsigned char new_sha1[20]; | |
270 | unsigned char old_sha1[20]; | |
271 | int have_old; | |
c750ba95 | 272 | |
aebfc133 MH |
273 | refname = parse_refname(input, &next); |
274 | if (!refname) | |
f11b09fb | 275 | die("verify: missing <ref>"); |
c750ba95 | 276 | |
aebfc133 MH |
277 | if (parse_next_sha1(input, &next, old_sha1, "verify", refname, |
278 | PARSE_SHA1_OLD)) { | |
279 | hashclr(new_sha1); | |
280 | have_old = 0; | |
3afcc463 | 281 | } else { |
aebfc133 MH |
282 | hashcpy(new_sha1, old_sha1); |
283 | have_old = 1; | |
3afcc463 | 284 | } |
c750ba95 | 285 | |
e23d8435 | 286 | if (*next != line_termination) |
aebfc133 MH |
287 | die("verify %s: extra input: %s", refname, next); |
288 | ||
289 | ref_transaction_update(transaction, refname, new_sha1, old_sha1, | |
290 | update_flags, have_old); | |
291 | ||
292 | update_flags = 0; | |
293 | free(refname); | |
e23d8435 MH |
294 | |
295 | return next; | |
c750ba95 BK |
296 | } |
297 | ||
e23d8435 | 298 | static const char *parse_cmd_option(struct strbuf *input, const char *next) |
c750ba95 | 299 | { |
e23d8435 | 300 | if (!strncmp(next, "no-deref", 8) && next[8] == line_termination) |
c750ba95 BK |
301 | update_flags |= REF_NODEREF; |
302 | else | |
303 | die("option unknown: %s", next); | |
e23d8435 | 304 | return next + 8; |
c750ba95 BK |
305 | } |
306 | ||
307 | static void update_refs_stdin(void) | |
308 | { | |
e23d8435 MH |
309 | struct strbuf input = STRBUF_INIT; |
310 | const char *next; | |
c750ba95 | 311 | |
e23d8435 MH |
312 | if (strbuf_read(&input, 0, 1000) < 0) |
313 | die_errno("could not read from stdin"); | |
314 | next = input.buf; | |
c750ba95 | 315 | /* Read each line dispatch its command */ |
e23d8435 MH |
316 | while (next < input.buf + input.len) { |
317 | if (*next == line_termination) | |
c750ba95 | 318 | die("empty command in input"); |
e23d8435 MH |
319 | else if (isspace(*next)) |
320 | die("whitespace before command: %s", next); | |
321 | else if (starts_with(next, "update ")) | |
322 | next = parse_cmd_update(&input, next + 7); | |
323 | else if (starts_with(next, "create ")) | |
324 | next = parse_cmd_create(&input, next + 7); | |
325 | else if (starts_with(next, "delete ")) | |
326 | next = parse_cmd_delete(&input, next + 7); | |
327 | else if (starts_with(next, "verify ")) | |
328 | next = parse_cmd_verify(&input, next + 7); | |
329 | else if (starts_with(next, "option ")) | |
330 | next = parse_cmd_option(&input, next + 7); | |
c750ba95 | 331 | else |
e23d8435 MH |
332 | die("unknown command: %s", next); |
333 | ||
334 | next++; | |
335 | } | |
c750ba95 | 336 | |
e23d8435 | 337 | strbuf_release(&input); |
c750ba95 BK |
338 | } |
339 | ||
a633fca0 | 340 | int cmd_update_ref(int argc, const char **argv, const char *prefix) |
66bf85a4 | 341 | { |
f877fd82 | 342 | const char *refname, *oldval, *msg = NULL; |
5b16b090 | 343 | unsigned char sha1[20], oldsha1[20]; |
c750ba95 | 344 | int delete = 0, no_deref = 0, read_stdin = 0, end_null = 0, flags = 0; |
89942be6 | 345 | struct option options[] = { |
82269505 | 346 | OPT_STRING( 'm', NULL, &msg, N_("reason"), N_("reason of the update")), |
d5d09d47 SB |
347 | OPT_BOOL('d', NULL, &delete, N_("delete the reference")), |
348 | OPT_BOOL( 0 , "no-deref", &no_deref, | |
82269505 | 349 | N_("update <refname> not the one it points to")), |
9a86b899 JH |
350 | OPT_BOOL('z', NULL, &end_null, N_("stdin has NUL-terminated arguments")), |
351 | OPT_BOOL( 0 , "stdin", &read_stdin, N_("read updates from stdin")), | |
89942be6 PH |
352 | OPT_END(), |
353 | }; | |
66bf85a4 | 354 | |
ef90d6d4 | 355 | git_config(git_default_config, NULL); |
37782920 SB |
356 | argc = parse_options(argc, argv, prefix, options, git_update_ref_usage, |
357 | 0); | |
89942be6 PH |
358 | if (msg && !*msg) |
359 | die("Refusing to perform update with empty message."); | |
5b16b090 | 360 | |
c750ba95 | 361 | if (read_stdin) { |
aebfc133 MH |
362 | int ret; |
363 | transaction = ref_transaction_begin(); | |
364 | ||
c750ba95 BK |
365 | if (delete || no_deref || argc > 0) |
366 | usage_with_options(git_update_ref_usage, options); | |
367 | if (end_null) | |
368 | line_termination = '\0'; | |
369 | update_refs_stdin(); | |
aebfc133 MH |
370 | ret = ref_transaction_commit(transaction, msg, |
371 | UPDATE_REFS_DIE_ON_ERR); | |
372 | return ret; | |
c750ba95 BK |
373 | } |
374 | ||
375 | if (end_null) | |
376 | usage_with_options(git_update_ref_usage, options); | |
377 | ||
ac5409e4 | 378 | if (delete) { |
3fe8dce6 | 379 | if (argc < 1 || argc > 2) |
973a70ea KW |
380 | usage_with_options(git_update_ref_usage, options); |
381 | refname = argv[0]; | |
382 | oldval = argv[1]; | |
383 | } else { | |
384 | const char *value; | |
385 | if (argc < 2 || argc > 3) | |
89942be6 | 386 | usage_with_options(git_update_ref_usage, options); |
973a70ea KW |
387 | refname = argv[0]; |
388 | value = argv[1]; | |
389 | oldval = argv[2]; | |
390 | if (get_sha1(value, sha1)) | |
391 | die("%s: not a valid SHA1", value); | |
ac5409e4 JH |
392 | } |
393 | ||
973a70ea | 394 | hashclr(oldsha1); /* all-zero hash in case oldval is the empty string */ |
ac5409e4 | 395 | if (oldval && *oldval && get_sha1(oldval, oldsha1)) |
66bf85a4 LT |
396 | die("%s: not a valid old SHA1", oldval); |
397 | ||
569740bd MV |
398 | if (no_deref) |
399 | flags = REF_NODEREF; | |
973a70ea | 400 | if (delete) |
569740bd | 401 | return delete_ref(refname, oldval ? oldsha1 : NULL, flags); |
973a70ea KW |
402 | else |
403 | return update_ref(msg, refname, sha1, oldval ? oldsha1 : NULL, | |
f4124112 | 404 | flags, UPDATE_REFS_DIE_ON_ERR); |
66bf85a4 | 405 | } |