#include "cache.h" #include "config.h" #include "string-list.h" #include "run-command.h" #include "commit.h" #include "tempfile.h" #include "trailer.h" #include "list.h" /* * Copyright (c) 2013, 2014 Christian Couder <chriscool@tuxfamily.org> */ struct conf_info { char *name; char *key; char *command; char *cmd; enum trailer_where where; enum trailer_if_exists if_exists; enum trailer_if_missing if_missing; }; static struct conf_info default_conf_info; struct trailer_item { struct list_head list; /* * If this is not a trailer line, the line is stored in value * (excluding the terminating newline) and token is NULL. */ char *token; char *value; }; struct arg_item { struct list_head list; char *token; char *value; struct conf_info conf; }; static LIST_HEAD(conf_head); static char *separators = ":"; static int configured; #define TRAILER_ARG_STRING "$ARG" static const char *git_generated_prefixes[] = { "Signed-off-by: ", "(cherry picked from commit ", NULL }; /* Iterate over the elements of the list. */ #define list_for_each_dir(pos, head, is_reverse) \ for (pos = is_reverse ? (head)->prev : (head)->next; \ pos != (head); \ pos = is_reverse ? pos->prev : pos->next) static int after_or_end(enum trailer_where where) { return (where == WHERE_AFTER) || (where == WHERE_END); } /* * Return the length of the string not including any final * punctuation. E.g., the input "Signed-off-by:" would return * 13, stripping the trailing punctuation but retaining * internal punctuation. */ static size_t token_len_without_separator(const char *token, size_t len) { while (len > 0 && !isalnum(token[len - 1])) len--; return len; } static int same_token(struct trailer_item *a, struct arg_item *b) { size_t a_len, b_len, min_len; if (!a->token) return 0; a_len = token_len_without_separator(a->token, strlen(a->token)); b_len = token_len_without_separator(b->token, strlen(b->token)); min_len = (a_len > b_len) ? b_len : a_len; return !strncasecmp(a->token, b->token, min_len); } static int same_value(struct trailer_item *a, struct arg_item *b) { return !strcasecmp(a->value, b->value); } static int same_trailer(struct trailer_item *a, struct arg_item *b) { return same_token(a, b) && same_value(a, b); } static inline int is_blank_line(const char *str) { const char *s = str; while (*s && *s != '\n' && isspace(*s)) s++; return !*s || *s == '\n'; } static inline void strbuf_replace(struct strbuf *sb, const char *a, const char *b) { const char *ptr = strstr(sb->buf, a); if (ptr) strbuf_splice(sb, ptr - sb->buf, strlen(a), b, strlen(b)); } static void free_trailer_item(struct trailer_item *item) { free(item->token); free(item->value); free(item); } static void free_arg_item(struct arg_item *item) { free(item->conf.name); free(item->conf.key); free(item->conf.command); free(item->conf.cmd); free(item->token); free(item->value); free(item); } static char last_non_space_char(const char *s) { int i; for (i = strlen(s) - 1; i >= 0; i--) if (!isspace(s[i])) return s[i]; return '\0'; } static void print_tok_val(FILE *outfile, const char *tok, const char *val) { char c; if (!tok) { fprintf(outfile, "%s\n", val); return; } c = last_non_space_char(tok); if (!c) return; if (strchr(separators, c)) fprintf(outfile, "%s%s\n", tok, val); else fprintf(outfile, "%s%c %s\n", tok, separators[0], val); } static void print_all(FILE *outfile, struct list_head *head, const struct process_trailer_options *opts) { struct list_head *pos; struct trailer_item *item; list_for_each(pos, head) { item = list_entry(pos, struct trailer_item, list); if ((!opts->trim_empty || strlen(item->value) > 0) && (!opts->only_trailers || item->token)) print_tok_val(outfile, item->token, item->value); } } static struct trailer_item *trailer_from_arg(struct arg_item *arg_tok) { struct trailer_item *new_item = xcalloc(1, sizeof(*new_item)); new_item->token = arg_tok->token; new_item->value = arg_tok->value; arg_tok->token = arg_tok->value = NULL; free_arg_item(arg_tok); return new_item; } static void add_arg_to_input_list(struct trailer_item *on_tok, struct arg_item *arg_tok) { int aoe = after_or_end(arg_tok->conf.where); struct trailer_item *to_add = trailer_from_arg(arg_tok); if (aoe) list_add(&to_add->list, &on_tok->list); else list_add_tail(&to_add->list, &on_tok->list); } static int check_if_different(struct trailer_item *in_tok, struct arg_item *arg_tok, int check_all, struct list_head *head) { enum trailer_where where = arg_tok->conf.where; struct list_head *next_head; do { if (same_trailer(in_tok, arg_tok)) return 0; /* * if we want to add a trailer after another one, * we have to check those before this one */ next_head = after_or_end(where) ? in_tok->list.prev : in_tok->list.next; if (next_head == head) break; in_tok = list_entry(next_head, struct trailer_item, list); } while (check_all); return 1; } static char *apply_command(struct conf_info *conf, const char *arg) { struct strbuf cmd = STRBUF_INIT; struct strbuf buf = STRBUF_INIT; struct child_process cp = CHILD_PROCESS_INIT; char *result; if (conf->cmd) { strbuf_addstr(&cmd, conf->cmd); strvec_push(&cp.args, cmd.buf); if (arg) strvec_push(&cp.args, arg); } else if (conf->command) { strbuf_addstr(&cmd, conf->command); if (arg) strbuf_replace(&cmd, TRAILER_ARG_STRING, arg); strvec_push(&cp.args, cmd.buf); } strvec_pushv(&cp.env_array, (const char **)local_repo_env); cp.no_stdin = 1; cp.use_shell = 1; if (capture_command(&cp, &buf, 1024)) { error(_("running trailer command '%s' failed"), cmd.buf); strbuf_release(&buf); result = xstrdup(""); } else { strbuf_trim(&buf); result = strbuf_detach(&buf, NULL); } strbuf_release(&cmd); return result; } static void apply_item_command(struct trailer_item *in_tok, struct arg_item *arg_tok) { if (arg_tok->conf.command || arg_tok->conf.cmd) { const char *arg; if (arg_tok->value && arg_tok->value[0]) { arg = arg_tok->value; } else { if (in_tok && in_tok->value) arg = xstrdup(in_tok->value); else arg = xstrdup(""); } arg_tok->value = apply_command(&arg_tok->conf, arg); free((char *)arg); } } static void apply_arg_if_exists(struct trailer_item *in_tok, struct arg_item *arg_tok, struct trailer_item *on_tok, struct list_head *head) { switch (arg_tok->conf.if_exists) { case EXISTS_DO_NOTHING: free_arg_item(arg_tok); break; case EXISTS_REPLACE: apply_item_command(in_tok, arg_tok); add_arg_to_input_list(on_tok, arg_tok); list_del(&in_tok->list); free_trailer_item(in_tok); break; case EXISTS_ADD: apply_item_command(in_tok, arg_tok); add_arg_to_input_list(on_tok, arg_tok); break; case EXISTS_ADD_IF_DIFFERENT: apply_item_command(in_tok, arg_tok); if (check_if_different(in_tok, arg_tok, 1, head)) add_arg_to_input_list(on_tok, arg_tok); else free_arg_item(arg_tok); break; case EXISTS_ADD_IF_DIFFERENT_NEIGHBOR: apply_item_command(in_tok, arg_tok); if (check_if_different(on_tok, arg_tok, 0, head)) add_arg_to_input_list(on_tok, arg_tok); else free_arg_item(arg_tok); break; default: BUG("trailer.c: unhandled value %d", arg_tok->conf.if_exists); } } static void apply_arg_if_missing(struct list_head *head, struct arg_item *arg_tok) { enum trailer_where where; struct trailer_item *to_add; switch (arg_tok->conf.if_missing) { case MISSING_DO_NOTHING: free_arg_item(arg_tok); break; case MISSING_ADD: where = arg_tok->conf.where; apply_item_command(NULL, arg_tok); to_add = trailer_from_arg(arg_tok); if (after_or_end(where)) list_add_tail(&to_add->list, head); else list_add(&to_add->list, head); break; default: BUG("trailer.c: unhandled value %d", arg_tok->conf.if_missing); } } static int find_same_and_apply_arg(struct list_head *head, struct arg_item *arg_tok) { struct list_head *pos; struct trailer_item *in_tok; struct trailer_item *on_tok; enum trailer_where where = arg_tok->conf.where; int middle = (where == WHERE_AFTER) || (where == WHERE_BEFORE); int backwards = after_or_end(where); struct trailer_item *start_tok; if (list_empty(head)) return 0; start_tok = list_entry(backwards ? head->prev : head->next, struct trailer_item, list); list_for_each_dir(pos, head, backwards) { in_tok = list_entry(pos, struct trailer_item, list); if (!same_token(in_tok, arg_tok)) continue; on_tok = middle ? in_tok : start_tok; apply_arg_if_exists(in_tok, arg_tok, on_tok, head); return 1; } return 0; } static void process_trailers_lists(struct list_head *head, struct list_head *arg_head) { struct list_head *pos, *p; struct arg_item *arg_tok; list_for_each_safe(pos, p, arg_head) { int applied = 0; arg_tok = list_entry(pos, struct arg_item, list); list_del(pos); applied = find_same_and_apply_arg(head, arg_tok); if (!applied) apply_arg_if_missing(head, arg_tok); } } int trailer_set_where(enum trailer_where *item, const char *value) { if (!value) *item = WHERE_DEFAULT; else if (!strcasecmp("after", value)) *item = WHERE_AFTER; else if (!strcasecmp("before", value)) *item = WHERE_BEFORE; else if (!strcasecmp("end", value)) *item = WHERE_END; else if (!strcasecmp("start", value)) *item = WHERE_START; else return -1; return 0; } int trailer_set_if_exists(enum trailer_if_exists *item, const char *value) { if (!value) *item = EXISTS_DEFAULT; else if (!strcasecmp("addIfDifferent", value)) *item = EXISTS_ADD_IF_DIFFERENT; else if (!strcasecmp("addIfDifferentNeighbor", value)) *item = EXISTS_ADD_IF_DIFFERENT_NEIGHBOR; else if (!strcasecmp("add", value)) *item = EXISTS_ADD; else if (!strcasecmp("replace", value)) *item = EXISTS_REPLACE; else if (!strcasecmp("doNothing", value)) *item = EXISTS_DO_NOTHING; else return -1; return 0; } int trailer_set_if_missing(enum trailer_if_missing *item, const char *value) { if (!value) *item = MISSING_DEFAULT; else if (!strcasecmp("doNothing", value)) *item = MISSING_DO_NOTHING; else if (!strcasecmp("add", value)) *item = MISSING_ADD; else return -1; return 0; } static void duplicate_conf(struct conf_info *dst, const struct conf_info *src) { *dst = *src; dst->name = xstrdup_or_null(src->name); dst->key = xstrdup_or_null(src->key); dst->command = xstrdup_or_null(src->command); dst->cmd = xstrdup_or_null(src->cmd); } static struct arg_item *get_conf_item(const char *name) { struct list_head *pos; struct arg_item *item; /* Look up item with same name */ list_for_each(pos, &conf_head) { item = list_entry(pos, struct arg_item, list); if (!strcasecmp(item->conf.name, name)) return item; } /* Item does not already exists, create it */ CALLOC_ARRAY(item, 1); duplicate_conf(&item->conf, &default_conf_info); item->conf.name = xstrdup(name); list_add_tail(&item->list, &conf_head); return item; } enum trailer_info_type { TRAILER_KEY, TRAILER_COMMAND, TRAILER_CMD, TRAILER_WHERE, TRAILER_IF_EXISTS, TRAILER_IF_MISSING }; static struct { const char *name; enum trailer_info_type type; } trailer_config_items[] = { { "key", TRAILER_KEY }, { "command", TRAILER_COMMAND }, { "cmd", TRAILER_CMD }, { "where", TRAILER_WHERE }, { "ifexists", TRAILER_IF_EXISTS }, { "ifmissing", TRAILER_IF_MISSING } }; static int git_trailer_default_config(const char *conf_key, const char *value, void *cb) { const char *trailer_item, *variable_name; if (!skip_prefix(conf_key, "trailer.", &trailer_item)) return 0; variable_name = strrchr(trailer_item, '.'); if (!variable_name) { if (!strcmp(trailer_item, "where")) { if (trailer_set_where(&default_conf_info.where, value) < 0) warning(_("unknown value '%s' for key '%s'"), value, conf_key); } else if (!strcmp(trailer_item, "ifexists")) { if (trailer_set_if_exists(&default_conf_info.if_exists, value) < 0) warning(_("unknown value '%s' for key '%s'"), value, conf_key); } else if (!strcmp(trailer_item, "ifmissing")) { if (trailer_set_if_missing(&default_conf_info.if_missing, value) < 0) warning(_("unknown value '%s' for key '%s'"), value, conf_key); } else if (!strcmp(trailer_item, "separators")) { separators = xstrdup(value); } } return 0; } static int git_trailer_config(const char *conf_key, const char *value, void *cb) { const char *trailer_item, *variable_name; struct arg_item *item; struct conf_info *conf; char *name = NULL; enum trailer_info_type type; int i; if (!skip_prefix(conf_key, "trailer.", &trailer_item)) return 0; variable_name = strrchr(trailer_item, '.'); if (!variable_name) return 0; variable_name++; for (i = 0; i < ARRAY_SIZE(trailer_config_items); i++) { if (strcmp(trailer_config_items[i].name, variable_name)) continue; name = xstrndup(trailer_item, variable_name - trailer_item - 1); type = trailer_config_items[i].type; break; } if (!name) return 0; item = get_conf_item(name); conf = &item->conf; free(name); switch (type) { case TRAILER_KEY: if (conf->key) warning(_("more than one %s"), conf_key); conf->key = xstrdup(value); break; case TRAILER_COMMAND: if (conf->command) warning(_("more than one %s"), conf_key); conf->command = xstrdup(value); break; case TRAILER_CMD: if (conf->cmd) warning(_("more than one %s"), conf_key); conf->cmd = xstrdup(value); break; case TRAILER_WHERE: if (trailer_set_where(&conf->where, value)) warning(_("unknown value '%s' for key '%s'"), value, conf_key); break; case TRAILER_IF_EXISTS: if (trailer_set_if_exists(&conf->if_exists, value)) warning(_("unknown value '%s' for key '%s'"), value, conf_key); break; case TRAILER_IF_MISSING: if (trailer_set_if_missing(&conf->if_missing, value)) warning(_("unknown value '%s' for key '%s'"), value, conf_key); break; default: BUG("trailer.c: unhandled type %d", type); } return 0; } static void ensure_configured(void) { if (configured) return; /* Default config must be setup first */ default_conf_info.where = WHERE_END; default_conf_info.if_exists = EXISTS_ADD_IF_DIFFERENT_NEIGHBOR; default_conf_info.if_missing = MISSING_ADD; git_config(git_trailer_default_config, NULL); git_config(git_trailer_config, NULL); configured = 1; } static const char *token_from_item(struct arg_item *item, char *tok) { if (item->conf.key) return item->conf.key; if (tok) return tok; return item->conf.name; } static int token_matches_item(const char *tok, struct arg_item *item, size_t tok_len) { if (!strncasecmp(tok, item->conf.name, tok_len)) return 1; return item->conf.key ? !strncasecmp(tok, item->conf.key, tok_len) : 0; } /* * If the given line is of the form * "<token><optional whitespace><separator>..." or "<separator>...", return the * location of the separator. Otherwise, return -1. The optional whitespace * is allowed there primarily to allow things like "Bug #43" where <token> is * "Bug" and <separator> is "#". * * The separator-starts-line case (in which this function returns 0) is * distinguished from the non-well-formed-line case (in which this function * returns -1) because some callers of this function need such a distinction. */ static ssize_t find_separator(const char *line, const char *separators) { int whitespace_found = 0; const char *c; for (c = line; *c; c++) { if (strchr(separators, *c)) return c - line; if (!whitespace_found && (isalnum(*c) || *c == '-')) continue; if (c != line && (*c == ' ' || *c == '\t')) { whitespace_found = 1; continue; } break; } return -1; } /* * Obtain the token, value, and conf from the given trailer. * * separator_pos must not be 0, since the token cannot be an empty string. * * If separator_pos is -1, interpret the whole trailer as a token. */ static void parse_trailer(struct strbuf *tok, struct strbuf *val, const struct conf_info **conf, const char *trailer, ssize_t separator_pos) { struct arg_item *item; size_t tok_len; struct list_head *pos; if (separator_pos != -1) { strbuf_add(tok, trailer, separator_pos); strbuf_trim(tok); strbuf_addstr(val, trailer + separator_pos + 1); strbuf_trim(val); } else { strbuf_addstr(tok, trailer); strbuf_trim(tok); } /* Lookup if the token matches something in the config */ tok_len = token_len_without_separator(tok->buf, tok->len); if (conf) *conf = &default_conf_info; list_for_each(pos, &conf_head) { item = list_entry(pos, struct arg_item, list); if (token_matches_item(tok->buf, item, tok_len)) { char *tok_buf = strbuf_detach(tok, NULL); if (conf) *conf = &item->conf; strbuf_addstr(tok, token_from_item(item, tok_buf)); free(tok_buf); break; } } } static struct trailer_item *add_trailer_item(struct list_head *head, char *tok, char *val) { struct trailer_item *new_item = xcalloc(1, sizeof(*new_item)); new_item->token = tok; new_item->value = val; list_add_tail(&new_item->list, head); return new_item; } static void add_arg_item(struct list_head *arg_head, char *tok, char *val, const struct conf_info *conf, const struct new_trailer_item *new_trailer_item) { struct arg_item *new_item = xcalloc(1, sizeof(*new_item)); new_item->token = tok; new_item->value = val; duplicate_conf(&new_item->conf, conf); if (new_trailer_item) { if (new_trailer_item->where != WHERE_DEFAULT) new_item->conf.where = new_trailer_item->where; if (new_trailer_item->if_exists != EXISTS_DEFAULT) new_item->conf.if_exists = new_trailer_item->if_exists; if (new_trailer_item->if_missing != MISSING_DEFAULT) new_item->conf.if_missing = new_trailer_item->if_missing; } list_add_tail(&new_item->list, arg_head); } static void process_command_line_args(struct list_head *arg_head, struct list_head *new_trailer_head) { struct arg_item *item; struct strbuf tok = STRBUF_INIT; struct strbuf val = STRBUF_INIT; const struct conf_info *conf; struct list_head *pos; /* * In command-line arguments, '=' is accepted (in addition to the * separators that are defined). */ char *cl_separators = xstrfmt("=%s", separators); /* Add an arg item for each configured trailer with a command */ list_for_each(pos, &conf_head) { item = list_entry(pos, struct arg_item, list); if (item->conf.command) add_arg_item(arg_head, xstrdup(token_from_item(item, NULL)), xstrdup(""), &item->conf, NULL); } /* Add an arg item for each trailer on the command line */ list_for_each(pos, new_trailer_head) { struct new_trailer_item *tr = list_entry(pos, struct new_trailer_item, list); ssize_t separator_pos = find_separator(tr->text, cl_separators); if (separator_pos == 0) { struct strbuf sb = STRBUF_INIT; strbuf_addstr(&sb, tr->text); strbuf_trim(&sb); error(_("empty trailer token in trailer '%.*s'"), (int) sb.len, sb.buf); strbuf_release(&sb); } else { parse_trailer(&tok, &val, &conf, tr->text, separator_pos); add_arg_item(arg_head, strbuf_detach(&tok, NULL), strbuf_detach(&val, NULL), conf, tr); } } free(cl_separators); } static void read_input_file(struct strbuf *sb, const char *file) { if (file) { if (strbuf_read_file(sb, file, 0) < 0) die_errno(_("could not read input file '%s'"), file); } else { if (strbuf_read(sb, fileno(stdin), 0) < 0) die_errno(_("could not read from stdin")); } } static const char *next_line(const char *str) { const char *nl = strchrnul(str, '\n'); return nl + !!*nl; } /* * Return the position of the start of the last line. If len is 0, return -1. */ static ssize_t last_line(const char *buf, size_t len) { ssize_t i; if (len == 0) return -1; if (len == 1) return 0; /* * Skip the last character (in addition to the null terminator), * because if the last character is a newline, it is considered as part * of the last line anyway. */ i = len - 2; for (; i >= 0; i--) { if (buf[i] == '\n') return i + 1; } return 0; } /* * Return the position of the start of the patch or the length of str if there * is no patch in the message. */ static size_t find_patch_start(const char *str) { const char *s; for (s = str; *s; s = next_line(s)) { const char *v; if (skip_prefix(s, "---", &v) && isspace(*v)) return s - str; } return s - str; } /* * Return the position of the first trailer line or len if there are no * trailers. */ static size_t find_trailer_start(const char *buf, size_t len) { const char *s; ssize_t end_of_title, l; int only_spaces = 1; int recognized_prefix = 0, trailer_lines = 0, non_trailer_lines = 0; /* * Number of possible continuation lines encountered. This will be * reset to 0 if we encounter a trailer (since those lines are to be * considered continuations of that trailer), and added to * non_trailer_lines if we encounter a non-trailer (since those lines * are to be considered non-trailers). */ int possible_continuation_lines = 0; /* The first paragraph is the title and cannot be trailers */ for (s = buf; s < buf + len; s = next_line(s)) { if (s[0] == comment_line_char) continue; if (is_blank_line(s)) break; } end_of_title = s - buf; /* * Get the start of the trailers by looking starting from the end for a * blank line before a set of non-blank lines that (i) are all * trailers, or (ii) contains at least one Git-generated trailer and * consists of at least 25% trailers. */ for (l = last_line(buf, len); l >= end_of_title; l = last_line(buf, l)) { const char *bol = buf + l; const char **p; ssize_t separator_pos; if (bol[0] == comment_line_char) { non_trailer_lines += possible_continuation_lines; possible_continuation_lines = 0; continue; } if (is_blank_line(bol)) { if (only_spaces) continue; non_trailer_lines += possible_continuation_lines; if (recognized_prefix && trailer_lines * 3 >= non_trailer_lines) return next_line(bol) - buf; else if (trailer_lines && !non_trailer_lines) return next_line(bol) - buf; return len; } only_spaces = 0; for (p = git_generated_prefixes; *p; p++) { if (starts_with(bol, *p)) { trailer_lines++; possible_continuation_lines = 0; recognized_prefix = 1; goto continue_outer_loop; } } separator_pos = find_separator(bol, separators); if (separator_pos >= 1 && !isspace(bol[0])) { struct list_head *pos; trailer_lines++; possible_continuation_lines = 0; if (recognized_prefix) continue; list_for_each(pos, &conf_head) { struct arg_item *item; item = list_entry(pos, struct arg_item, list); if (token_matches_item(bol, item, separator_pos)) { recognized_prefix = 1; break; } } } else if (isspace(bol[0])) possible_continuation_lines++; else { non_trailer_lines++; non_trailer_lines += possible_continuation_lines; possible_continuation_lines = 0; } continue_outer_loop: ; } return len; } /* Return the position of the end of the trailers. */ static size_t find_trailer_end(const char *buf, size_t len) { return len - ignore_non_trailer(buf, len); } static int ends_with_blank_line(const char *buf, size_t len) { ssize_t ll = last_line(buf, len); if (ll < 0) return 0; return is_blank_line(buf + ll); } static void unfold_value(struct strbuf *val) { struct strbuf out = STRBUF_INIT; size_t i; strbuf_grow(&out, val->len); i = 0; while (i < val->len) { char c = val->buf[i++]; if (c == '\n') { /* Collapse continuation down to a single space. */ while (i < val->len && isspace(val->buf[i])) i++; strbuf_addch(&out, ' '); } else { strbuf_addch(&out, c); } } /* Empty lines may have left us with whitespace cruft at the edges */ strbuf_trim(&out); /* output goes back to val as if we modified it in-place */ strbuf_swap(&out, val); strbuf_release(&out); } static size_t process_input_file(FILE *outfile, const char *str, struct list_head *head, const struct process_trailer_options *opts) { struct trailer_info info; struct strbuf tok = STRBUF_INIT; struct strbuf val = STRBUF_INIT; size_t i; trailer_info_get(&info, str, opts); /* Print lines before the trailers as is */ if (!opts->only_trailers) fwrite(str, 1, info.trailer_start - str, outfile); if (!opts->only_trailers && !info.blank_line_before_trailer) fprintf(outfile, "\n"); for (i = 0; i < info.trailer_nr; i++) { int separator_pos; char *trailer = info.trailers[i]; if (trailer[0] == comment_line_char) continue; separator_pos = find_separator(trailer, separators); if (separator_pos >= 1) { parse_trailer(&tok, &val, NULL, trailer, separator_pos); if (opts->unfold) unfold_value(&val); add_trailer_item(head, strbuf_detach(&tok, NULL), strbuf_detach(&val, NULL)); } else if (!opts->only_trailers) { strbuf_addstr(&val, trailer); strbuf_strip_suffix(&val, "\n"); add_trailer_item(head, NULL, strbuf_detach(&val, NULL)); } } trailer_info_release(&info); return info.trailer_end - str; } static void free_all(struct list_head *head) { struct list_head *pos, *p; list_for_each_safe(pos, p, head) { list_del(pos); free_trailer_item(list_entry(pos, struct trailer_item, list)); } } static struct tempfile *trailers_tempfile; static FILE *create_in_place_tempfile(const char *file) { struct stat st; struct strbuf filename_template = STRBUF_INIT; const char *tail; FILE *outfile; if (stat(file, &st)) die_errno(_("could not stat %s"), file); if (!S_ISREG(st.st_mode)) die(_("file %s is not a regular file"), file); if (!(st.st_mode & S_IWUSR)) die(_("file %s is not writable by user"), file); /* Create temporary file in the same directory as the original */ tail = strrchr(file, '/'); if (tail != NULL) strbuf_add(&filename_template, file, tail - file + 1); strbuf_addstr(&filename_template, "git-interpret-trailers-XXXXXX"); trailers_tempfile = xmks_tempfile_m(filename_template.buf, st.st_mode); strbuf_release(&filename_template); outfile = fdopen_tempfile(trailers_tempfile, "w"); if (!outfile) die_errno(_("could not open temporary file")); return outfile; } void process_trailers(const char *file, const struct process_trailer_options *opts, struct list_head *new_trailer_head) { LIST_HEAD(head); struct strbuf sb = STRBUF_INIT; size_t trailer_end; FILE *outfile = stdout; ensure_configured(); read_input_file(&sb, file); if (opts->in_place) outfile = create_in_place_tempfile(file); /* Print the lines before the trailers */ trailer_end = process_input_file(outfile, sb.buf, &head, opts); if (!opts->only_input) { LIST_HEAD(arg_head); process_command_line_args(&arg_head, new_trailer_head); process_trailers_lists(&head, &arg_head); } print_all(outfile, &head, opts); free_all(&head); /* Print the lines after the trailers as is */ if (!opts->only_trailers) fwrite(sb.buf + trailer_end, 1, sb.len - trailer_end, outfile); if (opts->in_place) if (rename_tempfile(&trailers_tempfile, file)) die_errno(_("could not rename temporary file to %s"), file); strbuf_release(&sb); } void trailer_info_get(struct trailer_info *info, const char *str, const struct process_trailer_options *opts) { int patch_start, trailer_end, trailer_start; struct strbuf **trailer_lines, **ptr; char **trailer_strings = NULL; size_t nr = 0, alloc = 0; char **last = NULL; ensure_configured(); if (opts->no_divider) patch_start = strlen(str); else patch_start = find_patch_start(str); trailer_end = find_trailer_end(str, patch_start); trailer_start = find_trailer_start(str, trailer_end); trailer_lines = strbuf_split_buf(str + trailer_start, trailer_end - trailer_start, '\n', 0); for (ptr = trailer_lines; *ptr; ptr++) { if (last && isspace((*ptr)->buf[0])) { struct strbuf sb = STRBUF_INIT; strbuf_attach(&sb, *last, strlen(*last), strlen(*last)); strbuf_addbuf(&sb, *ptr); *last = strbuf_detach(&sb, NULL); continue; } ALLOC_GROW(trailer_strings, nr + 1, alloc); trailer_strings[nr] = strbuf_detach(*ptr, NULL); last = find_separator(trailer_strings[nr], separators) >= 1 ? &trailer_strings[nr] : NULL; nr++; } strbuf_list_free(trailer_lines); info->blank_line_before_trailer = ends_with_blank_line(str, trailer_start); info->trailer_start = str + trailer_start; info->trailer_end = str + trailer_end; info->trailers = trailer_strings; info->trailer_nr = nr; } void trailer_info_release(struct trailer_info *info) { size_t i; for (i = 0; i < info->trailer_nr; i++) free(info->trailers[i]); free(info->trailers); } static void format_trailer_info(struct strbuf *out, const struct trailer_info *info, const struct process_trailer_options *opts) { size_t origlen = out->len; size_t i; /* If we want the whole block untouched, we can take the fast path. */ if (!opts->only_trailers && !opts->unfold && !opts->filter && !opts->separator && !opts->key_only && !opts->value_only && !opts->key_value_separator) { strbuf_add(out, info->trailer_start, info->trailer_end - info->trailer_start); return; } for (i = 0; i < info->trailer_nr; i++) { char *trailer = info->trailers[i]; ssize_t separator_pos = find_separator(trailer, separators); if (separator_pos >= 1) { struct strbuf tok = STRBUF_INIT; struct strbuf val = STRBUF_INIT; parse_trailer(&tok, &val, NULL, trailer, separator_pos); if (!opts->filter || opts->filter(&tok, opts->filter_data)) { if (opts->unfold) unfold_value(&val); if (opts->separator && out->len != origlen) strbuf_addbuf(out, opts->separator); if (!opts->value_only) strbuf_addbuf(out, &tok); if (!opts->key_only && !opts->value_only) { if (opts->key_value_separator) strbuf_addbuf(out, opts->key_value_separator); else strbuf_addstr(out, ": "); } if (!opts->key_only) strbuf_addbuf(out, &val); if (!opts->separator) strbuf_addch(out, '\n'); } strbuf_release(&tok); strbuf_release(&val); } else if (!opts->only_trailers) { if (opts->separator && out->len != origlen) { strbuf_addbuf(out, opts->separator); } strbuf_addstr(out, trailer); if (opts->separator) { strbuf_rtrim(out); } } } } void format_trailers_from_commit(struct strbuf *out, const char *msg, const struct process_trailer_options *opts) { struct trailer_info info; trailer_info_get(&info, msg, opts); format_trailer_info(out, &info, opts); trailer_info_release(&info); } void trailer_iterator_init(struct trailer_iterator *iter, const char *msg) { struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT; strbuf_init(&iter->key, 0); strbuf_init(&iter->val, 0); opts.no_divider = 1; trailer_info_get(&iter->info, msg, &opts); iter->cur = 0; } int trailer_iterator_advance(struct trailer_iterator *iter) { while (iter->cur < iter->info.trailer_nr) { char *trailer = iter->info.trailers[iter->cur++]; int separator_pos = find_separator(trailer, separators); if (separator_pos < 1) continue; /* not a real trailer */ strbuf_reset(&iter->key); strbuf_reset(&iter->val); parse_trailer(&iter->key, &iter->val, NULL, trailer, separator_pos); unfold_value(&iter->val); return 1; } return 0; } void trailer_iterator_release(struct trailer_iterator *iter) { trailer_info_release(&iter->info); strbuf_release(&iter->val); strbuf_release(&iter->key); }