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_UNREADABLE:
 116         case GIT_DELTA_MODIFIED:
 117         case GIT_DELTA_COPIED:
 118         case GIT_DELTA_RENAMED:
 119                 break;
 120         default:
 121                 has_data = false;
 122                 break;
 123         }
 124
 125         if (!has_data)
 126                 fc->flags |= GIT_DIFF_FLAG__NO_DATA;
 127
 128         return diff_file_content_init_common(fc, &diff->opts);
 129 }
 130
 131 int git_diff_file_content__init_from_src(
 132         git_diff_file_content *fc,
 133         git_repository *repo,
 134         const git_diff_options *opts,
 135         const git_diff_file_content_src *src,
 136         git_diff_file *as_file)
 137 {
 138         memset(fc, 0, sizeof(*fc));
 139         fc->repo = repo;
 140         fc->file = as_file;
 141         fc->blob = src->blob;
 142
 143         if (!src->blob && !src->buf) {
 144                 fc->flags |= GIT_DIFF_FLAG__NO_DATA;
 145         } else {
 146                 fc->flags |= GIT_DIFF_FLAG__LOADED;
 147                 fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 148                 fc->file->mode = GIT_FILEMODE_BLOB;
 149
 150                 if (src->blob) {
 151                         fc->file->size = git_blob_rawsize(src->blob);
 152                         git_oid_cpy(&fc->file->id, git_blob_id(src->blob));
 153
 154                         fc->map.len  = (size_t)fc->file->size;
 155                         fc->map.data = (char *)git_blob_rawcontent(src->blob);
 156                 } else {
 157                         fc->file->size = src->buflen;
 158                         git_odb_hash(&fc->file->id, src->buf, src->buflen, GIT_OBJ_BLOB);
 159
 160                         fc->map.len  = src->buflen;
 161                         fc->map.data = (char *)src->buf;
 162                 }
 163         }
 164
 165         return diff_file_content_init_common(fc, opts);
 166 }
 167
 168 static int diff_file_content_commit_to_str(
 169         git_diff_file_content *fc, bool check_status)
 170 {
 171         char oid[GIT_OID_HEXSZ+1];
 172         git_buf content = GIT_BUF_INIT;
 173         const char *status = "";
 174
 175         if (check_status) {
 176                 int error = 0;
 177                 git_submodule *sm = NULL;
 178                 unsigned int sm_status = 0;
 179                 const git_oid *sm_head;
 180
 181                 if ((error = git_submodule_lookup(&sm, fc->repo, fc->file->path)) < 0) {
 182                         /* GIT_EEXISTS means a "submodule" that has not been git added */
 183                         if (error == GIT_EEXISTS) {
 184                                 giterr_clear();
 185                                 error = 0;
 186                         }
 187                         return error;
 188                 }
 189
 190                 if ((error = git_submodule_status(&sm_status, sm)) < 0) {
 191                         git_submodule_free(sm);
 192                         return error;
 193                 }
 194
 195                 /* update OID if we didn't have it previously */
 196                 if ((fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0 &&
 197                         ((sm_head = git_submodule_wd_id(sm)) != NULL ||
 198                          (sm_head = git_submodule_head_id(sm)) != NULL))
 199                 {
 200                         git_oid_cpy(&fc->file->id, sm_head);
 201                         fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 202                 }
 203
 204                 if (GIT_SUBMODULE_STATUS_IS_WD_DIRTY(sm_status))
 205                         status = "-dirty";
 206
 207                 git_submodule_free(sm);
 208         }
 209
 210         git_oid_tostr(oid, sizeof(oid), &fc->file->id);
 211         if (git_buf_printf(&content, "Subproject commit %s%s\n", oid, status) < 0)
 212                 return -1;
 213
 214         fc->map.len  = git_buf_len(&content);
 215         fc->map.data = git_buf_detach(&content);
 216         fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 217
 218         return 0;
 219 }
 220
 221 static int diff_file_content_load_blob(git_diff_file_content *fc)
 222 {
 223         int error = 0;
 224         git_odb_object *odb_obj = NULL;
 225
 226         if (git_oid_iszero(&fc->file->id))
 227                 return 0;
 228
 229         if (fc->file->mode == GIT_FILEMODE_COMMIT)
 230                 return diff_file_content_commit_to_str(fc, false);
 231
 232         /* if we don't know size, try to peek at object header first */
 233         if (!fc->file->size) {
 234                 if ((error = git_diff_file__resolve_zero_size(
 235                                 fc->file, &odb_obj, fc->repo)) < 0)
 236                         return error;
 237         }
 238
 239         if (diff_file_content_binary_by_size(fc))
 240                 return 0;
 241
 242         if (odb_obj != NULL) {
 243                 error = git_object__from_odb_object(
 244                         (git_object **)&fc->blob, fc->repo, odb_obj, GIT_OBJ_BLOB);
 245                 git_odb_object_free(odb_obj);
 246         } else {
 247                 error = git_blob_lookup(
 248                         (git_blob **)&fc->blob, fc->repo, &fc->file->id);
 249         }
 250
 251         if (!error) {
 252                 fc->flags |= GIT_DIFF_FLAG__FREE_BLOB;
 253                 fc->map.data = (void *)git_blob_rawcontent(fc->blob);
 254                 fc->map.len  = (size_t)git_blob_rawsize(fc->blob);
 255         }
 256
 257         return error;
 258 }
 259
 260 static int diff_file_content_load_workdir_symlink(
 261         git_diff_file_content *fc, git_buf *path)
 262 {
 263         ssize_t alloc_len, read_len;
 264
 265         /* link path on disk could be UTF-16, so prepare a buffer that is
 266          * big enough to handle some UTF-8 data expansion
 267          */
 268         alloc_len = (ssize_t)(fc->file->size * 2) + 1;
 269
 270         fc->map.data = git__calloc(alloc_len, sizeof(char));
 271         GITERR_CHECK_ALLOC(fc->map.data);
 272
 273         fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 274
 275         read_len = p_readlink(git_buf_cstr(path), fc->map.data, alloc_len);
 276         if (read_len < 0) {
 277                 giterr_set(GITERR_OS, "Failed to read symlink '%s'", fc->file->path);
 278                 return -1;
 279         }
 280
 281         fc->map.len = read_len;
 282         return 0;
 283 }
 284
 285 static int diff_file_content_load_workdir_file(
 286         git_diff_file_content *fc, git_buf *path)
 287 {
 288         int error = 0;
 289         git_filter_list *fl = NULL;
 290         git_file fd = git_futils_open_ro(git_buf_cstr(path));
 291         git_buf raw = GIT_BUF_INIT;
 292
 293         if (fd < 0)
 294                 return fd;
 295
 296         if (!fc->file->size &&
 297                 !(fc->file->size = git_futils_filesize(fd)))
 298                 goto cleanup;
 299
 300         if (diff_file_content_binary_by_size(fc))
 301                 goto cleanup;
 302
 303         if ((error = git_filter_list_load(
 304                         &fl, fc->repo, NULL, fc->file->path,
 305                         GIT_FILTER_TO_ODB, GIT_FILTER_OPT_ALLOW_UNSAFE)) < 0)
 306                 goto cleanup;
 307
 308         /* if there are no filters, try to mmap the file */
 309         if (fl == NULL) {
 310                 if (!(error = git_futils_mmap_ro(
 311                                 &fc->map, fd, 0, (size_t)fc->file->size))) {
 312                         fc->flags |= GIT_DIFF_FLAG__UNMAP_DATA;
 313                         goto cleanup;
 314                 }
 315
 316                 /* if mmap failed, fall through to try readbuffer below */
 317                 giterr_clear();
 318         }
 319
 320         if (!(error = git_futils_readbuffer_fd(&raw, fd, (size_t)fc->file->size))) {
 321                 git_buf out = GIT_BUF_INIT;
 322
 323                 error = git_filter_list_apply_to_data(&out, fl, &raw);
 324
 325                 if (out.ptr != raw.ptr)
 326                         git_buf_free(&raw);
 327
 328                 if (!error) {
 329                         fc->map.len  = out.size;
 330                         fc->map.data = out.ptr;
 331                         fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 332                 }
 333         }
 334
 335 cleanup:
 336         git_filter_list_free(fl);
 337         p_close(fd);
 338
 339         return error;
 340 }
 341
 342 static int diff_file_content_load_workdir(git_diff_file_content *fc)
 343 {
 344         int error = 0;
 345         git_buf path = GIT_BUF_INIT;
 346
 347         if (fc->file->mode == GIT_FILEMODE_COMMIT)
 348                 return diff_file_content_commit_to_str(fc, true);
 349
 350         if (fc->file->mode == GIT_FILEMODE_TREE)
 351                 return 0;
 352
 353         if (git_buf_joinpath(
 354                         &path, git_repository_workdir(fc->repo), fc->file->path) < 0)
 355                 return -1;
 356
 357         if (S_ISLNK(fc->file->mode))
 358                 error = diff_file_content_load_workdir_symlink(fc, &path);
 359         else
 360                 error = diff_file_content_load_workdir_file(fc, &path);
 361
 362         /* once data is loaded, update OID if we didn't have it previously */
 363         if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0) {
 364                 error = git_odb_hash(
 365                         &fc->file->id, fc->map.data, fc->map.len, GIT_OBJ_BLOB);
 366                 fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 367         }
 368
 369         git_buf_free(&path);
 370         return error;
 371 }
 372
 373 int git_diff_file_content__load(git_diff_file_content *fc)
 374 {
 375         int error = 0;
 376
 377         if ((fc->flags & GIT_DIFF_FLAG__LOADED) != 0)
 378                 return 0;
 379
 380         if ((fc->file->flags & GIT_DIFF_FLAG_BINARY) != 0)
 381                 return 0;
 382
 383         if (fc->src == GIT_ITERATOR_TYPE_WORKDIR)
 384                 error = diff_file_content_load_workdir(fc);
 385         else
 386                 error = diff_file_content_load_blob(fc);
 387         if (error)
 388                 return error;
 389
 390         fc->flags |= GIT_DIFF_FLAG__LOADED;
 391
 392         diff_file_content_binary_by_content(fc);
 393
 394         return 0;
 395 }
 396
 397 void git_diff_file_content__unload(git_diff_file_content *fc)
 398 {
 399         if ((fc->flags & GIT_DIFF_FLAG__LOADED) == 0)
 400                 return;
 401
 402         if (fc->flags & GIT_DIFF_FLAG__FREE_DATA) {
 403                 git__free(fc->map.data);
 404                 fc->map.data = "";
 405                 fc->map.len  = 0;
 406                 fc->flags &= ~GIT_DIFF_FLAG__FREE_DATA;
 407         }
 408         else if (fc->flags & GIT_DIFF_FLAG__UNMAP_DATA) {
 409                 git_futils_mmap_free(&fc->map);
 410                 fc->map.data = "";
 411                 fc->map.len  = 0;
 412                 fc->flags &= ~GIT_DIFF_FLAG__UNMAP_DATA;
 413         }
 414
 415         if (fc->flags & GIT_DIFF_FLAG__FREE_BLOB) {
 416                 git_blob_free((git_blob *)fc->blob);
 417                 fc->blob = NULL;
 418                 fc->flags &= ~GIT_DIFF_FLAG__FREE_BLOB;
 419         }
 420
 421         fc->flags &= ~GIT_DIFF_FLAG__LOADED;
 422 }
 423
 424 void git_diff_file_content__clear(git_diff_file_content *fc)
 425 {
 426         git_diff_file_content__unload(fc);
 427
 428         /* for now, nothing else to do */
 429 }