trailer.c

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