trailer.c

   1 #include "cache.h"
   2 #include "config.h"
   3 #include "string-list.h"
   4 #include "run-command.h"
   5 #include "commit.h"
   6 #include "tempfile.h"
   7 #include "trailer.h"
   8 #include "list.h"
   9 /*
  10  * Copyright (c) 2013, 2014 Christian Couder <chriscool@tuxfamily.org>
  11  */
  12
  13 struct conf_info {
  14         char *name;
  15         char *key;
  16         char *command;
  17         char *cmd;
  18         enum trailer_where where;
  19         enum trailer_if_exists if_exists;
  20         enum trailer_if_missing if_missing;
  21 };
  22
  23 static struct conf_info default_conf_info;
  24
  25 struct trailer_item {
  26         struct list_head list;
  27         /*
  28          * If this is not a trailer line, the line is stored in value
  29          * (excluding the terminating newline) and token is NULL.
  30          */
  31         char *token;
  32         char *value;
  33 };
  34
  35 struct arg_item {
  36         struct list_head list;
  37         char *token;
  38         char *value;
  39         struct conf_info conf;
  40 };
  41
  42 static LIST_HEAD(conf_head);
  43
  44 static char *separators = ":";
  45
  46 static int configured;
  47
  48 #define TRAILER_ARG_STRING "$ARG"
  49
  50 static const char *git_generated_prefixes[] = {
  51         "Signed-off-by: ",
  52         "(cherry picked from commit ",
  53         NULL
  54 };
  55
  56 /* Iterate over the elements of the list. */
  57 #define list_for_each_dir(pos, head, is_reverse) \
  58         for (pos = is_reverse ? (head)->prev : (head)->next; \
  59                 pos != (head); \
  60                 pos = is_reverse ? pos->prev : pos->next)
  61
  62 static int after_or_end(enum trailer_where where)
  63 {
  64         return (where == WHERE_AFTER) || (where == WHERE_END);
  65 }
  66
  67 /*
  68  * Return the length of the string not including any final
  69  * punctuation. E.g., the input "Signed-off-by:" would return
  70  * 13, stripping the trailing punctuation but retaining
  71  * internal punctuation.
  72  */
  73 static size_t token_len_without_separator(const char *token, size_t len)
  74 {
  75         while (len > 0 && !isalnum(token[len - 1]))
  76                 len--;
  77         return len;
  78 }
  79
  80 static int same_token(struct trailer_item *a, struct arg_item *b)
  81 {
  82         size_t a_len, b_len, min_len;
  83
  84         if (!a->token)
  85                 return 0;
  86
  87         a_len = token_len_without_separator(a->token, strlen(a->token));
  88         b_len = token_len_without_separator(b->token, strlen(b->token));
  89         min_len = (a_len > b_len) ? b_len : a_len;
  90
  91         return !strncasecmp(a->token, b->token, min_len);
  92 }
  93
  94 static int same_value(struct trailer_item *a, struct arg_item *b)
  95 {
  96         return !strcasecmp(a->value, b->value);
  97 }
  98
  99 static int same_trailer(struct trailer_item *a, struct arg_item *b)
 100 {
 101         return same_token(a, b) && same_value(a, b);
 102 }
 103
 104 static inline int is_blank_line(const char *str)
 105 {
 106         const char *s = str;
 107         while (*s && *s != '\n' && isspace(*s))
 108                 s++;
 109         return !*s || *s == '\n';
 110 }
 111
 112 static inline void strbuf_replace(struct strbuf *sb, const char *a, const char *b)
 113 {
 114         const char *ptr = strstr(sb->buf, a);
 115         if (ptr)
 116                 strbuf_splice(sb, ptr - sb->buf, strlen(a), b, strlen(b));
 117 }
 118
 119 static void free_trailer_item(struct trailer_item *item)
 120 {
 121         free(item->token);
 122         free(item->value);
 123         free(item);
 124 }
 125
 126 static void free_arg_item(struct arg_item *item)
 127 {
 128         free(item->conf.name);
 129         free(item->conf.key);
 130         free(item->conf.command);
 131         free(item->conf.cmd);
 132         free(item->token);
 133         free(item->value);
 134         free(item);
 135 }
 136
 137 static char last_non_space_char(const char *s)
 138 {
 139         int i;
 140         for (i = strlen(s) - 1; i >= 0; i--)
 141                 if (!isspace(s[i]))
 142                         return s[i];
 143         return '\0';
 144 }
 145
 146 static void print_tok_val(FILE *outfile, const char *tok, const char *val)
 147 {
 148         char c;
 149
 150         if (!tok) {
 151                 fprintf(outfile, "%s\n", val);
 152                 return;
 153         }
 154
 155         c = last_non_space_char(tok);
 156         if (!c)
 157                 return;
 158         if (strchr(separators, c))
 159                 fprintf(outfile, "%s%s\n", tok, val);
 160         else
 161                 fprintf(outfile, "%s%c %s\n", tok, separators[0], val);
 162 }
 163
 164 static void print_all(FILE *outfile, struct list_head *head,
 165                       const struct process_trailer_options *opts)
 166 {
 167         struct list_head *pos;
 168         struct trailer_item *item;
 169         list_for_each(pos, head) {
 170                 item = list_entry(pos, struct trailer_item, list);
 171                 if ((!opts->trim_empty || strlen(item->value) > 0) &&
 172                     (!opts->only_trailers || item->token))
 173                         print_tok_val(outfile, item->token, item->value);
 174         }
 175 }
 176
 177 static struct trailer_item *trailer_from_arg(struct arg_item *arg_tok)
 178 {
 179         struct trailer_item *new_item = xcalloc(1, sizeof(*new_item));
 180         new_item->token = arg_tok->token;
 181         new_item->value = arg_tok->value;
 182         arg_tok->token = arg_tok->value = NULL;
 183         free_arg_item(arg_tok);
 184         return new_item;
 185 }
 186
 187 static void add_arg_to_input_list(struct trailer_item *on_tok,
 188                                   struct arg_item *arg_tok)
 189 {
 190         int aoe = after_or_end(arg_tok->conf.where);
 191         struct trailer_item *to_add = trailer_from_arg(arg_tok);
 192         if (aoe)
 193                 list_add(&to_add->list, &on_tok->list);
 194         else
 195                 list_add_tail(&to_add->list, &on_tok->list);
 196 }
 197
 198 static int check_if_different(struct trailer_item *in_tok,
 199                               struct arg_item *arg_tok,
 200                               int check_all,
 201                               struct list_head *head)
 202 {
 203         enum trailer_where where = arg_tok->conf.where;
 204         struct list_head *next_head;
 205         do {
 206                 if (same_trailer(in_tok, arg_tok))
 207                         return 0;
 208                 /*
 209                  * if we want to add a trailer after another one,
 210                  * we have to check those before this one
 211                  */
 212                 next_head = after_or_end(where) ? in_tok->list.prev
 213                                                 : in_tok->list.next;
 214                 if (next_head == head)
 215                         break;
 216                 in_tok = list_entry(next_head, struct trailer_item, list);
 217         } while (check_all);
 218         return 1;
 219 }
 220
 221 static char *apply_command(struct conf_info *conf, const char *arg)
 222 {
 223         struct strbuf cmd = STRBUF_INIT;
 224         struct strbuf buf = STRBUF_INIT;
 225         struct child_process cp = CHILD_PROCESS_INIT;
 226         char *result;
 227
 228         if (conf->cmd) {
 229                 strbuf_addstr(&cmd, conf->cmd);
 230                 strvec_push(&cp.args, cmd.buf);
 231                 if (arg)
 232                         strvec_push(&cp.args, arg);
 233         } else if (conf->command) {
 234                 strbuf_addstr(&cmd, conf->command);
 235                 if (arg)
 236                         strbuf_replace(&cmd, TRAILER_ARG_STRING, arg);
 237                 strvec_push(&cp.args, cmd.buf);
 238         }
 239         strvec_pushv(&cp.env, (const char **)local_repo_env);
 240         cp.no_stdin = 1;
 241         cp.use_shell = 1;
 242
 243         if (capture_command(&cp, &buf, 1024)) {
 244                 error(_("running trailer command '%s' failed"), cmd.buf);
 245                 strbuf_release(&buf);
 246                 result = xstrdup("");
 247         } else {
 248                 strbuf_trim(&buf);
 249                 result = strbuf_detach(&buf, NULL);
 250         }
 251
 252         strbuf_release(&cmd);
 253         return result;
 254 }
 255
 256 static void apply_item_command(struct trailer_item *in_tok, struct arg_item *arg_tok)
 257 {
 258         if (arg_tok->conf.command || arg_tok->conf.cmd) {
 259                 const char *arg;
 260                 if (arg_tok->value && arg_tok->value[0]) {
 261                         arg = arg_tok->value;
 262                 } else {
 263                         if (in_tok && in_tok->value)
 264                                 arg = xstrdup(in_tok->value);
 265                         else
 266                                 arg = xstrdup("");
 267                 }
 268                 arg_tok->value = apply_command(&arg_tok->conf, arg);
 269                 free((char *)arg);
 270         }
 271 }
 272
 273 static void apply_arg_if_exists(struct trailer_item *in_tok,
 274                                 struct arg_item *arg_tok,
 275                                 struct trailer_item *on_tok,
 276                                 struct list_head *head)
 277 {
 278         switch (arg_tok->conf.if_exists) {
 279         case EXISTS_DO_NOTHING:
 280                 free_arg_item(arg_tok);
 281                 break;
 282         case EXISTS_REPLACE:
 283                 apply_item_command(in_tok, arg_tok);
 284                 add_arg_to_input_list(on_tok, arg_tok);
 285                 list_del(&in_tok->list);
 286                 free_trailer_item(in_tok);
 287                 break;
 288         case EXISTS_ADD:
 289                 apply_item_command(in_tok, arg_tok);
 290                 add_arg_to_input_list(on_tok, arg_tok);
 291                 break;
 292         case EXISTS_ADD_IF_DIFFERENT:
 293                 apply_item_command(in_tok, arg_tok);
 294                 if (check_if_different(in_tok, arg_tok, 1, head))
 295                         add_arg_to_input_list(on_tok, arg_tok);
 296                 else
 297                         free_arg_item(arg_tok);
 298                 break;
 299         case EXISTS_ADD_IF_DIFFERENT_NEIGHBOR:
 300                 apply_item_command(in_tok, arg_tok);
 301                 if (check_if_different(on_tok, arg_tok, 0, head))
 302                         add_arg_to_input_list(on_tok, arg_tok);
 303                 else
 304                         free_arg_item(arg_tok);
 305                 break;
 306         default:
 307                 BUG("trailer.c: unhandled value %d",
 308                     arg_tok->conf.if_exists);
 309         }
 310 }
 311
 312 static void apply_arg_if_missing(struct list_head *head,
 313                                  struct arg_item *arg_tok)
 314 {
 315         enum trailer_where where;
 316         struct trailer_item *to_add;
 317
 318         switch (arg_tok->conf.if_missing) {
 319         case MISSING_DO_NOTHING:
 320                 free_arg_item(arg_tok);
 321                 break;
 322         case MISSING_ADD:
 323                 where = arg_tok->conf.where;
 324                 apply_item_command(NULL, arg_tok);
 325                 to_add = trailer_from_arg(arg_tok);
 326                 if (after_or_end(where))
 327                         list_add_tail(&to_add->list, head);
 328                 else
 329                         list_add(&to_add->list, head);
 330                 break;
 331         default:
 332                 BUG("trailer.c: unhandled value %d",
 333                     arg_tok->conf.if_missing);
 334         }
 335 }
 336
 337 static int find_same_and_apply_arg(struct list_head *head,
 338                                    struct arg_item *arg_tok)
 339 {
 340         struct list_head *pos;
 341         struct trailer_item *in_tok;
 342         struct trailer_item *on_tok;
 343
 344         enum trailer_where where = arg_tok->conf.where;
 345         int middle = (where == WHERE_AFTER) || (where == WHERE_BEFORE);
 346         int backwards = after_or_end(where);
 347         struct trailer_item *start_tok;
 348
 349         if (list_empty(head))
 350                 return 0;
 351
 352         start_tok = list_entry(backwards ? head->prev : head->next,
 353                                struct trailer_item,
 354                                list);
 355
 356         list_for_each_dir(pos, head, backwards) {
 357                 in_tok = list_entry(pos, struct trailer_item, list);
 358                 if (!same_token(in_tok, arg_tok))
 359                         continue;
 360                 on_tok = middle ? in_tok : start_tok;
 361                 apply_arg_if_exists(in_tok, arg_tok, on_tok, head);
 362                 return 1;
 363         }
 364         return 0;
 365 }
 366
 367 static void process_trailers_lists(struct list_head *head,
 368                                    struct list_head *arg_head)
 369 {
 370         struct list_head *pos, *p;
 371         struct arg_item *arg_tok;
 372
 373         list_for_each_safe(pos, p, arg_head) {
 374                 int applied = 0;
 375                 arg_tok = list_entry(pos, struct arg_item, list);
 376
 377                 list_del(pos);
 378
 379                 applied = find_same_and_apply_arg(head, arg_tok);
 380
 381                 if (!applied)
 382                         apply_arg_if_missing(head, arg_tok);
 383         }
 384 }
 385
 386 int trailer_set_where(enum trailer_where *item, const char *value)
 387 {
 388         if (!value)
 389                 *item = WHERE_DEFAULT;
 390         else if (!strcasecmp("after", value))
 391                 *item = WHERE_AFTER;
 392         else if (!strcasecmp("before", value))
 393                 *item = WHERE_BEFORE;
 394         else if (!strcasecmp("end", value))
 395                 *item = WHERE_END;
 396         else if (!strcasecmp("start", value))
 397                 *item = WHERE_START;
 398         else
 399                 return -1;
 400         return 0;
 401 }
 402
 403 int trailer_set_if_exists(enum trailer_if_exists *item, const char *value)
 404 {
 405         if (!value)
 406                 *item = EXISTS_DEFAULT;
 407         else if (!strcasecmp("addIfDifferent", value))
 408                 *item = EXISTS_ADD_IF_DIFFERENT;
 409         else if (!strcasecmp("addIfDifferentNeighbor", value))
 410                 *item = EXISTS_ADD_IF_DIFFERENT_NEIGHBOR;
 411         else if (!strcasecmp("add", value))
 412                 *item = EXISTS_ADD;
 413         else if (!strcasecmp("replace", value))
 414                 *item = EXISTS_REPLACE;
 415         else if (!strcasecmp("doNothing", value))
 416                 *item = EXISTS_DO_NOTHING;
 417         else
 418                 return -1;
 419         return 0;
 420 }
 421
 422 int trailer_set_if_missing(enum trailer_if_missing *item, const char *value)
 423 {
 424         if (!value)
 425                 *item = MISSING_DEFAULT;
 426         else if (!strcasecmp("doNothing", value))
 427                 *item = MISSING_DO_NOTHING;
 428         else if (!strcasecmp("add", value))
 429                 *item = MISSING_ADD;
 430         else
 431                 return -1;
 432         return 0;
 433 }
 434
 435 static void duplicate_conf(struct conf_info *dst, const struct conf_info *src)
 436 {
 437         *dst = *src;
 438         dst->name = xstrdup_or_null(src->name);
 439         dst->key = xstrdup_or_null(src->key);
 440         dst->command = xstrdup_or_null(src->command);
 441         dst->cmd = xstrdup_or_null(src->cmd);
 442 }
 443
 444 static struct arg_item *get_conf_item(const char *name)
 445 {
 446         struct list_head *pos;
 447         struct arg_item *item;
 448
 449         /* Look up item with same name */
 450         list_for_each(pos, &conf_head) {
 451                 item = list_entry(pos, struct arg_item, list);
 452                 if (!strcasecmp(item->conf.name, name))
 453                         return item;
 454         }
 455
 456         /* Item does not already exists, create it */
 457         CALLOC_ARRAY(item, 1);
 458         duplicate_conf(&item->conf, &default_conf_info);
 459         item->conf.name = xstrdup(name);
 460
 461         list_add_tail(&item->list, &conf_head);
 462
 463         return item;
 464 }
 465
 466 enum trailer_info_type { TRAILER_KEY, TRAILER_COMMAND, TRAILER_CMD,
 467                         TRAILER_WHERE, TRAILER_IF_EXISTS, TRAILER_IF_MISSING };
 468
 469 static struct {
 470         const char *name;
 471         enum trailer_info_type type;
 472 } trailer_config_items[] = {
 473         { "key", TRAILER_KEY },
 474         { "command", TRAILER_COMMAND },
 475         { "cmd", TRAILER_CMD },
 476         { "where", TRAILER_WHERE },
 477         { "ifexists", TRAILER_IF_EXISTS },
 478         { "ifmissing", TRAILER_IF_MISSING }
 479 };
 480
 481 static int git_trailer_default_config(const char *conf_key, const char *value,
 482                                       void *cb UNUSED)
 483 {
 484         const char *trailer_item, *variable_name;
 485
 486         if (!skip_prefix(conf_key, "trailer.", &trailer_item))
 487                 return 0;
 488
 489         variable_name = strrchr(trailer_item, '.');
 490         if (!variable_name) {
 491                 if (!strcmp(trailer_item, "where")) {
 492                         if (trailer_set_where(&default_conf_info.where,
 493                                               value) < 0)
 494                                 warning(_("unknown value '%s' for key '%s'"),
 495                                         value, conf_key);
 496                 } else if (!strcmp(trailer_item, "ifexists")) {
 497                         if (trailer_set_if_exists(&default_conf_info.if_exists,
 498                                                   value) < 0)
 499                                 warning(_("unknown value '%s' for key '%s'"),
 500                                         value, conf_key);
 501                 } else if (!strcmp(trailer_item, "ifmissing")) {
 502                         if (trailer_set_if_missing(&default_conf_info.if_missing,
 503                                                    value) < 0)
 504                                 warning(_("unknown value '%s' for key '%s'"),
 505                                         value, conf_key);
 506                 } else if (!strcmp(trailer_item, "separators")) {
 507                         separators = xstrdup(value);
 508                 }
 509         }
 510         return 0;
 511 }
 512
 513 static int git_trailer_config(const char *conf_key, const char *value,
 514                               void *cb UNUSED)
 515 {
 516         const char *trailer_item, *variable_name;
 517         struct arg_item *item;
 518         struct conf_info *conf;
 519         char *name = NULL;
 520         enum trailer_info_type type;
 521         int i;
 522
 523         if (!skip_prefix(conf_key, "trailer.", &trailer_item))
 524                 return 0;
 525
 526         variable_name = strrchr(trailer_item, '.');
 527         if (!variable_name)
 528                 return 0;
 529
 530         variable_name++;
 531         for (i = 0; i < ARRAY_SIZE(trailer_config_items); i++) {
 532                 if (strcmp(trailer_config_items[i].name, variable_name))
 533                         continue;
 534                 name = xstrndup(trailer_item,  variable_name - trailer_item - 1);
 535                 type = trailer_config_items[i].type;
 536                 break;
 537         }
 538
 539         if (!name)
 540                 return 0;
 541
 542         item = get_conf_item(name);
 543         conf = &item->conf;
 544         free(name);
 545
 546         switch (type) {
 547         case TRAILER_KEY:
 548                 if (conf->key)
 549                         warning(_("more than one %s"), conf_key);
 550                 conf->key = xstrdup(value);
 551                 break;
 552         case TRAILER_COMMAND:
 553                 if (conf->command)
 554                         warning(_("more than one %s"), conf_key);
 555                 conf->command = xstrdup(value);
 556                 break;
 557         case TRAILER_CMD:
 558                 if (conf->cmd)
 559                         warning(_("more than one %s"), conf_key);
 560                 conf->cmd = xstrdup(value);
 561                 break;
 562         case TRAILER_WHERE:
 563                 if (trailer_set_where(&conf->where, value))
 564                         warning(_("unknown value '%s' for key '%s'"), value, conf_key);
 565                 break;
 566         case TRAILER_IF_EXISTS:
 567                 if (trailer_set_if_exists(&conf->if_exists, value))
 568                         warning(_("unknown value '%s' for key '%s'"), value, conf_key);
 569                 break;
 570         case TRAILER_IF_MISSING:
 571                 if (trailer_set_if_missing(&conf->if_missing, value))
 572                         warning(_("unknown value '%s' for key '%s'"), value, conf_key);
 573                 break;
 574         default:
 575                 BUG("trailer.c: unhandled type %d", type);
 576         }
 577         return 0;
 578 }
 579
 580 static void ensure_configured(void)
 581 {
 582         if (configured)
 583                 return;
 584
 585         /* Default config must be setup first */
 586         default_conf_info.where = WHERE_END;
 587         default_conf_info.if_exists = EXISTS_ADD_IF_DIFFERENT_NEIGHBOR;
 588         default_conf_info.if_missing = MISSING_ADD;
 589         git_config(git_trailer_default_config, NULL);
 590         git_config(git_trailer_config, NULL);
 591         configured = 1;
 592 }
 593
 594 static const char *token_from_item(struct arg_item *item, char *tok)
 595 {
 596         if (item->conf.key)
 597                 return item->conf.key;
 598         if (tok)
 599                 return tok;
 600         return item->conf.name;
 601 }
 602
 603 static int token_matches_item(const char *tok, struct arg_item *item, size_t tok_len)
 604 {
 605         if (!strncasecmp(tok, item->conf.name, tok_len))
 606                 return 1;
 607         return item->conf.key ? !strncasecmp(tok, item->conf.key, tok_len) : 0;
 608 }
 609
 610 /*
 611  * If the given line is of the form
 612  * "<token><optional whitespace><separator>..." or "<separator>...", return the
 613  * location of the separator. Otherwise, return -1.  The optional whitespace
 614  * is allowed there primarily to allow things like "Bug #43" where <token> is
 615  * "Bug" and <separator> is "#".
 616  *
 617  * The separator-starts-line case (in which this function returns 0) is
 618  * distinguished from the non-well-formed-line case (in which this function
 619  * returns -1) because some callers of this function need such a distinction.
 620  */
 621 static ssize_t find_separator(const char *line, const char *separators)
 622 {
 623         int whitespace_found = 0;
 624         const char *c;
 625         for (c = line; *c; c++) {
 626                 if (strchr(separators, *c))
 627                         return c - line;
 628                 if (!whitespace_found && (isalnum(*c) || *c == '-'))
 629                         continue;
 630                 if (c != line && (*c == ' ' || *c == '\t')) {
 631                         whitespace_found = 1;
 632                         continue;
 633                 }
 634                 break;
 635         }
 636         return -1;
 637 }
 638
 639 /*
 640  * Obtain the token, value, and conf from the given trailer.
 641  *
 642  * separator_pos must not be 0, since the token cannot be an empty string.
 643  *
 644  * If separator_pos is -1, interpret the whole trailer as a token.
 645  */
 646 static void parse_trailer(struct strbuf *tok, struct strbuf *val,
 647                          const struct conf_info **conf, const char *trailer,
 648                          ssize_t separator_pos)
 649 {
 650         struct arg_item *item;
 651         size_t tok_len;
 652         struct list_head *pos;
 653
 654         if (separator_pos != -1) {
 655                 strbuf_add(tok, trailer, separator_pos);
 656                 strbuf_trim(tok);
 657                 strbuf_addstr(val, trailer + separator_pos + 1);
 658                 strbuf_trim(val);
 659         } else {
 660                 strbuf_addstr(tok, trailer);
 661                 strbuf_trim(tok);
 662         }
 663
 664         /* Lookup if the token matches something in the config */
 665         tok_len = token_len_without_separator(tok->buf, tok->len);
 666         if (conf)
 667                 *conf = &default_conf_info;
 668         list_for_each(pos, &conf_head) {
 669                 item = list_entry(pos, struct arg_item, list);
 670                 if (token_matches_item(tok->buf, item, tok_len)) {
 671                         char *tok_buf = strbuf_detach(tok, NULL);
 672                         if (conf)
 673                                 *conf = &item->conf;
 674                         strbuf_addstr(tok, token_from_item(item, tok_buf));
 675                         free(tok_buf);
 676                         break;
 677                 }
 678         }
 679 }
 680
 681 static struct trailer_item *add_trailer_item(struct list_head *head, char *tok,
 682                                              char *val)
 683 {
 684         struct trailer_item *new_item = xcalloc(1, sizeof(*new_item));
 685         new_item->token = tok;
 686         new_item->value = val;
 687         list_add_tail(&new_item->list, head);
 688         return new_item;
 689 }
 690
 691 static void add_arg_item(struct list_head *arg_head, char *tok, char *val,
 692                          const struct conf_info *conf,
 693                          const struct new_trailer_item *new_trailer_item)
 694 {
 695         struct arg_item *new_item = xcalloc(1, sizeof(*new_item));
 696         new_item->token = tok;
 697         new_item->value = val;
 698         duplicate_conf(&new_item->conf, conf);
 699         if (new_trailer_item) {
 700                 if (new_trailer_item->where != WHERE_DEFAULT)
 701                         new_item->conf.where = new_trailer_item->where;
 702                 if (new_trailer_item->if_exists != EXISTS_DEFAULT)
 703                         new_item->conf.if_exists = new_trailer_item->if_exists;
 704                 if (new_trailer_item->if_missing != MISSING_DEFAULT)
 705                         new_item->conf.if_missing = new_trailer_item->if_missing;
 706         }
 707         list_add_tail(&new_item->list, arg_head);
 708 }
 709
 710 static void process_command_line_args(struct list_head *arg_head,
 711                                       struct list_head *new_trailer_head)
 712 {
 713         struct arg_item *item;
 714         struct strbuf tok = STRBUF_INIT;
 715         struct strbuf val = STRBUF_INIT;
 716         const struct conf_info *conf;
 717         struct list_head *pos;
 718
 719         /*
 720          * In command-line arguments, '=' is accepted (in addition to the
 721          * separators that are defined).
 722          */
 723         char *cl_separators = xstrfmt("=%s", separators);
 724
 725         /* Add an arg item for each configured trailer with a command */
 726         list_for_each(pos, &conf_head) {
 727                 item = list_entry(pos, struct arg_item, list);
 728                 if (item->conf.command)
 729                         add_arg_item(arg_head,
 730                                      xstrdup(token_from_item(item, NULL)),
 731                                      xstrdup(""),
 732                                      &item->conf, NULL);
 733         }
 734
 735         /* Add an arg item for each trailer on the command line */
 736         list_for_each(pos, new_trailer_head) {
 737                 struct new_trailer_item *tr =
 738                         list_entry(pos, struct new_trailer_item, list);
 739                 ssize_t separator_pos = find_separator(tr->text, cl_separators);
 740
 741                 if (separator_pos == 0) {
 742                         struct strbuf sb = STRBUF_INIT;
 743                         strbuf_addstr(&sb, tr->text);
 744                         strbuf_trim(&sb);
 745                         error(_("empty trailer token in trailer '%.*s'"),
 746                               (int) sb.len, sb.buf);
 747                         strbuf_release(&sb);
 748                 } else {
 749                         parse_trailer(&tok, &val, &conf, tr->text,
 750                                       separator_pos);
 751                         add_arg_item(arg_head,
 752                                      strbuf_detach(&tok, NULL),
 753                                      strbuf_detach(&val, NULL),
 754                                      conf, tr);
 755                 }
 756         }
 757
 758         free(cl_separators);
 759 }
 760
 761 static void read_input_file(struct strbuf *sb, const char *file)
 762 {
 763         if (file) {
 764                 if (strbuf_read_file(sb, file, 0) < 0)
 765                         die_errno(_("could not read input file '%s'"), file);
 766         } else {
 767                 if (strbuf_read(sb, fileno(stdin), 0) < 0)
 768                         die_errno(_("could not read from stdin"));
 769         }
 770 }
 771
 772 static const char *next_line(const char *str)
 773 {
 774         const char *nl = strchrnul(str, '\n');
 775         return nl + !!*nl;
 776 }
 777
 778 /*
 779  * Return the position of the start of the last line. If len is 0, return -1.
 780  */
 781 static ssize_t last_line(const char *buf, size_t len)
 782 {
 783         ssize_t i;
 784         if (len == 0)
 785                 return -1;
 786         if (len == 1)
 787                 return 0;
 788         /*
 789          * Skip the last character (in addition to the null terminator),
 790          * because if the last character is a newline, it is considered as part
 791          * of the last line anyway.
 792          */
 793         i = len - 2;
 794
 795         for (; i >= 0; i--) {
 796                 if (buf[i] == '\n')
 797                         return i + 1;
 798         }
 799         return 0;
 800 }
 801
 802 /*
 803  * Return the position of the start of the patch or the length of str if there
 804  * is no patch in the message.
 805  */
 806 static size_t find_patch_start(const char *str)
 807 {
 808         const char *s;
 809
 810         for (s = str; *s; s = next_line(s)) {
 811                 const char *v;
 812
 813                 if (skip_prefix(s, "---", &v) && isspace(*v))
 814                         return s - str;
 815         }
 816
 817         return s - str;
 818 }
 819
 820 /*
 821  * Return the position of the first trailer line or len if there are no
 822  * trailers.
 823  */
 824 static size_t find_trailer_start(const char *buf, size_t len)
 825 {
 826         const char *s;
 827         ssize_t end_of_title, l;
 828         int only_spaces = 1;
 829         int recognized_prefix = 0, trailer_lines = 0, non_trailer_lines = 0;
 830         /*
 831          * Number of possible continuation lines encountered. This will be
 832          * reset to 0 if we encounter a trailer (since those lines are to be
 833          * considered continuations of that trailer), and added to
 834          * non_trailer_lines if we encounter a non-trailer (since those lines
 835          * are to be considered non-trailers).
 836          */
 837         int possible_continuation_lines = 0;
 838
 839         /* The first paragraph is the title and cannot be trailers */
 840         for (s = buf; s < buf + len; s = next_line(s)) {
 841                 if (s[0] == comment_line_char)
 842                         continue;
 843                 if (is_blank_line(s))
 844                         break;
 845         }
 846         end_of_title = s - buf;
 847
 848         /*
 849          * Get the start of the trailers by looking starting from the end for a
 850          * blank line before a set of non-blank lines that (i) are all
 851          * trailers, or (ii) contains at least one Git-generated trailer and
 852          * consists of at least 25% trailers.
 853          */
 854         for (l = last_line(buf, len);
 855              l >= end_of_title;
 856              l = last_line(buf, l)) {
 857                 const char *bol = buf + l;
 858                 const char **p;
 859                 ssize_t separator_pos;
 860
 861                 if (bol[0] == comment_line_char) {
 862                         non_trailer_lines += possible_continuation_lines;
 863                         possible_continuation_lines = 0;
 864                         continue;
 865                 }
 866                 if (is_blank_line(bol)) {
 867                         if (only_spaces)
 868                                 continue;
 869                         non_trailer_lines += possible_continuation_lines;
 870                         if (recognized_prefix &&
 871                             trailer_lines * 3 >= non_trailer_lines)
 872                                 return next_line(bol) - buf;
 873                         else if (trailer_lines && !non_trailer_lines)
 874                                 return next_line(bol) - buf;
 875                         return len;
 876                 }
 877                 only_spaces = 0;
 878
 879                 for (p = git_generated_prefixes; *p; p++) {
 880                         if (starts_with(bol, *p)) {
 881                                 trailer_lines++;
 882                                 possible_continuation_lines = 0;
 883                                 recognized_prefix = 1;
 884                                 goto continue_outer_loop;
 885                         }
 886                 }
 887
 888                 separator_pos = find_separator(bol, separators);
 889                 if (separator_pos >= 1 && !isspace(bol[0])) {
 890                         struct list_head *pos;
 891
 892                         trailer_lines++;
 893                         possible_continuation_lines = 0;
 894                         if (recognized_prefix)
 895                                 continue;
 896                         list_for_each(pos, &conf_head) {
 897                                 struct arg_item *item;
 898                                 item = list_entry(pos, struct arg_item, list);
 899                                 if (token_matches_item(bol, item,
 900                                                        separator_pos)) {
 901                                         recognized_prefix = 1;
 902                                         break;
 903                                 }
 904                         }
 905                 } else if (isspace(bol[0]))
 906                         possible_continuation_lines++;
 907                 else {
 908                         non_trailer_lines++;
 909                         non_trailer_lines += possible_continuation_lines;
 910                         possible_continuation_lines = 0;
 911                 }
 912 continue_outer_loop:
 913                 ;
 914         }
 915
 916         return len;
 917 }
 918
 919 /* Return the position of the end of the trailers. */
 920 static size_t find_trailer_end(const char *buf, size_t len)
 921 {
 922         return len - ignore_non_trailer(buf, len);
 923 }
 924
 925 static int ends_with_blank_line(const char *buf, size_t len)
 926 {
 927         ssize_t ll = last_line(buf, len);
 928         if (ll < 0)
 929                 return 0;
 930         return is_blank_line(buf + ll);
 931 }
 932
 933 static void unfold_value(struct strbuf *val)
 934 {
 935         struct strbuf out = STRBUF_INIT;
 936         size_t i;
 937
 938         strbuf_grow(&out, val->len);
 939         i = 0;
 940         while (i < val->len) {
 941                 char c = val->buf[i++];
 942                 if (c == '\n') {
 943                         /* Collapse continuation down to a single space. */
 944                         while (i < val->len && isspace(val->buf[i]))
 945                                 i++;
 946                         strbuf_addch(&out, ' ');
 947                 } else {
 948                         strbuf_addch(&out, c);
 949                 }
 950         }
 951
 952         /* Empty lines may have left us with whitespace cruft at the edges */
 953         strbuf_trim(&out);
 954
 955         /* output goes back to val as if we modified it in-place */
 956         strbuf_swap(&out, val);
 957         strbuf_release(&out);
 958 }
 959
 960 static size_t process_input_file(FILE *outfile,
 961                                  const char *str,
 962                                  struct list_head *head,
 963                                  const struct process_trailer_options *opts)
 964 {
 965         struct trailer_info info;
 966         struct strbuf tok = STRBUF_INIT;
 967         struct strbuf val = STRBUF_INIT;
 968         size_t i;
 969
 970         trailer_info_get(&info, str, opts);
 971
 972         /* Print lines before the trailers as is */
 973         if (!opts->only_trailers)
 974                 fwrite(str, 1, info.trailer_start - str, outfile);
 975
 976         if (!opts->only_trailers && !info.blank_line_before_trailer)
 977                 fprintf(outfile, "\n");
 978
 979         for (i = 0; i < info.trailer_nr; i++) {
 980                 int separator_pos;
 981                 char *trailer = info.trailers[i];
 982                 if (trailer[0] == comment_line_char)
 983                         continue;
 984                 separator_pos = find_separator(trailer, separators);
 985                 if (separator_pos >= 1) {
 986                         parse_trailer(&tok, &val, NULL, trailer,
 987                                       separator_pos);
 988                         if (opts->unfold)
 989                                 unfold_value(&val);
 990                         add_trailer_item(head,
 991                                          strbuf_detach(&tok, NULL),
 992                                          strbuf_detach(&val, NULL));
 993                 } else if (!opts->only_trailers) {
 994                         strbuf_addstr(&val, trailer);
 995                         strbuf_strip_suffix(&val, "\n");
 996                         add_trailer_item(head,
 997                                          NULL,
 998                                          strbuf_detach(&val, NULL));
 999                 }
1000         }
1001
1002         trailer_info_release(&info);
1003
1004         return info.trailer_end - str;
1005 }
1006
1007 static void free_all(struct list_head *head)
1008 {
1009         struct list_head *pos, *p;
1010         list_for_each_safe(pos, p, head) {
1011                 list_del(pos);
1012                 free_trailer_item(list_entry(pos, struct trailer_item, list));
1013         }
1014 }
1015
1016 static struct tempfile *trailers_tempfile;
1017
1018 static FILE *create_in_place_tempfile(const char *file)
1019 {
1020         struct stat st;
1021         struct strbuf filename_template = STRBUF_INIT;
1022         const char *tail;
1023         FILE *outfile;
1024
1025         if (stat(file, &st))
1026                 die_errno(_("could not stat %s"), file);
1027         if (!S_ISREG(st.st_mode))
1028                 die(_("file %s is not a regular file"), file);
1029         if (!(st.st_mode & S_IWUSR))
1030                 die(_("file %s is not writable by user"), file);
1031
1032         /* Create temporary file in the same directory as the original */
1033         tail = strrchr(file, '/');
1034         if (tail)
1035                 strbuf_add(&filename_template, file, tail - file + 1);
1036         strbuf_addstr(&filename_template, "git-interpret-trailers-XXXXXX");
1037
1038         trailers_tempfile = xmks_tempfile_m(filename_template.buf, st.st_mode);
1039         strbuf_release(&filename_template);
1040         outfile = fdopen_tempfile(trailers_tempfile, "w");
1041         if (!outfile)
1042                 die_errno(_("could not open temporary file"));
1043
1044         return outfile;
1045 }
1046
1047 void process_trailers(const char *file,
1048                       const struct process_trailer_options *opts,
1049                       struct list_head *new_trailer_head)
1050 {
1051         LIST_HEAD(head);
1052         struct strbuf sb = STRBUF_INIT;
1053         size_t trailer_end;
1054         FILE *outfile = stdout;
1055
1056         ensure_configured();
1057
1058         read_input_file(&sb, file);
1059
1060         if (opts->in_place)
1061                 outfile = create_in_place_tempfile(file);
1062
1063         /* Print the lines before the trailers */
1064         trailer_end = process_input_file(outfile, sb.buf, &head, opts);
1065
1066         if (!opts->only_input) {
1067                 LIST_HEAD(arg_head);
1068                 process_command_line_args(&arg_head, new_trailer_head);
1069                 process_trailers_lists(&head, &arg_head);
1070         }
1071
1072         print_all(outfile, &head, opts);
1073
1074         free_all(&head);
1075
1076         /* Print the lines after the trailers as is */
1077         if (!opts->only_trailers)
1078                 fwrite(sb.buf + trailer_end, 1, sb.len - trailer_end, outfile);
1079
1080         if (opts->in_place)
1081                 if (rename_tempfile(&trailers_tempfile, file))
1082                         die_errno(_("could not rename temporary file to %s"), file);
1083
1084         strbuf_release(&sb);
1085 }
1086
1087 void trailer_info_get(struct trailer_info *info, const char *str,
1088                       const struct process_trailer_options *opts)
1089 {
1090         int patch_start, trailer_end, trailer_start;
1091         struct strbuf **trailer_lines, **ptr;
1092         char **trailer_strings = NULL;
1093         size_t nr = 0, alloc = 0;
1094         char **last = NULL;
1095
1096         ensure_configured();
1097
1098         if (opts->no_divider)
1099                 patch_start = strlen(str);
1100         else
1101                 patch_start = find_patch_start(str);
1102
1103         trailer_end = find_trailer_end(str, patch_start);
1104         trailer_start = find_trailer_start(str, trailer_end);
1105
1106         trailer_lines = strbuf_split_buf(str + trailer_start,
1107                                          trailer_end - trailer_start,
1108                                          '\n',
1109                                          0);
1110         for (ptr = trailer_lines; *ptr; ptr++) {
1111                 if (last && isspace((*ptr)->buf[0])) {
1112                         struct strbuf sb = STRBUF_INIT;
1113                         strbuf_attach(&sb, *last, strlen(*last), strlen(*last));
1114                         strbuf_addbuf(&sb, *ptr);
1115                         *last = strbuf_detach(&sb, NULL);
1116                         continue;
1117                 }
1118                 ALLOC_GROW(trailer_strings, nr + 1, alloc);
1119                 trailer_strings[nr] = strbuf_detach(*ptr, NULL);
1120                 last = find_separator(trailer_strings[nr], separators) >= 1
1121                         ? &trailer_strings[nr]
1122                         : NULL;
1123                 nr++;
1124         }
1125         strbuf_list_free(trailer_lines);
1126
1127         info->blank_line_before_trailer = ends_with_blank_line(str,
1128                                                                trailer_start);
1129         info->trailer_start = str + trailer_start;
1130         info->trailer_end = str + trailer_end;
1131         info->trailers = trailer_strings;
1132         info->trailer_nr = nr;
1133 }
1134
1135 void trailer_info_release(struct trailer_info *info)
1136 {
1137         size_t i;
1138         for (i = 0; i < info->trailer_nr; i++)
1139                 free(info->trailers[i]);
1140         free(info->trailers);
1141 }
1142
1143 static void format_trailer_info(struct strbuf *out,
1144                                 const struct trailer_info *info,
1145                                 const struct process_trailer_options *opts)
1146 {
1147         size_t origlen = out->len;
1148         size_t i;
1149
1150         /* If we want the whole block untouched, we can take the fast path. */
1151         if (!opts->only_trailers && !opts->unfold && !opts->filter &&
1152             !opts->separator && !opts->key_only && !opts->value_only &&
1153             !opts->key_value_separator) {
1154                 strbuf_add(out, info->trailer_start,
1155                            info->trailer_end - info->trailer_start);
1156                 return;
1157         }
1158
1159         for (i = 0; i < info->trailer_nr; i++) {
1160                 char *trailer = info->trailers[i];
1161                 ssize_t separator_pos = find_separator(trailer, separators);
1162
1163                 if (separator_pos >= 1) {
1164                         struct strbuf tok = STRBUF_INIT;
1165                         struct strbuf val = STRBUF_INIT;
1166
1167                         parse_trailer(&tok, &val, NULL, trailer, separator_pos);
1168                         if (!opts->filter || opts->filter(&tok, opts->filter_data)) {
1169                                 if (opts->unfold)
1170                                         unfold_value(&val);
1171
1172                                 if (opts->separator && out->len != origlen)
1173                                         strbuf_addbuf(out, opts->separator);
1174                                 if (!opts->value_only)
1175                                         strbuf_addbuf(out, &tok);
1176                                 if (!opts->key_only && !opts->value_only) {
1177                                         if (opts->key_value_separator)
1178                                                 strbuf_addbuf(out, opts->key_value_separator);
1179                                         else
1180                                                 strbuf_addstr(out, ": ");
1181                                 }
1182                                 if (!opts->key_only)
1183                                         strbuf_addbuf(out, &val);
1184                                 if (!opts->separator)
1185                                         strbuf_addch(out, '\n');
1186                         }
1187                         strbuf_release(&tok);
1188                         strbuf_release(&val);
1189
1190                 } else if (!opts->only_trailers) {
1191                         if (opts->separator && out->len != origlen) {
1192                                 strbuf_addbuf(out, opts->separator);
1193                         }
1194                         strbuf_addstr(out, trailer);
1195                         if (opts->separator) {
1196                                 strbuf_rtrim(out);
1197                         }
1198                 }
1199         }
1200
1201 }
1202
1203 void format_trailers_from_commit(struct strbuf *out, const char *msg,
1204                                  const struct process_trailer_options *opts)
1205 {
1206         struct trailer_info info;
1207
1208         trailer_info_get(&info, msg, opts);
1209         format_trailer_info(out, &info, opts);
1210         trailer_info_release(&info);
1211 }
1212
1213 void trailer_iterator_init(struct trailer_iterator *iter, const char *msg)
1214 {
1215         struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
1216         strbuf_init(&iter->key, 0);
1217         strbuf_init(&iter->val, 0);
1218         opts.no_divider = 1;
1219         trailer_info_get(&iter->info, msg, &opts);
1220         iter->cur = 0;
1221 }
1222
1223 int trailer_iterator_advance(struct trailer_iterator *iter)
1224 {
1225         while (iter->cur < iter->info.trailer_nr) {
1226                 char *trailer = iter->info.trailers[iter->cur++];
1227                 int separator_pos = find_separator(trailer, separators);
1228
1229                 if (separator_pos < 1)
1230                         continue; /* not a real trailer */
1231
1232                 strbuf_reset(&iter->key);
1233                 strbuf_reset(&iter->val);
1234                 parse_trailer(&iter->key, &iter->val, NULL,
1235                               trailer, separator_pos);
1236                 unfold_value(&iter->val);
1237                 return 1;
1238         }
1239         return 0;
1240 }
1241
1242 void trailer_iterator_release(struct trailer_iterator *iter)
1243 {
1244         trailer_info_release(&iter->info);
1245         strbuf_release(&iter->val);
1246         strbuf_release(&iter->key);
1247 }