4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>,
5 * Carlos Rica <jasampler@gmail.com>
6 * Based on git-tag.sh and mktag.c by Linus Torvalds.
13 #include "run-command.h"
14 #include "parse-options.h"
18 static const char * const git_tag_usage
[] = {
19 "git tag [-a|-s|-u <key-id>] [-f] [-m <msg>|-F <file>] <tagname> [<head>]",
20 "git tag -d <tagname>...",
21 "git tag -l [-n[<num>]] [<pattern>...]",
22 "git tag -v <tagname>...",
26 static char signingkey
[1000];
29 const char **patterns
;
31 struct commit_list
*with_commit
;
34 static int match_pattern(const char **patterns
, const char *ref
)
36 /* no pattern means match everything */
39 for (; *patterns
; patterns
++)
40 if (!fnmatch(*patterns
, ref
, 0))
45 static int in_commit_list(const struct commit_list
*want
, struct commit
*c
)
47 for (; want
; want
= want
->next
)
48 if (!hashcmp(want
->item
->object
.sha1
, c
->object
.sha1
))
53 static int contains_recurse(struct commit
*candidate
,
54 const struct commit_list
*want
)
56 struct commit_list
*p
;
58 /* was it previously marked as containing a want commit? */
59 if (candidate
->object
.flags
& TMP_MARK
)
61 /* or marked as not possibly containing a want commit? */
62 if (candidate
->object
.flags
& UNINTERESTING
)
65 if (in_commit_list(want
, candidate
))
68 if (parse_commit(candidate
) < 0)
71 /* Otherwise recurse and mark ourselves for future traversals. */
72 for (p
= candidate
->parents
; p
; p
= p
->next
) {
73 if (contains_recurse(p
->item
, want
)) {
74 candidate
->object
.flags
|= TMP_MARK
;
78 candidate
->object
.flags
|= UNINTERESTING
;
82 static int contains(struct commit
*candidate
, const struct commit_list
*want
)
84 return contains_recurse(candidate
, want
);
87 static int show_reference(const char *refname
, const unsigned char *sha1
,
88 int flag
, void *cb_data
)
90 struct tag_filter
*filter
= cb_data
;
92 if (match_pattern(filter
->patterns
, refname
)) {
95 enum object_type type
;
99 if (filter
->with_commit
) {
100 struct commit
*commit
;
102 commit
= lookup_commit_reference_gently(sha1
, 1);
105 if (!contains(commit
, filter
->with_commit
))
109 if (!filter
->lines
) {
110 printf("%s\n", refname
);
113 printf("%-15s ", refname
);
115 buf
= read_sha1_file(sha1
, &type
, &size
);
120 sp
= strstr(buf
, "\n\n");
125 /* only take up to "lines" lines, and strip the signature */
126 size
= parse_signature(buf
, size
);
128 i
< filter
->lines
&& sp
< buf
+ size
;
132 eol
= memchr(sp
, '\n', size
- (sp
- buf
));
133 len
= eol
? eol
- sp
: size
- (sp
- buf
);
134 fwrite(sp
, len
, 1, stdout
);
146 static int list_tags(const char **patterns
, int lines
,
147 struct commit_list
*with_commit
)
149 struct tag_filter filter
;
151 filter
.patterns
= patterns
;
152 filter
.lines
= lines
;
153 filter
.with_commit
= with_commit
;
155 for_each_tag_ref(show_reference
, (void *) &filter
);
160 typedef int (*each_tag_name_fn
)(const char *name
, const char *ref
,
161 const unsigned char *sha1
);
163 static int for_each_tag_name(const char **argv
, each_tag_name_fn fn
)
168 unsigned char sha1
[20];
170 for (p
= argv
; *p
; p
++) {
171 if (snprintf(ref
, sizeof(ref
), "refs/tags/%s", *p
)
173 error(_("tag name too long: %.*s..."), 50, *p
);
177 if (!resolve_ref(ref
, sha1
, 1, NULL
)) {
178 error(_("tag '%s' not found."), *p
);
182 if (fn(*p
, ref
, sha1
))
188 static int delete_tag(const char *name
, const char *ref
,
189 const unsigned char *sha1
)
191 if (delete_ref(ref
, sha1
, 0))
193 printf(_("Deleted tag '%s' (was %s)\n"), name
, find_unique_abbrev(sha1
, DEFAULT_ABBREV
));
197 static int verify_tag(const char *name
, const char *ref
,
198 const unsigned char *sha1
)
200 const char *argv_verify_tag
[] = {"verify-tag",
201 "-v", "SHA1_HEX", NULL
};
202 argv_verify_tag
[2] = sha1_to_hex(sha1
);
204 if (run_command_v_opt(argv_verify_tag
, RUN_GIT_CMD
))
205 return error(_("could not verify the tag '%s'"), name
);
209 static int do_sign(struct strbuf
*buffer
)
211 struct child_process gpg
;
218 if (strlcpy(signingkey
, git_committer_info(IDENT_ERROR_ON_NO_NAME
),
219 sizeof(signingkey
)) > sizeof(signingkey
) - 1)
220 return error(_("committer info too long."));
221 bracket
= strchr(signingkey
, '>');
226 /* When the username signingkey is bad, program could be terminated
227 * because gpg exits without reading and then write gets SIGPIPE. */
228 signal(SIGPIPE
, SIG_IGN
);
230 memset(&gpg
, 0, sizeof(gpg
));
236 args
[2] = signingkey
;
239 if (start_command(&gpg
))
240 return error(_("could not run gpg."));
242 if (write_in_full(gpg
.in
, buffer
->buf
, buffer
->len
) != buffer
->len
) {
245 finish_command(&gpg
);
246 return error(_("gpg did not accept the tag data"));
249 len
= strbuf_read(buffer
, gpg
.out
, 1024);
252 if (finish_command(&gpg
) || !len
|| len
< 0)
253 return error(_("gpg failed to sign the tag"));
255 /* Strip CR from the line endings, in case we are on Windows. */
256 for (i
= j
= 0; i
< buffer
->len
; i
++)
257 if (buffer
->buf
[i
] != '\r') {
259 buffer
->buf
[j
] = buffer
->buf
[i
];
262 strbuf_setlen(buffer
, j
);
267 static const char tag_template
[] =
270 "# Write a tag message\n"
271 "# Lines starting with '#' will be ignored.\n"
274 static const char tag_template_nocleanup
[] =
277 "# Write a tag message\n"
278 "# Lines starting with '#' will be kept; you may remove them"
279 " yourself if you want to.\n"
282 static void set_signingkey(const char *value
)
284 if (strlcpy(signingkey
, value
, sizeof(signingkey
)) >= sizeof(signingkey
))
285 die(_("signing key value too long (%.10s...)"), value
);
288 static int git_tag_config(const char *var
, const char *value
, void *cb
)
290 if (!strcmp(var
, "user.signingkey")) {
292 return config_error_nonbool(var
);
293 set_signingkey(value
);
297 return git_default_config(var
, value
, cb
);
300 static void write_tag_body(int fd
, const unsigned char *sha1
)
303 enum object_type type
;
306 buf
= read_sha1_file(sha1
, &type
, &size
);
310 sp
= strstr(buf
, "\n\n");
312 if (!sp
|| !size
|| type
!= OBJ_TAG
) {
316 sp
+= 2; /* skip the 2 LFs */
317 write_or_die(fd
, sp
, parse_signature(sp
, buf
+ size
- sp
));
322 static int build_tag_object(struct strbuf
*buf
, int sign
, unsigned char *result
)
324 if (sign
&& do_sign(buf
) < 0)
325 return error(_("unable to sign the tag"));
326 if (write_sha1_file(buf
->buf
, buf
->len
, tag_type
, result
) < 0)
327 return error(_("unable to write tag file"));
331 struct create_tag_options
{
332 unsigned int message_given
:1;
341 static void create_tag(const unsigned char *object
, const char *tag
,
342 struct strbuf
*buf
, struct create_tag_options
*opt
,
343 unsigned char *prev
, unsigned char *result
)
345 enum object_type type
;
346 char header_buf
[1024];
350 type
= sha1_object_info(object
, NULL
);
351 if (type
<= OBJ_NONE
)
352 die(_("bad object type."));
354 header_len
= snprintf(header_buf
, sizeof(header_buf
),
362 git_committer_info(IDENT_ERROR_ON_NO_NAME
));
364 if (header_len
> sizeof(header_buf
) - 1)
365 die(_("tag header too big."));
367 if (!opt
->message_given
) {
370 /* write the template message before editing: */
371 path
= git_pathdup("TAG_EDITMSG");
372 fd
= open(path
, O_CREAT
| O_TRUNC
| O_WRONLY
, 0600);
374 die_errno(_("could not create file '%s'"), path
);
376 if (!is_null_sha1(prev
))
377 write_tag_body(fd
, prev
);
378 else if (opt
->cleanup_mode
== CLEANUP_ALL
)
379 write_or_die(fd
, _(tag_template
),
380 strlen(_(tag_template
)));
382 write_or_die(fd
, _(tag_template_nocleanup
),
383 strlen(_(tag_template_nocleanup
)));
386 if (launch_editor(path
, buf
, NULL
)) {
388 _("Please supply the message using either -m or -F option.\n"));
393 if (opt
->cleanup_mode
!= CLEANUP_NONE
)
394 stripspace(buf
, opt
->cleanup_mode
== CLEANUP_ALL
);
396 if (!opt
->message_given
&& !buf
->len
)
397 die(_("no tag message?"));
399 strbuf_insert(buf
, 0, header_buf
, header_len
);
401 if (build_tag_object(buf
, opt
->sign
, result
) < 0) {
403 fprintf(stderr
, _("The tag message has been left in %s\n"),
408 unlink_or_warn(path
);
418 static int parse_msg_arg(const struct option
*opt
, const char *arg
, int unset
)
420 struct msg_arg
*msg
= opt
->value
;
425 strbuf_addstr(&(msg
->buf
), "\n\n");
426 strbuf_addstr(&(msg
->buf
), arg
);
431 static int strbuf_check_tag_ref(struct strbuf
*sb
, const char *name
)
437 strbuf_addf(sb
, "refs/tags/%s", name
);
439 return check_refname_format(sb
->buf
, 0);
442 int cmd_tag(int argc
, const char **argv
, const char *prefix
)
444 struct strbuf buf
= STRBUF_INIT
;
445 struct strbuf ref
= STRBUF_INIT
;
446 unsigned char object
[20], prev
[20];
447 const char *object_ref
, *tag
;
448 struct ref_lock
*lock
;
449 struct create_tag_options opt
;
450 char *cleanup_arg
= NULL
;
451 int annotate
= 0, force
= 0, lines
= -1, list
= 0,
452 delete = 0, verify
= 0;
453 const char *msgfile
= NULL
, *keyid
= NULL
;
454 struct msg_arg msg
= { 0, STRBUF_INIT
};
455 struct commit_list
*with_commit
= NULL
;
456 struct option options
[] = {
457 OPT_BOOLEAN('l', "list", &list
, "list tag names"),
458 { OPTION_INTEGER
, 'n', NULL
, &lines
, "n",
459 "print <n> lines of each tag message",
460 PARSE_OPT_OPTARG
, NULL
, 1 },
461 OPT_BOOLEAN('d', "delete", &delete, "delete tags"),
462 OPT_BOOLEAN('v', "verify", &verify
, "verify tags"),
464 OPT_GROUP("Tag creation options"),
465 OPT_BOOLEAN('a', "annotate", &annotate
,
466 "annotated tag, needs a message"),
467 OPT_CALLBACK('m', "message", &msg
, "message",
468 "tag message", parse_msg_arg
),
469 OPT_FILENAME('F', "file", &msgfile
, "read message from file"),
470 OPT_BOOLEAN('s', "sign", &opt
.sign
, "annotated and GPG-signed tag"),
471 OPT_STRING(0, "cleanup", &cleanup_arg
, "mode",
472 "how to strip spaces and #comments from message"),
473 OPT_STRING('u', "local-user", &keyid
, "key-id",
474 "use another key to sign the tag"),
475 OPT__FORCE(&force
, "replace the tag if exists"),
477 OPT_GROUP("Tag listing options"),
479 OPTION_CALLBACK
, 0, "contains", &with_commit
, "commit",
480 "print only tags that contain the commit",
481 PARSE_OPT_LASTARG_DEFAULT
,
482 parse_opt_with_commit
, (intptr_t)"HEAD",
487 git_config(git_tag_config
, NULL
);
489 memset(&opt
, 0, sizeof(opt
));
491 argc
= parse_options(argc
, argv
, prefix
, options
, git_tag_usage
, 0);
495 set_signingkey(keyid
);
499 if (argc
== 0 && !(delete || verify
))
502 if ((annotate
|| msg
.given
|| msgfile
|| force
) &&
503 (list
|| delete || verify
))
504 usage_with_options(git_tag_usage
, options
);
506 if (list
+ delete + verify
> 1)
507 usage_with_options(git_tag_usage
, options
);
509 return list_tags(argv
, lines
== -1 ? 0 : lines
,
512 die(_("-n option is only allowed with -l."));
514 die(_("--contains option is only allowed with -l."));
516 return for_each_tag_name(argv
, delete_tag
);
518 return for_each_tag_name(argv
, verify_tag
);
520 if (msg
.given
|| msgfile
) {
521 if (msg
.given
&& msgfile
)
522 die(_("only one -F or -m option is allowed."));
525 strbuf_addbuf(&buf
, &(msg
.buf
));
527 if (!strcmp(msgfile
, "-")) {
528 if (strbuf_read(&buf
, 0, 1024) < 0)
529 die_errno(_("cannot read '%s'"), msgfile
);
531 if (strbuf_read_file(&buf
, msgfile
, 1024) < 0)
532 die_errno(_("could not open or read '%s'"),
540 object_ref
= argc
== 2 ? argv
[1] : "HEAD";
542 die(_("too many params"));
544 if (get_sha1(object_ref
, object
))
545 die(_("Failed to resolve '%s' as a valid ref."), object_ref
);
547 if (strbuf_check_tag_ref(&ref
, tag
))
548 die(_("'%s' is not a valid tag name."), tag
);
550 if (!resolve_ref(ref
.buf
, prev
, 1, NULL
))
553 die(_("tag '%s' already exists"), tag
);
555 opt
.message_given
= msg
.given
|| msgfile
;
557 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "strip"))
558 opt
.cleanup_mode
= CLEANUP_ALL
;
559 else if (!strcmp(cleanup_arg
, "verbatim"))
560 opt
.cleanup_mode
= CLEANUP_NONE
;
561 else if (!strcmp(cleanup_arg
, "whitespace"))
562 opt
.cleanup_mode
= CLEANUP_SPACE
;
564 die(_("Invalid cleanup mode %s"), cleanup_arg
);
567 create_tag(object
, tag
, &buf
, &opt
, prev
, object
);
569 lock
= lock_any_ref_for_update(ref
.buf
, prev
, 0);
571 die(_("%s: cannot lock the ref"), ref
.buf
);
572 if (write_ref_sha1(lock
, object
, NULL
) < 0)
573 die(_("%s: cannot update the ref"), ref
.buf
);
574 if (force
&& hashcmp(prev
, object
))
575 printf(_("Updated tag '%s' (was %s)\n"), tag
, find_unique_abbrev(prev
, DEFAULT_ABBREV
));
577 strbuf_release(&buf
);
578 strbuf_release(&ref
);