src/diff_file.c

   1 /*
   2  * Copyright (C) the libgit2 contributors. All rights reserved.
   3  *
   4  * This file is part of libgit2, distributed under the GNU GPL v2 with
   5  * a Linking Exception. For full terms see the included COPYING file.
   6  */
   7 #include "common.h"
   8 #include "git2/blob.h"
   9 #include "git2/submodule.h"
  10 #include "diff.h"
  11 #include "diff_file.h"
  12 #include "odb.h"
  13 #include "fileops.h"
  14 #include "filter.h"
  15
  16 #define DIFF_MAX_FILESIZE 0x20000000
  17
  18 static bool diff_file_content_binary_by_size(git_diff_file_content *fc)
  19 {
  20         /* if we have diff opts, check max_size vs file size */
  21         if ((fc->file->flags & DIFF_FLAGS_KNOWN_BINARY) == 0 &&
  22                 fc->opts_max_size > 0 &&
  23                 fc->file->size > fc->opts_max_size)
  24                 fc->file->flags |= GIT_DIFF_FLAG_BINARY;
  25
  26         return ((fc->file->flags & GIT_DIFF_FLAG_BINARY) != 0);
  27 }
  28
  29 static void diff_file_content_binary_by_content(git_diff_file_content *fc)
  30 {
  31         if ((fc->file->flags & DIFF_FLAGS_KNOWN_BINARY) != 0)
  32                 return;
  33
  34         switch (git_diff_driver_content_is_binary(
  35                 fc->driver, fc->map.data, fc->map.len)) {
  36         case 0: fc->file->flags |= GIT_DIFF_FLAG_NOT_BINARY; break;
  37         case 1: fc->file->flags |= GIT_DIFF_FLAG_BINARY; break;
  38         default: break;
  39         }
  40 }
  41
  42 static int diff_file_content_init_common(
  43         git_diff_file_content *fc, const git_diff_options *opts)
  44 {
  45         fc->opts_flags = opts ? opts->flags : GIT_DIFF_NORMAL;
  46
  47         if (opts && opts->max_size >= 0)
  48                 fc->opts_max_size = opts->max_size ?
  49                         opts->max_size : DIFF_MAX_FILESIZE;
  50
  51         if (fc->src == GIT_ITERATOR_TYPE_EMPTY)
  52                 fc->src = GIT_ITERATOR_TYPE_TREE;
  53
  54         if (!fc->driver &&
  55                 git_diff_driver_lookup(&fc->driver, fc->repo, fc->file->path) < 0)
  56                 return -1;
  57
  58         /* give driver a chance to modify options */
  59         git_diff_driver_update_options(&fc->opts_flags, fc->driver);
  60
  61         /* make sure file is conceivable mmap-able */
  62         if ((git_off_t)((size_t)fc->file->size) != fc->file->size)
  63                 fc->file->flags |= GIT_DIFF_FLAG_BINARY;
  64         /* check if user is forcing text diff the file */
  65         else if (fc->opts_flags & GIT_DIFF_FORCE_TEXT) {
  66                 fc->file->flags &= ~GIT_DIFF_FLAG_BINARY;
  67                 fc->file->flags |= GIT_DIFF_FLAG_NOT_BINARY;
  68         }
  69         /* check if user is forcing binary diff the file */
  70         else if (fc->opts_flags & GIT_DIFF_FORCE_BINARY) {
  71                 fc->file->flags &= ~GIT_DIFF_FLAG_NOT_BINARY;
  72                 fc->file->flags |= GIT_DIFF_FLAG_BINARY;
  73         }
  74
  75         diff_file_content_binary_by_size(fc);
  76
  77         if ((fc->flags & GIT_DIFF_FLAG__NO_DATA) != 0) {
  78                 fc->flags |= GIT_DIFF_FLAG__LOADED;
  79                 fc->map.len  = 0;
  80                 fc->map.data = "";
  81         }
  82
  83         if ((fc->flags & GIT_DIFF_FLAG__LOADED) != 0)
  84                 diff_file_content_binary_by_content(fc);
  85
  86         return 0;
  87 }
  88
  89 int git_diff_file_content__init_from_diff(
  90         git_diff_file_content *fc,
  91         git_diff *diff,
  92         size_t delta_index,
  93         bool use_old)
  94 {
  95         git_diff_delta *delta = git_vector_get(&diff->deltas, delta_index);
  96         bool has_data = true;
  97
  98         memset(fc, 0, sizeof(*fc));
  99         fc->repo = diff->repo;
 100         fc->file = use_old ? &delta->old_file : &delta->new_file;
 101         fc->src  = use_old ? diff->old_src : diff->new_src;
 102
 103         if (git_diff_driver_lookup(&fc->driver, fc->repo, fc->file->path) < 0)
 104                 return -1;
 105
 106         switch (delta->status) {
 107         case GIT_DELTA_ADDED:
 108                 has_data = !use_old; break;
 109         case GIT_DELTA_DELETED:
 110                 has_data = use_old; break;
 111         case GIT_DELTA_UNTRACKED:
 112                 has_data = !use_old &&
 113                         (diff->opts.flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) != 0;
 114                 break;
 115         case GIT_DELTA_MODIFIED:
 116         case GIT_DELTA_COPIED:
 117         case GIT_DELTA_RENAMED:
 118                 break;
 119         default:
 120                 has_data = false;
 121                 break;
 122         }
 123
 124         if (!has_data)
 125                 fc->flags |= GIT_DIFF_FLAG__NO_DATA;
 126
 127         return diff_file_content_init_common(fc, &diff->opts);
 128 }
 129
 130 int git_diff_file_content__init_from_src(
 131         git_diff_file_content *fc,
 132         git_repository *repo,
 133         const git_diff_options *opts,
 134         const git_diff_file_content_src *src,
 135         git_diff_file *as_file)
 136 {
 137         memset(fc, 0, sizeof(*fc));
 138         fc->repo = repo;
 139         fc->file = as_file;
 140         fc->blob = src->blob;
 141
 142         if (!src->blob && !src->buf) {
 143                 fc->flags |= GIT_DIFF_FLAG__NO_DATA;
 144         } else {
 145                 fc->flags |= GIT_DIFF_FLAG__LOADED;
 146                 fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 147                 fc->file->mode = GIT_FILEMODE_BLOB;
 148
 149                 if (src->blob) {
 150                         fc->file->size = git_blob_rawsize(src->blob);
 151                         git_oid_cpy(&fc->file->id, git_blob_id(src->blob));
 152
 153                         fc->map.len  = (size_t)fc->file->size;
 154                         fc->map.data = (char *)git_blob_rawcontent(src->blob);
 155                 } else {
 156                         fc->file->size = src->buflen;
 157                         git_odb_hash(&fc->file->id, src->buf, src->buflen, GIT_OBJ_BLOB);
 158
 159                         fc->map.len  = src->buflen;
 160                         fc->map.data = (char *)src->buf;
 161                 }
 162         }
 163
 164         return diff_file_content_init_common(fc, opts);
 165 }
 166
 167 static int diff_file_content_commit_to_str(
 168         git_diff_file_content *fc, bool check_status)
 169 {
 170         char oid[GIT_OID_HEXSZ+1];
 171         git_buf content = GIT_BUF_INIT;
 172         const char *status = "";
 173
 174         if (check_status) {
 175                 int error = 0;
 176                 git_submodule *sm = NULL;
 177                 unsigned int sm_status = 0;
 178                 const git_oid *sm_head;
 179
 180                 if ((error = git_submodule_lookup(&sm, fc->repo, fc->file->path)) < 0) {
 181                         /* GIT_EEXISTS means a "submodule" that has not been git added */
 182                         if (error == GIT_EEXISTS) {
 183                                 giterr_clear();
 184                                 error = 0;
 185                         }
 186                         return error;
 187                 }
 188
 189                 if ((error = git_submodule_status(&sm_status, sm)) < 0) {
 190                         git_submodule_free(sm);
 191                         return error;
 192                 }
 193
 194                 /* update OID if we didn't have it previously */
 195                 if ((fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0 &&
 196                         ((sm_head = git_submodule_wd_id(sm)) != NULL ||
 197                          (sm_head = git_submodule_head_id(sm)) != NULL))
 198                 {
 199                         git_oid_cpy(&fc->file->id, sm_head);
 200                         fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 201                 }
 202
 203                 if (GIT_SUBMODULE_STATUS_IS_WD_DIRTY(sm_status))
 204                         status = "-dirty";
 205
 206                 git_submodule_free(sm);
 207         }
 208
 209         git_oid_tostr(oid, sizeof(oid), &fc->file->id);
 210         if (git_buf_printf(&content, "Subproject commit %s%s\n", oid, status) < 0)
 211                 return -1;
 212
 213         fc->map.len  = git_buf_len(&content);
 214         fc->map.data = git_buf_detach(&content);
 215         fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 216
 217         return 0;
 218 }
 219
 220 static int diff_file_content_load_blob(git_diff_file_content *fc)
 221 {
 222         int error = 0;
 223         git_odb_object *odb_obj = NULL;
 224
 225         if (git_oid_iszero(&fc->file->id))
 226                 return 0;
 227
 228         if (fc->file->mode == GIT_FILEMODE_COMMIT)
 229                 return diff_file_content_commit_to_str(fc, false);
 230
 231         /* if we don't know size, try to peek at object header first */
 232         if (!fc->file->size) {
 233                 if ((error = git_diff_file__resolve_zero_size(
 234                                 fc->file, &odb_obj, fc->repo)) < 0)
 235                         return error;
 236         }
 237
 238         if (diff_file_content_binary_by_size(fc))
 239                 return 0;
 240
 241         if (odb_obj != NULL) {
 242                 error = git_object__from_odb_object(
 243                         (git_object **)&fc->blob, fc->repo, odb_obj, GIT_OBJ_BLOB);
 244                 git_odb_object_free(odb_obj);
 245         } else {
 246                 error = git_blob_lookup(
 247                         (git_blob **)&fc->blob, fc->repo, &fc->file->id);
 248         }
 249
 250         if (!error) {
 251                 fc->flags |= GIT_DIFF_FLAG__FREE_BLOB;
 252                 fc->map.data = (void *)git_blob_rawcontent(fc->blob);
 253                 fc->map.len  = (size_t)git_blob_rawsize(fc->blob);
 254         }
 255
 256         return error;
 257 }
 258
 259 static int diff_file_content_load_workdir_symlink(
 260         git_diff_file_content *fc, git_buf *path)
 261 {
 262         ssize_t alloc_len, read_len;
 263
 264         /* link path on disk could be UTF-16, so prepare a buffer that is
 265          * big enough to handle some UTF-8 data expansion
 266          */
 267         alloc_len = (ssize_t)(fc->file->size * 2) + 1;
 268
 269         fc->map.data = git__calloc(alloc_len, sizeof(char));
 270         GITERR_CHECK_ALLOC(fc->map.data);
 271
 272         fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 273
 274         read_len = p_readlink(git_buf_cstr(path), fc->map.data, alloc_len);
 275         if (read_len < 0) {
 276                 giterr_set(GITERR_OS, "Failed to read symlink '%s'", fc->file->path);
 277                 return -1;
 278         }
 279
 280         fc->map.len = read_len;
 281         return 0;
 282 }
 283
 284 static int diff_file_content_load_workdir_file(
 285         git_diff_file_content *fc, git_buf *path)
 286 {
 287         int error = 0;
 288         git_filter_list *fl = NULL;
 289         git_file fd = git_futils_open_ro(git_buf_cstr(path));
 290         git_buf raw = GIT_BUF_INIT;
 291
 292         if (fd < 0)
 293                 return fd;
 294
 295         if (!fc->file->size &&
 296                 !(fc->file->size = git_futils_filesize(fd)))
 297                 goto cleanup;
 298
 299         if (diff_file_content_binary_by_size(fc))
 300                 goto cleanup;
 301
 302         if ((error = git_filter_list_load(
 303                         &fl, fc->repo, NULL, fc->file->path, GIT_FILTER_TO_ODB)) < 0)
 304                 goto cleanup;
 305
 306         /* if there are no filters, try to mmap the file */
 307         if (fl == NULL) {
 308                 if (!(error = git_futils_mmap_ro(
 309                                 &fc->map, fd, 0, (size_t)fc->file->size))) {
 310                         fc->flags |= GIT_DIFF_FLAG__UNMAP_DATA;
 311                         goto cleanup;
 312                 }
 313
 314                 /* if mmap failed, fall through to try readbuffer below */
 315                 giterr_clear();
 316         }
 317
 318         if (!(error = git_futils_readbuffer_fd(&raw, fd, (size_t)fc->file->size))) {
 319                 git_buf out = GIT_BUF_INIT;
 320
 321                 error = git_filter_list_apply_to_data(&out, fl, &raw);
 322
 323                 if (out.ptr != raw.ptr)
 324                         git_buf_free(&raw);
 325
 326                 if (!error) {
 327                         fc->map.len  = out.size;
 328                         fc->map.data = out.ptr;
 329                         fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 330                 }
 331         }
 332
 333 cleanup:
 334         git_filter_list_free(fl);
 335         p_close(fd);
 336
 337         return error;
 338 }
 339
 340 static int diff_file_content_load_workdir(git_diff_file_content *fc)
 341 {
 342         int error = 0;
 343         git_buf path = GIT_BUF_INIT;
 344
 345         if (fc->file->mode == GIT_FILEMODE_COMMIT)
 346                 return diff_file_content_commit_to_str(fc, true);
 347
 348         if (fc->file->mode == GIT_FILEMODE_TREE)
 349                 return 0;
 350
 351         if (git_buf_joinpath(
 352                         &path, git_repository_workdir(fc->repo), fc->file->path) < 0)
 353                 return -1;
 354
 355         if (S_ISLNK(fc->file->mode))
 356                 error = diff_file_content_load_workdir_symlink(fc, &path);
 357         else
 358                 error = diff_file_content_load_workdir_file(fc, &path);
 359
 360         /* once data is loaded, update OID if we didn't have it previously */
 361         if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0) {
 362                 error = git_odb_hash(
 363                         &fc->file->id, fc->map.data, fc->map.len, GIT_OBJ_BLOB);
 364                 fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 365         }
 366
 367         git_buf_free(&path);
 368         return error;
 369 }
 370
 371 int git_diff_file_content__load(git_diff_file_content *fc)
 372 {
 373         int error = 0;
 374
 375         if ((fc->flags & GIT_DIFF_FLAG__LOADED) != 0)
 376                 return 0;
 377
 378         if ((fc->file->flags & GIT_DIFF_FLAG_BINARY) != 0)
 379                 return 0;
 380
 381         if (fc->src == GIT_ITERATOR_TYPE_WORKDIR)
 382                 error = diff_file_content_load_workdir(fc);
 383         else
 384                 error = diff_file_content_load_blob(fc);
 385         if (error)
 386                 return error;
 387
 388         fc->flags |= GIT_DIFF_FLAG__LOADED;
 389
 390         diff_file_content_binary_by_content(fc);
 391
 392         return 0;
 393 }
 394
 395 void git_diff_file_content__unload(git_diff_file_content *fc)
 396 {
 397         if ((fc->flags & GIT_DIFF_FLAG__LOADED) == 0)
 398                 return;
 399
 400         if (fc->flags & GIT_DIFF_FLAG__FREE_DATA) {
 401                 git__free(fc->map.data);
 402                 fc->map.data = "";
 403                 fc->map.len  = 0;
 404                 fc->flags &= ~GIT_DIFF_FLAG__FREE_DATA;
 405         }
 406         else if (fc->flags & GIT_DIFF_FLAG__UNMAP_DATA) {
 407                 git_futils_mmap_free(&fc->map);
 408                 fc->map.data = "";
 409                 fc->map.len  = 0;
 410                 fc->flags &= ~GIT_DIFF_FLAG__UNMAP_DATA;
 411         }
 412
 413         if (fc->flags & GIT_DIFF_FLAG__FREE_BLOB) {
 414                 git_blob_free((git_blob *)fc->blob);
 415                 fc->blob = NULL;
 416                 fc->flags &= ~GIT_DIFF_FLAG__FREE_BLOB;
 417         }
 418
 419         fc->flags &= ~GIT_DIFF_FLAG__LOADED;
 420 }
 421
 422 void git_diff_file_content__clear(git_diff_file_content *fc)
 423 {
 424         git_diff_file_content__unload(fc);
 425
 426         /* for now, nothing else to do */
 427 }