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 int updates_alloc
;
16 static int updates_count
;
17 static const struct ref_update
**updates
;
19 static char line_termination
= '\n';
20 static int update_flags
;
22 static struct ref_update
*update_alloc(void)
24 struct ref_update
*update
;
26 /* Allocate and zero-init a struct ref_update */
27 update
= xcalloc(1, sizeof(*update
));
28 ALLOC_GROW(updates
, updates_count
+ 1, updates_alloc
);
29 updates
[updates_count
++] = update
;
31 /* Store and reset accumulated options */
32 update
->flags
= update_flags
;
38 static void update_store_ref_name(struct ref_update
*update
,
41 if (check_refname_format(ref_name
, REFNAME_ALLOW_ONELEVEL
))
42 die("invalid ref format: %s", ref_name
);
43 update
->ref_name
= xstrdup(ref_name
);
46 static void update_store_new_sha1(struct ref_update
*update
,
49 if (*newvalue
&& get_sha1(newvalue
, update
->new_sha1
))
50 die("invalid new value for ref %s: %s",
51 update
->ref_name
, newvalue
);
54 static void update_store_old_sha1(struct ref_update
*update
,
57 if (*oldvalue
&& get_sha1(oldvalue
, update
->old_sha1
))
58 die("invalid old value for ref %s: %s",
59 update
->ref_name
, oldvalue
);
61 /* We have an old value if non-empty, or if empty without -z */
62 update
->have_old
= *oldvalue
|| line_termination
;
66 * Parse one whitespace- or NUL-terminated, possibly C-quoted argument
67 * and append the result to arg. Return a pointer to the terminator.
68 * Die if there is an error in how the argument is C-quoted. This
69 * function is only used if not -z.
71 static const char *parse_arg(const char *next
, struct strbuf
*arg
)
74 const char *orig
= next
;
76 if (unquote_c_style(arg
, next
, &next
))
77 die("badly quoted argument: %s", orig
);
78 if (*next
&& !isspace(*next
))
79 die("unexpected character after quoted argument: %s", orig
);
81 while (*next
&& !isspace(*next
))
82 strbuf_addch(arg
, *next
++);
88 static const char *parse_first_arg(const char *next
, struct strbuf
*arg
)
90 /* Parse argument immediately after "command SP" */
92 if (line_termination
) {
93 /* Without -z, use the next argument */
94 next
= parse_arg(next
, arg
);
96 /* With -z, use rest of first NUL-terminated line */
97 strbuf_addstr(arg
, next
);
98 next
= next
+ arg
->len
;
103 static const char *parse_next_arg(const char *next
, struct strbuf
*arg
)
105 /* Parse next SP-terminated or NUL-terminated argument, if any */
107 if (line_termination
) {
108 /* Without -z, consume SP and use next argument */
112 die("expected SP but got: %s", next
);
113 next
= parse_arg(next
+ 1, arg
);
115 /* With -z, read the next NUL-terminated line */
117 die("expected NUL but got: %s", next
);
118 if (strbuf_getline(arg
, stdin
, '\0') == EOF
)
120 next
= arg
->buf
+ arg
->len
;
125 static void parse_cmd_update(const char *next
)
127 struct strbuf ref
= STRBUF_INIT
;
128 struct strbuf newvalue
= STRBUF_INIT
;
129 struct strbuf oldvalue
= STRBUF_INIT
;
130 struct ref_update
*update
;
132 update
= update_alloc();
134 if ((next
= parse_first_arg(next
, &ref
)) != NULL
&& ref
.buf
[0])
135 update_store_ref_name(update
, ref
.buf
);
137 die("update line missing <ref>");
139 if ((next
= parse_next_arg(next
, &newvalue
)) != NULL
)
140 update_store_new_sha1(update
, newvalue
.buf
);
142 die("update %s missing <newvalue>", ref
.buf
);
144 if ((next
= parse_next_arg(next
, &oldvalue
)) != NULL
)
145 update_store_old_sha1(update
, oldvalue
.buf
);
146 else if(!line_termination
)
147 die("update %s missing [<oldvalue>] NUL", ref
.buf
);
150 die("update %s has extra input: %s", ref
.buf
, next
);
153 static void parse_cmd_create(const char *next
)
155 struct strbuf ref
= STRBUF_INIT
;
156 struct strbuf newvalue
= STRBUF_INIT
;
157 struct ref_update
*update
;
159 update
= update_alloc();
161 if ((next
= parse_first_arg(next
, &ref
)) != NULL
&& ref
.buf
[0])
162 update_store_ref_name(update
, ref
.buf
);
164 die("create line missing <ref>");
166 if ((next
= parse_next_arg(next
, &newvalue
)) != NULL
)
167 update_store_new_sha1(update
, newvalue
.buf
);
169 die("create %s missing <newvalue>", ref
.buf
);
170 if (is_null_sha1(update
->new_sha1
))
171 die("create %s given zero new value", ref
.buf
);
174 die("create %s has extra input: %s", ref
.buf
, next
);
177 static void parse_cmd_delete(const char *next
)
179 struct strbuf ref
= STRBUF_INIT
;
180 struct strbuf oldvalue
= STRBUF_INIT
;
181 struct ref_update
*update
;
183 update
= update_alloc();
185 if ((next
= parse_first_arg(next
, &ref
)) != NULL
&& ref
.buf
[0])
186 update_store_ref_name(update
, ref
.buf
);
188 die("delete line missing <ref>");
190 if ((next
= parse_next_arg(next
, &oldvalue
)) != NULL
)
191 update_store_old_sha1(update
, oldvalue
.buf
);
192 else if(!line_termination
)
193 die("delete %s missing [<oldvalue>] NUL", ref
.buf
);
194 if (update
->have_old
&& is_null_sha1(update
->old_sha1
))
195 die("delete %s given zero old value", ref
.buf
);
198 die("delete %s has extra input: %s", ref
.buf
, next
);
201 static void parse_cmd_verify(const char *next
)
203 struct strbuf ref
= STRBUF_INIT
;
204 struct strbuf value
= STRBUF_INIT
;
205 struct ref_update
*update
;
207 update
= update_alloc();
209 if ((next
= parse_first_arg(next
, &ref
)) != NULL
&& ref
.buf
[0])
210 update_store_ref_name(update
, ref
.buf
);
212 die("verify line missing <ref>");
214 if ((next
= parse_next_arg(next
, &value
)) != NULL
) {
215 update_store_old_sha1(update
, value
.buf
);
216 update_store_new_sha1(update
, value
.buf
);
217 } else if(!line_termination
)
218 die("verify %s missing [<oldvalue>] NUL", ref
.buf
);
221 die("verify %s has extra input: %s", ref
.buf
, next
);
224 static void parse_cmd_option(const char *next
)
226 if (!strcmp(next
, "no-deref"))
227 update_flags
|= REF_NODEREF
;
229 die("option unknown: %s", next
);
232 static void update_refs_stdin(void)
234 struct strbuf cmd
= STRBUF_INIT
;
236 /* Read each line dispatch its command */
237 while (strbuf_getline(&cmd
, stdin
, line_termination
) != EOF
)
239 die("empty command in input");
240 else if (isspace(*cmd
.buf
))
241 die("whitespace before command: %s", cmd
.buf
);
242 else if (starts_with(cmd
.buf
, "update "))
243 parse_cmd_update(cmd
.buf
+ 7);
244 else if (starts_with(cmd
.buf
, "create "))
245 parse_cmd_create(cmd
.buf
+ 7);
246 else if (starts_with(cmd
.buf
, "delete "))
247 parse_cmd_delete(cmd
.buf
+ 7);
248 else if (starts_with(cmd
.buf
, "verify "))
249 parse_cmd_verify(cmd
.buf
+ 7);
250 else if (starts_with(cmd
.buf
, "option "))
251 parse_cmd_option(cmd
.buf
+ 7);
253 die("unknown command: %s", cmd
.buf
);
255 strbuf_release(&cmd
);
258 int cmd_update_ref(int argc
, const char **argv
, const char *prefix
)
260 const char *refname
, *oldval
, *msg
= NULL
;
261 unsigned char sha1
[20], oldsha1
[20];
262 int delete = 0, no_deref
= 0, read_stdin
= 0, end_null
= 0, flags
= 0;
263 struct option options
[] = {
264 OPT_STRING( 'm', NULL
, &msg
, N_("reason"), N_("reason of the update")),
265 OPT_BOOL('d', NULL
, &delete, N_("delete the reference")),
266 OPT_BOOL( 0 , "no-deref", &no_deref
,
267 N_("update <refname> not the one it points to")),
268 OPT_BOOL('z', NULL
, &end_null
, N_("stdin has NUL-terminated arguments")),
269 OPT_BOOL( 0 , "stdin", &read_stdin
, N_("read updates from stdin")),
273 git_config(git_default_config
, NULL
);
274 argc
= parse_options(argc
, argv
, prefix
, options
, git_update_ref_usage
,
277 die("Refusing to perform update with empty message.");
280 if (delete || no_deref
|| argc
> 0)
281 usage_with_options(git_update_ref_usage
, options
);
283 line_termination
= '\0';
285 return update_refs(msg
, updates
, updates_count
, DIE_ON_ERR
);
289 usage_with_options(git_update_ref_usage
, options
);
292 if (argc
< 1 || argc
> 2)
293 usage_with_options(git_update_ref_usage
, options
);
298 if (argc
< 2 || argc
> 3)
299 usage_with_options(git_update_ref_usage
, options
);
303 if (get_sha1(value
, sha1
))
304 die("%s: not a valid SHA1", value
);
307 hashclr(oldsha1
); /* all-zero hash in case oldval is the empty string */
308 if (oldval
&& *oldval
&& get_sha1(oldval
, oldsha1
))
309 die("%s: not a valid old SHA1", oldval
);
314 return delete_ref(refname
, oldval
? oldsha1
: NULL
, flags
);
316 return update_ref(msg
, refname
, sha1
, oldval
? oldsha1
: NULL
,