Merge branch 'jc/apply-ws-fix-expands' into maint
authorJunio C Hamano <gitster@pobox.com>
Wed, 25 Feb 2015 06:10:41 +0000 (22:10 -0800)
committerJunio C Hamano <gitster@pobox.com>
Wed, 25 Feb 2015 06:10:41 +0000 (22:10 -0800)
"git apply --whitespace=fix" used to under-allocate the memory
when the fix resulted in a longer text than the original patch.

* jc/apply-ws-fix-expands:
  apply: count the size of postimage correctly
  apply: make update_pre_post_images() sanity check the given postlen
  apply.c: typofix

1  2 
builtin/apply.c

diff --combined builtin/apply.c
@@@ -7,7 -7,6 +7,7 @@@
   *
   */
  #include "cache.h"
 +#include "lockfile.h"
  #include "cache-tree.h"
  #include "quote.h"
  #include "blob.h"
@@@ -436,7 -435,7 +436,7 @@@ static unsigned long linelen(const cha
  
  static int is_dev_null(const char *str)
  {
 -      return !memcmp("/dev/null", str, 9) && isspace(str[9]);
 +      return skip_prefix(str, "/dev/null", &str) && isspace(*str);
  }
  
  #define TERM_SPACE    1
@@@ -657,6 -656,11 +657,6 @@@ static size_t diff_timestamp_len(const 
        return line + len - end;
  }
  
 -static char *null_strdup(const char *s)
 -{
 -      return s ? xstrdup(s) : NULL;
 -}
 -
  static char *find_name_common(const char *line, const char *def,
                              int p_value, const char *end, int terminate)
  {
                        start = line;
        }
        if (!start)
 -              return squash_slash(null_strdup(def));
 +              return squash_slash(xstrdup_or_null(def));
        len = line - start;
        if (!len)
 -              return squash_slash(null_strdup(def));
 +              return squash_slash(xstrdup_or_null(def));
  
        /*
         * Generally we prefer the shorter name, especially
@@@ -904,7 -908,7 +904,7 @@@ static void parse_traditional_patch(con
                        patch->old_name = name;
                } else {
                        patch->old_name = name;
 -                      patch->new_name = null_strdup(name);
 +                      patch->new_name = xstrdup_or_null(name);
                }
        }
        if (!name)
@@@ -993,7 -997,7 +993,7 @@@ static int gitdiff_delete(const char *l
  {
        patch->is_delete = 1;
        free(patch->old_name);
 -      patch->old_name = null_strdup(patch->def_name);
 +      patch->old_name = xstrdup_or_null(patch->def_name);
        return gitdiff_oldmode(line, patch);
  }
  
@@@ -1001,7 -1005,7 +1001,7 @@@ static int gitdiff_newfile(const char *
  {
        patch->is_new = 1;
        free(patch->new_name);
 -      patch->new_name = null_strdup(patch->def_name);
 +      patch->new_name = xstrdup_or_null(patch->def_name);
        return gitdiff_newmode(line, patch);
  }
  
@@@ -1071,7 -1075,7 +1071,7 @@@ static int gitdiff_index(const char *li
  
        line = ptr + 2;
        ptr = strchr(line, ' ');
 -      eol = strchr(line, '\n');
 +      eol = strchrnul(line, '\n');
  
        if (!ptr || eol < ptr)
                ptr = eol;
@@@ -1277,7 -1281,9 +1277,7 @@@ static int parse_git_header(const char 
         */
        patch->def_name = git_header_name(line, len);
        if (patch->def_name && root) {
 -              char *s = xmalloc(root_len + strlen(patch->def_name) + 1);
 -              strcpy(s, root);
 -              strcpy(s + root_len, patch->def_name);
 +              char *s = xstrfmt("%s%s", root, patch->def_name);
                free(patch->def_name);
                patch->def_name = s;
        }
@@@ -1916,66 -1922,6 +1916,66 @@@ static int parse_binary(char *buffer, u
        return used;
  }
  
 +static void prefix_one(char **name)
 +{
 +      char *old_name = *name;
 +      if (!old_name)
 +              return;
 +      *name = xstrdup(prefix_filename(prefix, prefix_length, *name));
 +      free(old_name);
 +}
 +
 +static void prefix_patch(struct patch *p)
 +{
 +      if (!prefix || p->is_toplevel_relative)
 +              return;
 +      prefix_one(&p->new_name);
 +      prefix_one(&p->old_name);
 +}
 +
 +/*
 + * include/exclude
 + */
 +
 +static struct string_list limit_by_name;
 +static int has_include;
 +static void add_name_limit(const char *name, int exclude)
 +{
 +      struct string_list_item *it;
 +
 +      it = string_list_append(&limit_by_name, name);
 +      it->util = exclude ? NULL : (void *) 1;
 +}
 +
 +static int use_patch(struct patch *p)
 +{
 +      const char *pathname = p->new_name ? p->new_name : p->old_name;
 +      int i;
 +
 +      /* Paths outside are not touched regardless of "--include" */
 +      if (0 < prefix_length) {
 +              int pathlen = strlen(pathname);
 +              if (pathlen <= prefix_length ||
 +                  memcmp(prefix, pathname, prefix_length))
 +                      return 0;
 +      }
 +
 +      /* See if it matches any of exclude/include rule */
 +      for (i = 0; i < limit_by_name.nr; i++) {
 +              struct string_list_item *it = &limit_by_name.items[i];
 +              if (!wildmatch(it->string, pathname, 0, NULL))
 +                      return (it->util != NULL);
 +      }
 +
 +      /*
 +       * If we had any include, a path that does not match any rule is
 +       * not used.  Otherwise, we saw bunch of exclude rules (or none)
 +       * and such a path is used.
 +       */
 +      return !has_include;
 +}
 +
 +
  /*
   * Read the patch text in "buffer" that extends for "size" bytes; stop
   * reading after seeing a single patch (i.e. changes to a single file).
@@@ -1991,14 -1937,9 +1991,14 @@@ static int parse_chunk(char *buffer, un
        if (offset < 0)
                return offset;
  
 -      patch->ws_rule = whitespace_rule(patch->new_name
 -                                       ? patch->new_name
 -                                       : patch->old_name);
 +      prefix_patch(patch);
 +
 +      if (!use_patch(patch))
 +              patch->ws_rule = 0;
 +      else
 +              patch->ws_rule = whitespace_rule(patch->new_name
 +                                               ? patch->new_name
 +                                               : patch->old_name);
  
        patchsize = parse_single_patch(buffer + offset + hdrsize,
                                       size - offset - hdrsize, patch);
@@@ -2230,6 -2171,12 +2230,12 @@@ static void update_pre_post_images(stru
                ctx++;
        }
  
+       if (postlen
+           ? postlen < new - postimage->buf
+           : postimage->len < new - postimage->buf)
+               die("BUG: caller miscounted postlen: asked %d, orig = %d, used = %d",
+                   (int)postlen, (int) postimage->len, (int)(new - postimage->buf));
        /* Fix the length of the whole thing */
        postimage->len = new - postimage->buf;
        postimage->nr -= reduced;
@@@ -2385,10 -2332,27 +2391,27 @@@ static int match_fragment(struct image 
  
        /*
         * The hunk does not apply byte-by-byte, but the hash says
-        * it might with whitespace fuzz. We haven't been asked to
+        * it might with whitespace fuzz. We weren't asked to
         * ignore whitespace, we were asked to correct whitespace
         * errors, so let's try matching after whitespace correction.
         *
+        * While checking the preimage against the target, whitespace
+        * errors in both fixed, we count how large the corresponding
+        * postimage needs to be.  The postimage prepared by
+        * apply_one_fragment() has whitespace errors fixed on added
+        * lines already, but the common lines were propagated as-is,
+        * which may become longer when their whitespace errors are
+        * fixed.
+        */
+       /* First count added lines in postimage */
+       postlen = 0;
+       for (i = 0; i < postimage->nr; i++) {
+               if (!(postimage->line[i].flag & LINE_COMMON))
+                       postlen += postimage->line[i].len;
+       }
+       /*
         * The preimage may extend beyond the end of the file,
         * but in this loop we will only handle the part of the
         * preimage that falls within the file.
        strbuf_init(&fixed, preimage->len + 1);
        orig = preimage->buf;
        target = img->buf + try;
-       postlen = 0;
        for (i = 0; i < preimage_limit; i++) {
                size_t oldlen = preimage->line[i].len;
                size_t tgtlen = img->line[try_lno + i].len;
                match = (tgtfix.len == fixed.len - fixstart &&
                         !memcmp(tgtfix.buf, fixed.buf + fixstart,
                                             fixed.len - fixstart));
-               postlen += tgtfix.len;
+               /* Add the length if this is common with the postimage */
+               if (preimage->line[i].flag & LINE_COMMON)
+                       postlen += tgtfix.len;
  
                strbuf_release(&tgtfix);
                if (!match)
@@@ -2622,7 -2588,7 +2647,7 @@@ static void update_image(struct image *
                 * NOTE: this knows that we never call remove_first_line()
                 * on anything other than pre/post image.
                 */
 -              img->line = xrealloc(img->line, nr * sizeof(*img->line));
 +              REALLOC_ARRAY(img->line, nr);
                img->line_allocated = img->line;
        }
        if (preimage_limit != postimage->nr)
@@@ -3143,15 -3109,13 +3168,15 @@@ static void prepare_fn_table(struct pat
        }
  }
  
 -static int checkout_target(struct cache_entry *ce, struct stat *st)
 +static int checkout_target(struct index_state *istate,
 +                         struct cache_entry *ce, struct stat *st)
  {
        struct checkout costate;
  
        memset(&costate, 0, sizeof(costate));
        costate.base_dir = "";
        costate.refresh_cache = 1;
 +      costate.istate = istate;
        if (checkout_entry(ce, &costate, NULL) || lstat(ce->name, st))
                return error(_("cannot checkout %s"), ce->name);
        return 0;
@@@ -3318,7 -3282,7 +3343,7 @@@ static int load_current(struct image *i
        if (lstat(name, &st)) {
                if (errno != ENOENT)
                        return error(_("%s: %s"), name, strerror(errno));
 -              if (checkout_target(ce, &st))
 +              if (checkout_target(&the_index, ce, &st))
                        return -1;
        }
        if (verify_index_match(ce, &st))
@@@ -3472,7 -3436,7 +3497,7 @@@ static int check_preimage(struct patch 
                }
                *ce = active_cache[pos];
                if (stat_ret < 0) {
 -                      if (checkout_target(*ce, st))
 +                      if (checkout_target(&the_index, *ce, st))
                                return -1;
                }
                if (!cached && verify_index_match(*ce, st))
@@@ -3705,7 -3669,7 +3730,7 @@@ static void build_fake_ancestor(struct 
  {
        struct patch *patch;
        struct index_state result = { NULL };
 -      int fd;
 +      static struct lock_file lock;
  
        /* Once we start supporting the reverse patch, it may be
         * worth showing the new sha1 prefix, but until then...
                        if (!preimage_sha1_in_gitlink_patch(patch, sha1))
                                ; /* ok, the textual part looks sane */
                        else
 -                              die("sha1 information is lacking or useless for submoule %s",
 +                              die("sha1 information is lacking or useless for submodule %s",
                                    name);
                } else if (!get_sha1_blob(patch->old_sha1_prefix, sha1)) {
                        ; /* ok */
                        die ("Could not add %s to temporary index", name);
        }
  
 -      fd = open(filename, O_WRONLY | O_CREAT, 0666);
 -      if (fd < 0 || write_index(&result, fd) || close(fd))
 +      hold_lock_file_for_update(&lock, filename, LOCK_DIE_ON_ERROR);
 +      if (write_locked_index(&result, &lock, COMMIT_LOCK))
                die ("Could not write temporary index to %s", filename);
  
        discard_index(&result);
@@@ -3906,10 -3870,9 +3931,10 @@@ static void add_index_file(const char *
        ce->ce_flags = create_ce_flags(0);
        ce->ce_namelen = namelen;
        if (S_ISGITLINK(mode)) {
 -              const char *s = buf;
 +              const char *s;
  
 -              if (get_sha1_hex(s + strlen("Subproject commit "), ce->sha1))
 +              if (!skip_prefix(buf, "Subproject commit ", &s) ||
 +                  get_sha1_hex(s, ce->sha1))
                        die(_("corrupt patch for submodule %s"), path);
        } else {
                if (!cached) {
@@@ -4175,7 -4138,7 +4200,7 @@@ static int write_out_results(struct pat
        if (cpath.nr) {
                struct string_list_item *item;
  
 -              sort_string_list(&cpath);
 +              string_list_sort(&cpath);
                for_each_string_list_item(item, &cpath)
                        fprintf(stderr, "U %s\n", item->string);
                string_list_clear(&cpath, 0);
  
  static struct lock_file lock_file;
  
 -static struct string_list limit_by_name;
 -static int has_include;
 -static void add_name_limit(const char *name, int exclude)
 -{
 -      struct string_list_item *it;
 -
 -      it = string_list_append(&limit_by_name, name);
 -      it->util = exclude ? NULL : (void *) 1;
 -}
 -
 -static int use_patch(struct patch *p)
 -{
 -      const char *pathname = p->new_name ? p->new_name : p->old_name;
 -      int i;
 -
 -      /* Paths outside are not touched regardless of "--include" */
 -      if (0 < prefix_length) {
 -              int pathlen = strlen(pathname);
 -              if (pathlen <= prefix_length ||
 -                  memcmp(prefix, pathname, prefix_length))
 -                      return 0;
 -      }
 -
 -      /* See if it matches any of exclude/include rule */
 -      for (i = 0; i < limit_by_name.nr; i++) {
 -              struct string_list_item *it = &limit_by_name.items[i];
 -              if (!wildmatch(it->string, pathname, 0, NULL))
 -                      return (it->util != NULL);
 -      }
 -
 -      /*
 -       * If we had any include, a path that does not match any rule is
 -       * not used.  Otherwise, we saw bunch of exclude rules (or none)
 -       * and such a path is used.
 -       */
 -      return !has_include;
 -}
 -
 -
 -static void prefix_one(char **name)
 -{
 -      char *old_name = *name;
 -      if (!old_name)
 -              return;
 -      *name = xstrdup(prefix_filename(prefix, prefix_length, *name));
 -      free(old_name);
 -}
 -
 -static void prefix_patches(struct patch *p)
 -{
 -      if (!prefix || p->is_toplevel_relative)
 -              return;
 -      for ( ; p; p = p->next) {
 -              prefix_one(&p->new_name);
 -              prefix_one(&p->old_name);
 -      }
 -}
 -
  #define INACCURATE_EOF        (1<<0)
  #define RECOUNT               (1<<1)
  
@@@ -4213,6 -4234,8 +4238,6 @@@ static int apply_patch(int fd, const ch
                        break;
                if (apply_in_reverse)
                        reverse_patches(patch);
 -              if (prefix)
 -                      prefix_patches(patch);
                if (use_patch(patch)) {
                        patch_stats(patch);
                        *listp = patch;
        return 0;
  }
  
 -static int git_apply_config(const char *var, const char *value, void *cb)
 +static void git_apply_config(void)
  {
 -      if (!strcmp(var, "apply.whitespace"))
 -              return git_config_string(&apply_default_whitespace, var, value);
 -      else if (!strcmp(var, "apply.ignorewhitespace"))
 -              return git_config_string(&apply_default_ignorewhitespace, var, value);
 -      return git_default_config(var, value, cb);
 +      git_config_get_string_const("apply.whitespace", &apply_default_whitespace);
 +      git_config_get_string_const("apply.ignorewhitespace", &apply_default_ignorewhitespace);
 +      git_config(git_default_config, NULL);
  }
  
  static int option_parse_exclude(const struct option *opt,
@@@ -4422,7 -4447,7 +4447,7 @@@ int cmd_apply(int argc, const char **ar
  
        prefix = prefix_;
        prefix_length = prefix ? strlen(prefix) : 0;
 -      git_config(git_apply_config, NULL);
 +      git_apply_config();
        if (apply_default_whitespace)
                parse_whitespace_option(apply_default_whitespace);
        if (apply_default_ignorewhitespace)
        }
  
        if (update_index) {
 -              if (write_cache(newfd, active_cache, active_nr) ||
 -                  commit_locked_index(&lock_file))
 +              if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
                        die(_("Unable to write new index file"));
        }