src/Git/GitIndex.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2012 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19
  20 #include "StdAfx.h"
  21 #include "Git.h"
  22 #include "atlconv.h"
  23 #include "GitRev.h"
  24 #include "registry.h"
  25 #include "GitConfig.h"
  26 #include <map>
  27 #include "UnicodeUtils.h"
  28 #include "TGitPath.h"
  29 #include "gitindex.h"
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include "git2.h"
  33 #include "SmartHandle.h"
  34
  35 class CAutoReadLock
  36 {
  37         SharedMutex *m_Lock;
  38 public:
  39         CAutoReadLock(SharedMutex * lock)
  40         {
  41                 m_Lock = lock;
  42                 lock->AcquireShared();
  43         }
  44         ~CAutoReadLock()
  45         {
  46                 m_Lock->ReleaseShared();
  47         }
  48 };
  49
  50 class CAutoWriteLock
  51 {
  52         SharedMutex *m_Lock;
  53 public:
  54         CAutoWriteLock(SharedMutex * lock)
  55         {
  56                 m_Lock = lock;
  57                 lock->AcquireExclusive();
  58         }
  59         ~CAutoWriteLock()
  60         {
  61                 m_Lock->ReleaseExclusive();
  62         }
  63 };
  64
  65 CGitAdminDirMap g_AdminDirMap;
  66
  67 int CGitIndex::Print()
  68 {
  69         _tprintf(_T("0x%08X  0x%08X %s %s\n"),
  70                 (int)this->m_ModifyTime,
  71                 this->m_Flags,
  72                 this->m_IndexHash.ToString(),
  73                 this->m_FileName);
  74
  75         return 0;
  76 }
  77
  78 CGitIndexList::CGitIndexList()
  79 {
  80         this->m_LastModifyTime = 0;
  81 }
  82
  83 static bool SortIndex(CGitIndex &Item1, CGitIndex &Item2)
  84 {
  85         return Item1.m_FileName.Compare(Item2.m_FileName) < 0;
  86 }
  87
  88 static bool SortTree(CGitTreeItem &Item1, CGitTreeItem &Item2)
  89 {
  90         return Item1.m_FileName.Compare(Item2.m_FileName) < 0;
  91 }
  92
  93 int CGitIndexList::ReadIndex(CString dgitdir)
  94 {
  95         this->clear();
  96
  97         CStringA gitdir = CUnicodeUtils::GetMulti(dgitdir, CP_UTF8);
  98         git_repository *repository = NULL;
  99         git_index *index = NULL;
 100
 101         int ret = git_repository_open(&repository, gitdir.GetBuffer());
 102         gitdir.ReleaseBuffer();
 103         if (ret)
 104                 return -1;
 105
 106         if (git_repository_index(&index, repository))
 107         {
 108                 git_repository_free(repository);
 109                 return -1;
 110         }
 111
 112         unsigned int ecount = git_index_entrycount(index);
 113         resize(ecount);
 114         for (unsigned int i = 0; i < ecount; ++i)
 115         {
 116                 git_index_entry *e = git_index_get(index, i);
 117
 118                 this->at(i).m_FileName.Empty();
 119                 g_Git.StringAppend(&this->at(i).m_FileName, (BYTE*)e->path, CP_UTF8);
 120                 this->at(i).m_FileName.MakeLower();
 121                 this->at(i).m_ModifyTime = e->mtime.seconds;
 122                 this->at(i).m_Flags = e->flags | e->flags_extended;
 123                 this->at(i).m_IndexHash = (char *) e->oid.id;
 124         }
 125
 126         git_index_free(index);
 127         git_repository_free(repository);
 128
 129         g_Git.GetFileModifyTime(dgitdir + _T("index"), &this->m_LastModifyTime);
 130         std::sort(this->begin(), this->end(), SortIndex);
 131
 132         return 0;
 133 }
 134
 135 int CGitIndexList::GetFileStatus(const CString &gitdir,const CString &pathorg,git_wc_status_kind *status,__int64 time,FIll_STATUS_CALLBACK callback,void *pData, CGitHash *pHash, bool * assumeValid, bool * skipWorktree)
 136 {
 137         if(status)
 138         {
 139                 CString path = pathorg;
 140                 path.MakeLower();
 141
 142                 int start = SearchInSortVector(*this, ((CString&)path).GetBuffer(), -1);
 143                 ((CString&)path).ReleaseBuffer();
 144
 145                 if (start < 0)
 146                 {
 147                         *status = git_wc_status_unversioned;
 148                         if (pHash)
 149                                 pHash->Empty();
 150
 151                 }
 152                 else
 153                 {
 154                         int index = start;
 155                         if (index <0)
 156                                 return -1;
 157                         if (index >= size() )
 158                                 return -1;
 159
 160                         // skip-worktree has higher priority than assume-valid
 161                         if (at(index).m_Flags & GIT_IDXENTRY_SKIP_WORKTREE)
 162                         {
 163                                 *status = git_wc_status_normal;
 164                                 if (skipWorktree)
 165                                         *skipWorktree = true;
 166                         }
 167                         else if (at(index).m_Flags & GIT_IDXENTRY_VALID)
 168                         {
 169                                 *status = git_wc_status_normal;
 170                                 if (assumeValid)
 171                                         *assumeValid = true;
 172                         }
 173                         else if (time == at(index).m_ModifyTime)
 174                         {
 175                                 *status = git_wc_status_normal;
 176                         }
 177                         else
 178                         {
 179                                 *status = git_wc_status_modified;
 180                         }
 181
 182                         if (at(index).m_Flags & GIT_IDXENTRY_STAGEMASK)
 183                                 *status = git_wc_status_conflicted;
 184                         else if (at(index).m_Flags & GIT_IDXENTRY_INTENT_TO_ADD)
 185                                 *status = git_wc_status_added;
 186
 187                         if(pHash)
 188                                 *pHash = at(index).m_IndexHash;
 189                 }
 190
 191         }
 192
 193         if(callback && status)
 194                         callback(gitdir + _T("\\") + pathorg, *status, false, pData, *assumeValid, *skipWorktree);
 195         return 0;
 196 }
 197
 198 int CGitIndexList::GetStatus(const CString &gitdir,const CString &pathParam, git_wc_status_kind *status,
 199                                                          BOOL IsFull, BOOL IsRecursive,
 200                                                          FIll_STATUS_CALLBACK callback,void *pData,
 201                                                          CGitHash *pHash, bool * assumeValid, bool * skipWorktree)
 202 {
 203         int result;
 204         git_wc_status_kind dirstatus = git_wc_status_none;
 205         __int64 time;
 206         bool isDir = false;
 207         CString path = pathParam;
 208
 209         if (status)
 210         {
 211                 if (path.IsEmpty())
 212                         result = g_Git.GetFileModifyTime(gitdir, &time, &isDir);
 213                 else
 214                         result = g_Git.GetFileModifyTime(gitdir + _T("\\") + path, &time, &isDir);
 215
 216                 if (result)
 217                 {
 218                         *status = git_wc_status_deleted;
 219                         if (callback)
 220                                 callback(gitdir + _T("\\") + path, git_wc_status_deleted, false, pData, *assumeValid, *skipWorktree);
 221
 222                         return 0;
 223                 }
 224                 if (isDir)
 225                 {
 226                         if (!path.IsEmpty())
 227                         {
 228                                 if (path.Right(1) != _T("\\"))
 229                                         path += _T("\\");
 230                         }
 231                         int len = path.GetLength();
 232
 233                                 for (int i = 0; i < size(); i++)
 234                                 {
 235                                         if (at(i).m_FileName.GetLength() > len)
 236                                         {
 237                                                 if (at(i).m_FileName.Left(len) == path)
 238                                                 {
 239                                                         if (!IsFull)
 240                                                         {
 241                                                                 *status = git_wc_status_normal;
 242                                                                 if (callback)
 243                                                                         callback(gitdir + _T("\\") + path, *status, false, pData, (at(i).m_Flags & GIT_IDXENTRY_VALID) && !(at(i).m_Flags & GIT_IDXENTRY_SKIP_WORKTREE), at(i).m_Flags & GIT_IDXENTRY_SKIP_WORKTREE);
 244                                                                 return 0;
 245
 246                                                         }
 247                                                         else
 248                                                         {
 249                                                                 result = g_Git.GetFileModifyTime(gitdir+_T("\\") + at(i).m_FileName, &time);
 250                                                                 if (result)
 251                                                                         continue;
 252
 253                                                                 *status = git_wc_status_none;
 254                                                                 if (assumeValid)
 255                                                                         *assumeValid = false;
 256                                                                 if (skipWorktree)
 257                                                                         *skipWorktree = false;
 258                                                                 GetFileStatus(gitdir, at(i).m_FileName, status, time, callback, pData, NULL, assumeValid, skipWorktree);
 259                                                                 // if a file is assumed valid, we need to inform the caller, otherwise the assumevalid flag might not get to the explorer on first open of a repository
 260                                                                 if (callback && (assumeValid || skipWorktree))
 261                                                                         callback(gitdir + _T("\\") + path, *status, false, pData, *assumeValid, *skipWorktree);
 262                                                                 if (*status != git_wc_status_none)
 263                                                                 {
 264                                                                         if (dirstatus == git_wc_status_none)
 265                                                                         {
 266                                                                                 dirstatus = git_wc_status_normal;
 267                                                                         }
 268                                                                         if (*status != git_wc_status_normal)
 269                                                                         {
 270                                                                                 dirstatus = git_wc_status_modified;
 271                                                                         }
 272                                                                 }
 273
 274                                                         }
 275                                                 }
 276                                         }
 277                                 } /* End For */
 278
 279                         if (dirstatus != git_wc_status_none)
 280                         {
 281                                 *status = dirstatus;
 282                         }
 283                         else
 284                         {
 285                                 *status = git_wc_status_unversioned;
 286                         }
 287                         if(callback)
 288                                 callback(gitdir + _T("\\") + path, *status, false, pData, false, false);
 289
 290                         return 0;
 291
 292                 }
 293                 else
 294                 {
 295                         GetFileStatus(gitdir, path, status, time, callback, pData, pHash, assumeValid, skipWorktree);
 296                 }
 297         }
 298         return 0;
 299 }
 300
 301 int CGitIndexFileMap::Check(const CString &gitdir, bool *isChanged)
 302 {
 303         __int64 time;
 304         int result;
 305
 306         CString IndexFile = g_AdminDirMap.GetAdminDir(gitdir) + _T("index");
 307
 308         /* Get data associated with "crt_stat.c": */
 309         result = g_Git.GetFileModifyTime(IndexFile, &time);
 310
 311         if (result)
 312                 return result;
 313
 314         SHARED_INDEX_PTR pIndex;
 315         pIndex = this->SafeGet(gitdir);
 316
 317         if (pIndex.get() == NULL)
 318         {
 319                 if(isChanged)
 320                         *isChanged = true;
 321                 return 0;
 322         }
 323
 324         if (pIndex->m_LastModifyTime == time)
 325         {
 326                 if (isChanged)
 327                         *isChanged = false;
 328         }
 329         else
 330         {
 331                 if (isChanged)
 332                         *isChanged = true;
 333         }
 334         return 0;
 335 }
 336
 337 int CGitIndexFileMap::LoadIndex(const CString &gitdir)
 338 {
 339         try
 340         {
 341                 SHARED_INDEX_PTR pIndex(new CGitIndexList);
 342
 343                 if(pIndex->ReadIndex(g_AdminDirMap.GetAdminDir(gitdir)))
 344                         return -1;
 345
 346                 this->SafeSet(gitdir, pIndex);
 347
 348         }catch(...)
 349         {
 350                 return -1;
 351         }
 352         return 0;
 353 }
 354
 355 int CGitIndexFileMap::GetFileStatus(const CString &gitdir, const CString &path, git_wc_status_kind *status,BOOL IsFull, BOOL IsRecursive,
 356                                                                         FIll_STATUS_CALLBACK callback,void *pData,
 357                                                                         CGitHash *pHash,
 358                                                                         bool isLoadUpdatedIndex, bool * assumeValid, bool * skipWorktree)
 359 {
 360         try
 361         {
 362                 CheckAndUpdate(gitdir, isLoadUpdatedIndex);
 363
 364                 SHARED_INDEX_PTR pIndex = this->SafeGet(gitdir);
 365                 if (pIndex.get() != NULL)
 366                 {
 367                         pIndex->GetStatus(gitdir, path, status, IsFull, IsRecursive, callback, pData, pHash, assumeValid, skipWorktree);
 368                 }
 369                 else
 370                 {
 371                         // git working tree has not index
 372                         *status = git_wc_status_unversioned;
 373                 }
 374         }
 375         catch(...)
 376         {
 377                 return -1;
 378         }
 379         return 0;
 380 }
 381
 382 int CGitIndexFileMap::IsUnderVersionControl(const CString &gitdir, const CString &path, bool isDir,bool *isVersion, bool isLoadUpdateIndex)
 383 {
 384         try
 385         {
 386                 if (path.IsEmpty())
 387                 {
 388                         *isVersion = true;
 389                         return 0;
 390                 }
 391
 392                 CString subpath = path;
 393                 subpath.Replace(_T('\\'), _T('/'));
 394                 if(isDir)
 395                         subpath += _T('/');
 396
 397                 subpath.MakeLower();
 398
 399                 CheckAndUpdate(gitdir, isLoadUpdateIndex);
 400
 401                 SHARED_INDEX_PTR pIndex = this->SafeGet(gitdir);
 402
 403                 if(pIndex.get())
 404                 {
 405                         if(isDir)
 406                                 *isVersion = (SearchInSortVector(*pIndex, subpath.GetBuffer(), subpath.GetLength()) >= 0);
 407                         else
 408                                 *isVersion = (SearchInSortVector(*pIndex, subpath.GetBuffer(), -1) >= 0);
 409                         subpath.ReleaseBuffer();
 410                 }
 411
 412         }catch(...)
 413         {
 414                 return -1;
 415         }
 416         return 0;
 417 }
 418
 419 int CGitHeadFileList::GetPackRef(const CString &gitdir)
 420 {
 421         CString PackRef = g_AdminDirMap.GetAdminDir(gitdir) + _T("packed-refs");
 422
 423         __int64 mtime;
 424         if (g_Git.GetFileModifyTime(PackRef, &mtime))
 425         {
 426                 CAutoWriteLock lock(&this->m_SharedMutex);
 427                 //packed refs is not existed
 428                 this->m_PackRefFile.Empty();
 429                 this->m_PackRefMap.clear();
 430                 return 0;
 431         }
 432         else if(mtime == m_LastModifyTimePackRef)
 433         {
 434                 return 0;
 435         }
 436         else
 437         {
 438                 CAutoWriteLock lock(&this->m_SharedMutex);
 439                 this->m_PackRefFile = PackRef;
 440                 this->m_LastModifyTimePackRef = mtime;
 441         }
 442
 443         int ret = 0;
 444         {
 445                 CAutoWriteLock lock(&this->m_SharedMutex);
 446                 this->m_PackRefMap.clear();
 447
 448                 CAutoFile hfile = CreateFile(PackRef,
 449                         GENERIC_READ,
 450                         FILE_SHARE_READ|FILE_SHARE_DELETE|FILE_SHARE_WRITE,
 451                         NULL,
 452                         OPEN_EXISTING,
 453                         FILE_ATTRIBUTE_NORMAL,
 454                         NULL);
 455                 do
 456                 {
 457                         if (!hfile)
 458                         {
 459                                 ret = -1;
 460                                 break;
 461                         }
 462
 463                         DWORD filesize = GetFileSize(hfile, NULL);
 464                         DWORD size =0;
 465                         char *buff;
 466                         buff = new char[filesize];
 467
 468                         ReadFile(hfile, buff, filesize, &size, NULL);
 469
 470                         if (size != filesize)
 471                         {
 472                                 ret = -1;
 473                                 break;
 474                         }
 475
 476                         CString hash;
 477                         CString ref;
 478
 479                         for(DWORD i=0;i<filesize;)
 480                         {
 481                                 hash.Empty();
 482                                 ref.Empty();
 483                                 if (buff[i] == '#' || buff[i] == '^')
 484                                 {
 485                                         while (buff[i] != '\n')
 486                                         {
 487                                                 i++;
 488                                                 if (i == filesize)
 489                                                         break;
 490                                         }
 491                                         i++;
 492                                 }
 493
 494                                 if (i >= filesize)
 495                                         break;
 496
 497                                 while (buff[i] != ' ')
 498                                 {
 499                                         hash.AppendChar(buff[i]);
 500                                         i++;
 501                                         if (i == filesize)
 502                                                 break;
 503                                 }
 504
 505                                 i++;
 506                                 if (i >= filesize)
 507                                         break;
 508
 509                                 while (buff[i] != '\n')
 510                                 {
 511                                         ref.AppendChar(buff[i]);
 512                                         i++;
 513                                         if (i == filesize)
 514                                                 break;
 515                                 }
 516
 517                                 if (!ref.IsEmpty() )
 518                                 {
 519                                         this->m_PackRefMap[ref] = hash;
 520                                 }
 521
 522                                 while (buff[i] == '\n')
 523                                 {
 524                                         i++;
 525                                         if (i == filesize)
 526                                                 break;
 527                                 }
 528                         }
 529
 530                         delete buff;
 531
 532                 } while(0);
 533         }
 534         return ret;
 535
 536 }
 537 int CGitHeadFileList::ReadHeadHash(CString gitdir)
 538 {
 539         int ret = 0;
 540         CAutoWriteLock lock(&this->m_SharedMutex);
 541         m_Gitdir = g_AdminDirMap.GetAdminDir(gitdir);
 542
 543         m_HeadFile = m_Gitdir + _T("HEAD");
 544
 545         if( g_Git.GetFileModifyTime(m_HeadFile, &m_LastModifyTimeHead))
 546                 return -1;
 547
 548         try
 549         {
 550                 do
 551                 {
 552                         CAutoFile hfile = CreateFile(m_HeadFile,
 553                                 GENERIC_READ,
 554                                 FILE_SHARE_READ|FILE_SHARE_DELETE|FILE_SHARE_WRITE,
 555                                 NULL,
 556                                 OPEN_EXISTING,
 557                                 FILE_ATTRIBUTE_NORMAL,
 558                                 NULL);
 559
 560                         if (!hfile)
 561                         {
 562                                 ret = -1;
 563                                 break;
 564                         }
 565
 566                         DWORD size = 0,filesize = 0;
 567                         unsigned char buffer[40] ;
 568                         ReadFile(hfile, buffer, 4, &size, NULL);
 569                         if (size != 4)
 570                         {
 571                                 ret = -1;
 572                                 break;
 573                         }
 574                         buffer[4]=0;
 575                         if (strcmp((const char*)buffer,"ref:") == 0)
 576                         {
 577                                 filesize = GetFileSize(hfile, NULL);
 578
 579                                 unsigned char *p = (unsigned char*)malloc(filesize -4);
 580
 581                                 ReadFile(hfile, p, filesize - 4, &size, NULL);
 582
 583                                 m_HeadRefFile.Empty();
 584                                 g_Git.StringAppend(&this->m_HeadRefFile, p, CP_UTF8, filesize - 4);
 585                                 CString ref = this->m_HeadRefFile;
 586                                 ref = ref.Trim();
 587                                 int start = 0;
 588                                 ref = ref.Tokenize(_T("\n"), start);
 589                                 free(p);
 590                                 m_HeadRefFile = m_Gitdir + m_HeadRefFile.Trim();
 591                                 m_HeadRefFile.Replace(_T('/'),_T('\\'));
 592
 593                                 __int64 time;
 594                                 if (g_Git.GetFileModifyTime(m_HeadRefFile, &time, NULL))
 595                                 {
 596                                         m_HeadRefFile.Empty();
 597                                         if (GetPackRef(gitdir))
 598                                         {
 599                                                 ret = -1;
 600                                                 break;
 601                                         }
 602                                         if (this->m_PackRefMap.find(ref) == m_PackRefMap.end())
 603                                         {
 604                                                 ret = -1;
 605                                                 break;
 606                                         }
 607                                         this ->m_Head = m_PackRefMap[ref];
 608                                         ret = 0;
 609                                         break;
 610                                 }
 611
 612                                 CAutoFile href = CreateFile(m_HeadRefFile,
 613                                         GENERIC_READ,
 614                                         FILE_SHARE_READ|FILE_SHARE_DELETE|FILE_SHARE_WRITE,
 615                                         NULL,
 616                                         OPEN_EXISTING,
 617                                         FILE_ATTRIBUTE_NORMAL,
 618                                         NULL);
 619
 620                                 if (!href)
 621                                 {
 622                                         m_HeadRefFile.Empty();
 623
 624                                         if (GetPackRef(gitdir))
 625                                         {
 626                                                 ret = -1;
 627                                                 break;
 628                                         }
 629
 630                                         if (this->m_PackRefMap.find(ref) == m_PackRefMap.end())
 631                                         {
 632                                                 ret = -1;
 633                                                 break;
 634                                         }
 635                                         this ->m_Head = m_PackRefMap[ref];
 636                                         ret = 0;
 637                                         break;
 638                                 }
 639                                 ReadFile(href, buffer, 40, &size, NULL);
 640                                 if (size != 40)
 641                                 {
 642                                         ret = -1;
 643                                         break;
 644                                 }
 645                                 this->m_Head.ConvertFromStrA((char*)buffer);
 646
 647                                 this->m_LastModifyTimeRef = time;
 648
 649                         }
 650                         else
 651                         {
 652                                 ReadFile(hfile, buffer + 4, 40 - 4, &size, NULL);
 653                                 if(size != 36)
 654                                 {
 655                                         ret = -1;
 656                                         break;
 657                                 }
 658                                 m_HeadRefFile.Empty();
 659
 660                                 this->m_Head.ConvertFromStrA((char*)buffer);
 661                         }
 662                 } while(0);
 663         }
 664         catch(...)
 665         {
 666                 ret = -1;
 667         }
 668
 669         return ret;
 670 }
 671
 672 bool CGitHeadFileList::CheckHeadUpdate()
 673 {
 674         CAutoReadLock lock(&m_SharedMutex);
 675         if (this->m_HeadFile.IsEmpty())
 676                 return true;
 677
 678         __int64 mtime=0;
 679
 680         if (g_Git.GetFileModifyTime(m_HeadFile, &mtime))
 681                 return true;
 682
 683         if (mtime != this->m_LastModifyTimeHead)
 684                 return true;
 685
 686         if (!this->m_HeadRefFile.IsEmpty())
 687         {
 688                 if (g_Git.GetFileModifyTime(m_HeadRefFile, &mtime))
 689                         return true;
 690
 691                 if (mtime != this->m_LastModifyTimeRef)
 692                         return true;
 693         }
 694
 695         if(!this->m_PackRefFile.IsEmpty())
 696         {
 697                 if (g_Git.GetFileModifyTime(m_PackRefFile, &mtime))
 698                         return true;
 699
 700                 if (mtime != this->m_LastModifyTimePackRef)
 701                         return true;
 702         }
 703
 704         // in an empty repo HEAD points to refs/heads/master, but this ref doesn't exist.
 705         // So we need to retry again and again until the ref exists - otherwise we will never notice
 706         if (this->m_Head.IsEmpty() && this->m_HeadRefFile.IsEmpty() && this->m_PackRefFile.IsEmpty())
 707                 return true;
 708
 709         return false;
 710 }
 711
 712 int CGitHeadFileList::CallBack(const unsigned char *sha1, const char *base, int baselen,
 713                 const char *pathname, unsigned mode, int /*stage*/, void *context)
 714 {
 715 #define S_IFGITLINK     0160000
 716
 717         CGitHeadFileList *p = (CGitHeadFileList*)context;
 718         if( mode&S_IFDIR )
 719         {
 720                 if( (mode&S_IFMT) != S_IFGITLINK)
 721                         return READ_TREE_RECURSIVE;
 722         }
 723
 724         unsigned int cur = p->size();
 725         p->resize(p->size() + 1);
 726         p->at(cur).m_Hash = (char*)sha1;
 727         p->at(cur).m_FileName.Empty();
 728
 729         if(base)
 730                 g_Git.StringAppend(&p->at(cur).m_FileName, (BYTE*)base, CP_UTF8, baselen);
 731
 732         g_Git.StringAppend(&p->at(cur).m_FileName,(BYTE*)pathname, CP_UTF8);
 733
 734         p->at(cur).m_FileName.MakeLower();
 735
 736         //p->at(cur).m_FileName.Replace(_T('/'), _T('\\'));
 737
 738         //p->m_Map[p->at(cur).m_FileName] = cur;
 739
 740         if( (mode&S_IFMT) == S_IFGITLINK)
 741                 return 0;
 742
 743         return READ_TREE_RECURSIVE;
 744 }
 745
 746 int ReadTreeRecursive(git_repository &repo, git_tree * tree, CStringA base, int (*CallBack) (const unsigned char *, const char *, int, const char *, unsigned int, int, void *),void *data)
 747 {
 748         size_t count = git_tree_entrycount(tree);
 749         for (int i = 0; i < count; i++)
 750         {
 751                 const git_tree_entry *entry = git_tree_entry_byindex(tree, i);
 752                 if (entry == NULL)
 753                         continue;
 754                 int mode = git_tree_entry_attributes(entry);
 755                 if( CallBack(git_tree_entry_id(entry)->id,
 756                         base,
 757                         base.GetLength(),
 758                         git_tree_entry_name(entry),
 759                         mode,
 760                         0,
 761                         data) == READ_TREE_RECURSIVE
 762                   )
 763                 {
 764                         if(mode&S_IFDIR)
 765                         {
 766                                 git_object *object = NULL;
 767                                 git_tree_entry_to_object(&object, &repo, entry);
 768                                 if (object == NULL)
 769                                         continue;
 770                                 CStringA parent = base;
 771                                 parent += git_tree_entry_name(entry);
 772                                 parent += "/";
 773                                 ReadTreeRecursive(repo, (git_tree*)object, parent, CallBack, data);
 774                                 git_object_free(object);
 775                         }
 776                 }
 777
 778         }
 779
 780         return 0;
 781 }
 782
 783 int CGitHeadFileList::ReadTree()
 784 {
 785         CAutoWriteLock lock(&m_SharedMutex);
 786         CStringA gitdir = CUnicodeUtils::GetMulti(m_Gitdir, CP_UTF8);
 787         git_repository *repository = NULL;
 788         git_commit *commit = NULL;
 789         git_tree * tree = NULL;
 790         int ret = 0;
 791         this->clear(); // hack to avoid duplicates in the head list, which are introduced in GitStatus::GetFileStatus when this method is called
 792         do
 793         {
 794                 ret = git_repository_open(&repository, gitdir.GetBuffer());
 795                 gitdir.ReleaseBuffer();
 796                 if(ret)
 797                         break;
 798                 ret = git_commit_lookup(&commit, repository, (const git_oid*)m_Head.m_hash);
 799                 if(ret)
 800                         break;
 801
 802                 ret = git_commit_tree(&tree, commit);
 803                 if(ret)
 804                         break;
 805
 806                 ret = ReadTreeRecursive(*repository, tree,"", CGitHeadFileList::CallBack,this);
 807                 if(ret)
 808                         break;
 809
 810                 std::sort(this->begin(), this->end(), SortTree);
 811                 this->m_TreeHash = (char*)(git_commit_id(commit)->id);
 812
 813         } while(0);
 814
 815         if (tree)
 816                 git_tree_free(tree);
 817
 818         if (commit)
 819                 git_commit_free(commit);
 820
 821         if (repository)
 822                 git_repository_free(repository);
 823
 824         return ret;
 825
 826 }
 827 int CGitIgnoreItem::FetchIgnoreList(const CString &projectroot, const CString &file, bool isGlobal)
 828 {
 829         CAutoWriteLock lock(&this->m_SharedMutex);
 830
 831         if (this->m_pExcludeList)
 832         {
 833                 free(m_pExcludeList);
 834                 m_pExcludeList=NULL;
 835         }
 836
 837         this->m_BaseDir.Empty();
 838         if (!isGlobal)
 839         {
 840                 CString base = file.Mid(projectroot.GetLength() + 1);
 841                 base.Replace(_T('\\'), _T('/'));
 842
 843                 int start = base.ReverseFind(_T('/'));
 844                 if(start > 0)
 845                 {
 846                         base = base.Left(start);
 847                         this->m_BaseDir = CUnicodeUtils::GetMulti(base, CP_UTF8) + "/";
 848                 }
 849         }
 850         {
 851
 852                 if(g_Git.GetFileModifyTime(file, &m_LastModifyTime))
 853                         return -1;
 854
 855                 if(git_create_exclude_list(&this->m_pExcludeList))
 856                         return -1;
 857
 858
 859                 CAutoFile hfile = CreateFile(file,
 860                         GENERIC_READ,
 861                         FILE_SHARE_READ|FILE_SHARE_DELETE|FILE_SHARE_WRITE,
 862                         NULL,
 863                         OPEN_EXISTING,
 864                         FILE_ATTRIBUTE_NORMAL,
 865                         NULL);
 866
 867
 868                 if (!hfile)
 869                         return -1 ;
 870
 871                 DWORD size=0,filesize=0;
 872
 873                 filesize=GetFileSize(hfile, NULL);
 874
 875                 if(filesize == INVALID_FILE_SIZE)
 876                         return -1;
 877
 878                 BYTE *buffer = new BYTE[filesize + 1];
 879
 880                 if(buffer == NULL)
 881                         return -1;
 882
 883                 if(! ReadFile(hfile, buffer,filesize,&size,NULL))
 884                         return GetLastError();
 885
 886                 BYTE *p = buffer;
 887                 for (int i = 0; i < size; i++)
 888                 {
 889                         if (buffer[i] == '\n' || buffer[i] == '\r' || i == (size - 1))
 890                         {
 891                                 if (buffer[i] == '\n' || buffer[i] == '\r')
 892                                         buffer[i] = 0;
 893                                 if (i == size - 1)
 894                                         buffer[size] = 0;
 895
 896                                 if(p[0] != '#' && p[0] != 0)
 897                                         git_add_exclude((const char*)p,
 898                                                                                 this->m_BaseDir.GetBuffer(),
 899                                                                                 m_BaseDir.GetLength(),
 900                                                                                 this->m_pExcludeList);
 901
 902                                 p=buffer+i+1;
 903                         }
 904                 }
 905                 /* Can't free buffer, exluced list will use this buffer*/
 906                 //delete buffer;
 907                 //buffer = NULL;
 908         }
 909         return 0;
 910 }
 911
 912 bool CGitIgnoreList::CheckFileChanged(const CString &path)
 913 {
 914         __int64 time = 0;
 915
 916         int ret = g_Git.GetFileModifyTime(path, &time);
 917
 918         this->m_SharedMutex.AcquireShared();
 919         bool cacheExist = (m_Map.find(path) != m_Map.end());
 920         this->m_SharedMutex.ReleaseShared();
 921
 922         if (!cacheExist && ret == 0)
 923         {
 924                 CAutoWriteLock lock(&this->m_SharedMutex);
 925                 m_Map[path].m_LastModifyTime = 0;
 926                 m_Map[path].m_SharedMutex.Init();
 927         }
 928         // both cache and file is not exist
 929         if ((ret != 0) && (!cacheExist))
 930                 return false;
 931
 932         // file exist but cache miss
 933         if ((ret == 0) && (!cacheExist))
 934                 return true;
 935
 936         // file not exist but cache exist
 937         if ((ret != 0) && (cacheExist))
 938         {
 939                 return true;
 940         }
 941         // file exist and cache exist
 942
 943         {
 944                 CAutoReadLock lock(&this->m_SharedMutex);
 945                 if (m_Map[path].m_LastModifyTime == time)
 946                         return false;
 947         }
 948         return true;
 949 }
 950
 951 bool CGitIgnoreList::CheckIgnoreChanged(const CString &gitdir,const CString &path)
 952 {
 953         CString temp;
 954         temp = gitdir;
 955         temp += _T("\\");
 956         temp += path;
 957
 958         temp.Replace(_T('/'), _T('\\'));
 959
 960         while(!temp.IsEmpty())
 961         {
 962                 CString tempOrig = temp;
 963                 temp += _T("\\.git");
 964
 965                 if (CGit::GitPathFileExists(temp))
 966                 {
 967                         CString gitignore=temp;
 968                         gitignore += _T("ignore");
 969                         if (CheckFileChanged(gitignore))
 970                                 return true;
 971
 972                         CString adminDir = g_AdminDirMap.GetAdminDir(tempOrig);
 973                         CString wcglobalgitignore = adminDir + _T("info\\exclude");
 974                         if (CheckFileChanged(wcglobalgitignore))
 975                                 return true;
 976
 977                         if (CheckAndUpdateCoreExcludefile(adminDir))
 978                                 return true;
 979
 980                         return false;
 981                 }
 982                 else
 983                 {
 984                         temp += _T("ignore");
 985                         if (CheckFileChanged(temp))
 986                                 return true;
 987                 }
 988
 989                 int found=0;
 990                 int i;
 991                 for (i = temp.GetLength() - 1; i >= 0; i--)
 992                 {
 993                         if(temp[i] == _T('\\'))
 994                                 found ++;
 995
 996                         if(found == 2)
 997                                 break;
 998                 }
 999
1000                 temp = temp.Left(i);
1001         }
1002         return true;
1003 }
1004
1005 int CGitIgnoreList::FetchIgnoreFile(const CString &gitdir, const CString &gitignore, bool isGlobal)
1006 {
1007         if (CGit::GitPathFileExists(gitignore)) //if .gitignore remove, we need remote cache
1008         {
1009                 CAutoWriteLock lock(&this->m_SharedMutex);
1010                 if (m_Map.find(gitignore) == m_Map.end())
1011                         m_Map[gitignore].m_SharedMutex.Init();
1012
1013                 m_Map[gitignore].FetchIgnoreList(gitdir, gitignore, isGlobal);
1014         }
1015         else
1016         {
1017                 CAutoWriteLock lock(&this->m_SharedMutex);
1018                 if (m_Map.find(gitignore) != m_Map.end())
1019                         m_Map[gitignore].m_SharedMutex.Release();
1020
1021                 m_Map.erase(gitignore);
1022         }
1023         return 0;
1024 }
1025
1026 int CGitIgnoreList::LoadAllIgnoreFile(const CString &gitdir,const CString &path)
1027 {
1028         CString temp;
1029
1030         temp = gitdir;
1031         temp += _T("\\");
1032         temp += path;
1033
1034         temp.Replace(_T('/'), _T('\\'));
1035
1036         while (!temp.IsEmpty())
1037         {
1038                 CString tempOrig = temp;
1039                 temp += _T("\\.git");
1040
1041                 if (CGit::GitPathFileExists(temp))
1042                 {
1043                         CString gitignore = temp;
1044                         gitignore += _T("ignore");
1045                         if (CheckFileChanged(gitignore))
1046                         {
1047                                 FetchIgnoreFile(gitdir, gitignore, false);
1048                         }
1049
1050                         CString adminDir = g_AdminDirMap.GetAdminDir(tempOrig);
1051                         CString wcglobalgitignore = adminDir + _T("info\\exclude");
1052                         if (CheckFileChanged(wcglobalgitignore))
1053                         {
1054                                 FetchIgnoreFile(gitdir, wcglobalgitignore, true);
1055                         }
1056
1057                         if (CheckAndUpdateCoreExcludefile(adminDir))
1058                         {
1059                                 m_SharedMutex.AcquireShared();
1060                                 CString excludesFile = m_CoreExcludesfiles[adminDir];
1061                                 m_SharedMutex.ReleaseShared();
1062                                 if (!excludesFile.IsEmpty())
1063                                         FetchIgnoreFile(gitdir, excludesFile, true);
1064                         }
1065
1066                         return 0;
1067                 }
1068                 else
1069                 {
1070                         temp += _T("ignore");
1071                         if (CheckFileChanged(temp))
1072                         {
1073                                 FetchIgnoreFile(gitdir, temp, false);
1074                         }
1075                 }
1076
1077                 int found = 0;
1078                 int i;
1079                 for (i = temp.GetLength() - 1; i >= 0; i--)
1080                 {
1081                         if(temp[i] == _T('\\'))
1082                                 found ++;
1083
1084                         if(found == 2)
1085                                 break;
1086                 }
1087
1088                 temp = temp.Left(i);
1089         }
1090         return 0;
1091 }
1092 bool CGitIgnoreList::CheckAndUpdateMsysGitBinpath(bool force)
1093 {
1094         // recheck every 30 seconds
1095         if (GetTickCount() - m_dMsysGitBinPathLastChecked > 30000 || force)
1096         {
1097                 m_dMsysGitBinPathLastChecked = GetTickCount();
1098                 CString msysGitBinPath(CRegString(REG_MSYSGIT_PATH, _T(""), FALSE));
1099                 if (msysGitBinPath != m_sMsysGitBinPath)
1100                 {
1101                         m_sMsysGitBinPath = msysGitBinPath;
1102                         return true;
1103                 }
1104         }
1105         return false;
1106 }
1107 bool CGitIgnoreList::CheckAndUpdateCoreExcludefile(const CString &adminDir)
1108 {
1109         bool hasChanged = false;
1110
1111         CString projectConfig = adminDir + _T("config");
1112         CString globalConfig = GetWindowsHome() + _T("\\.gitconfig");
1113
1114         CAutoWriteLock lock(&m_coreExcludefilesSharedMutex);
1115         hasChanged = CheckAndUpdateMsysGitBinpath();
1116         CString systemConfig = m_sMsysGitBinPath + _T("\\..\\etc\\gitconfig");
1117
1118         hasChanged = hasChanged || CheckFileChanged(projectConfig);
1119         hasChanged = hasChanged || CheckFileChanged(globalConfig);
1120         if (!m_sMsysGitBinPath.IsEmpty())
1121                 hasChanged = hasChanged || CheckFileChanged(systemConfig);
1122
1123         m_SharedMutex.AcquireShared();
1124         CString excludesFile = m_CoreExcludesfiles[adminDir];
1125         m_SharedMutex.ReleaseShared();
1126         if (!excludesFile.IsEmpty())
1127                 hasChanged = hasChanged || CheckFileChanged(excludesFile);
1128
1129         if (!hasChanged)
1130                 return false;
1131
1132         git_config * config;
1133         git_config_new(&config);
1134         CStringA projectConfigA = CUnicodeUtils::GetMulti(projectConfig, CP_UTF8);
1135         git_config_add_file_ondisk(config, projectConfigA.GetBuffer(), 3);
1136         projectConfigA.ReleaseBuffer();
1137         CStringA globalConfigA = CUnicodeUtils::GetMulti(globalConfig, CP_UTF8);
1138         git_config_add_file_ondisk(config, globalConfigA.GetBuffer(), 2);
1139         globalConfigA.ReleaseBuffer();
1140         if (!m_sMsysGitBinPath.IsEmpty())
1141         {
1142                 CStringA systemConfigA = CUnicodeUtils::GetMulti(systemConfig, CP_UTF8);
1143                 git_config_add_file_ondisk(config, systemConfigA.GetBuffer(), 1);
1144                 systemConfigA.ReleaseBuffer();
1145         }
1146         const char * out = NULL;
1147         CStringA name(_T("core.excludesfile"));
1148         git_config_get_string(&out, config, name.GetBuffer());
1149         name.ReleaseBuffer();
1150         CStringA excludesFileA(out);
1151         excludesFile = CUnicodeUtils::GetUnicode(excludesFileA);
1152         if (excludesFile.Find(_T("~/")) == 0)
1153                 excludesFile = GetWindowsHome() + excludesFile.Mid(1);
1154         git_config_free(config);
1155
1156         CAutoWriteLock lockMap(&m_SharedMutex);
1157         g_Git.GetFileModifyTime(projectConfig, &m_Map[projectConfig].m_LastModifyTime);
1158         g_Git.GetFileModifyTime(globalConfig, &m_Map[globalConfig].m_LastModifyTime);
1159         if (m_Map[globalConfig].m_LastModifyTime == 0)
1160         {
1161                 m_Map[globalConfig].m_SharedMutex.Release();
1162                 m_Map.erase(globalConfig);
1163         }
1164         if (!m_sMsysGitBinPath.IsEmpty())
1165                 g_Git.GetFileModifyTime(systemConfig, &m_Map[systemConfig].m_LastModifyTime);
1166         if (m_Map[systemConfig].m_LastModifyTime == 0 || m_sMsysGitBinPath.IsEmpty())
1167         {
1168                 m_Map[systemConfig].m_SharedMutex.Release();
1169                 m_Map.erase(systemConfig);
1170         }
1171         m_CoreExcludesfiles[adminDir] = excludesFile;
1172
1173         return true;
1174 }
1175 const CString CGitIgnoreList::GetWindowsHome()
1176 {
1177         static CString sWindowsHome(g_Git.GetHomeDirectory());
1178         return sWindowsHome;
1179 }
1180 bool CGitIgnoreList::IsIgnore(const CString &path,const CString &projectroot)
1181 {
1182         CString str=path;
1183
1184         str.Replace(_T('\\'),_T('/'));
1185
1186         if (str.GetLength()>0)
1187                 if (str[str.GetLength()-1] == _T('/'))
1188                         str = str.Left(str.GetLength() - 1);
1189
1190         int ret;
1191         ret = CheckIgnore(str, projectroot);
1192         while (ret < 0)
1193         {
1194                 int start = str.ReverseFind(_T('/'));
1195                 if(start < 0)
1196                         return (ret == 1);
1197
1198                 str = str.Left(start);
1199                 ret = CheckIgnore(str, projectroot);
1200         }
1201
1202         return (ret == 1);
1203 }
1204 int CGitIgnoreList::CheckFileAgainstIgnoreList(const CString &ignorefile, const CStringA &patha, const char * base, int &type)
1205 {
1206         if (m_Map.find(ignorefile) != m_Map.end())
1207         {
1208                 int ret = -1;
1209                 if(m_Map[ignorefile].m_pExcludeList)
1210                         ret = git_check_excluded_1(patha, patha.GetLength(), base, &type, m_Map[ignorefile].m_pExcludeList);
1211                 if (ret == 0 || ret == 1)
1212                         return ret;
1213         }
1214         return -1;
1215 }
1216 int CGitIgnoreList::CheckIgnore(const CString &path,const CString &projectroot)
1217 {
1218         __int64 time = 0;
1219         bool dir = 0;
1220         CString temp = projectroot + _T("\\") + path;
1221         temp.Replace(_T('/'), _T('\\'));
1222
1223         CStringA patha = CUnicodeUtils::GetMulti(path, CP_UTF8);
1224         patha.Replace('\\', '/');
1225
1226         if(g_Git.GetFileModifyTime(temp, &time, &dir))
1227                 return -1;
1228
1229         int type = 0;
1230         if (dir)
1231         {
1232                 type = DT_DIR;
1233
1234                 // strip directory name
1235                 // we do not need to check for a .ignore file inside a directory we might ignore
1236                 int i = temp.ReverseFind(_T('\\'));
1237                 if (i >= 0)
1238                         temp = temp.Left(i);
1239         }
1240         else
1241                 type = DT_REG;
1242
1243         char * base = NULL;
1244         int pos = patha.ReverseFind('/');
1245         base = pos >= 0 ? patha.GetBuffer() + pos + 1 : patha.GetBuffer();
1246
1247         int ret = -1;
1248
1249         CAutoReadLock lock(&this->m_SharedMutex);
1250         while (!temp.IsEmpty())
1251         {
1252                 CString tempOrig = temp;
1253                 temp += _T("\\.git");
1254
1255                 if (CGit::GitPathFileExists(temp))
1256                 {
1257                         CString gitignore = temp;
1258                         gitignore += _T("ignore");
1259                         if ((ret = CheckFileAgainstIgnoreList(gitignore, patha, base, type)) != -1)
1260                                 break;
1261
1262                         CString adminDir = g_AdminDirMap.GetAdminDir(tempOrig);
1263                         CString wcglobalgitignore = adminDir + _T("info\\exclude");
1264                         if ((ret = CheckFileAgainstIgnoreList(wcglobalgitignore, patha, base, type)) != -1)
1265                                 break;
1266
1267                         m_SharedMutex.AcquireShared();
1268                         CString excludesFile = m_CoreExcludesfiles[adminDir];
1269                         m_SharedMutex.ReleaseShared();
1270                         if (!excludesFile.IsEmpty())
1271                                 ret = CheckFileAgainstIgnoreList(excludesFile, patha, base, type);
1272
1273                         break;
1274                 }
1275                 else
1276                 {
1277                         temp += _T("ignore");
1278                         if ((ret = CheckFileAgainstIgnoreList(temp, patha, base, type)) != -1)
1279                                 break;
1280                 }
1281
1282                 int found = 0;
1283                 int i;
1284                 for (i = temp.GetLength() - 1; i >= 0; i--)
1285                 {
1286                         if (temp[i] == _T('\\'))
1287                                 found++;
1288
1289                         if (found == 2)
1290                                 break;
1291                 }
1292
1293                 temp = temp.Left(i);
1294         }
1295
1296         patha.ReleaseBuffer();
1297
1298         return ret;
1299 }
1300
1301 bool CGitHeadFileMap::CheckHeadUpdate(const CString &gitdir)
1302 {
1303         SHARED_TREE_PTR ptr;
1304         ptr = this->SafeGet(gitdir);
1305
1306         if( ptr.get())
1307         {
1308                 return ptr->CheckHeadUpdate();
1309         }
1310         else
1311         {
1312                 SHARED_TREE_PTR ptr1(new CGitHeadFileList);
1313                 ptr1->ReadHeadHash(gitdir);
1314
1315                 this->SafeSet(gitdir, ptr1);
1316                 return true;
1317         }
1318         return false;
1319 }
1320
1321 int CGitHeadFileMap::IsUnderVersionControl(const CString &gitdir, const CString &path, bool isDir, bool *isVersion)
1322 {
1323         try
1324         {
1325                 if (path.IsEmpty())
1326                 {
1327                         *isVersion = true;
1328                         return 0;
1329                 }
1330
1331                 CString subpath = path;
1332                 subpath.Replace(_T('\\'), _T('/'));
1333                 if(isDir)
1334                         subpath += _T('/');
1335
1336                 subpath.MakeLower();
1337
1338                 CheckHeadUpdate(gitdir);
1339
1340                 SHARED_TREE_PTR treeptr;
1341                 treeptr = SafeGet(gitdir);
1342
1343                 if (treeptr->m_Head != treeptr->m_TreeHash)
1344                 {
1345                         treeptr->ReadHeadHash(gitdir);
1346
1347                         // Init Repository
1348                         if (treeptr->m_HeadFile.IsEmpty())
1349                         {
1350                                 *isVersion = false;
1351                                 return 0;
1352                         }
1353                         else if (treeptr->ReadTree())
1354                         {
1355                                 treeptr->m_LastModifyTimeHead = 0;
1356                                 *isVersion = false;
1357                                 return 1;
1358                         }
1359                         SafeSet(gitdir, treeptr);
1360                 }
1361
1362                 if(isDir)
1363                         *isVersion = (SearchInSortVector(*treeptr, subpath.GetBuffer(), subpath.GetLength()) >= 0);
1364                 else
1365                         *isVersion = (SearchInSortVector(*treeptr, subpath.GetBuffer(), -1) >= 0);
1366                 subpath.ReleaseBuffer();
1367         }
1368         catch(...)
1369         {
1370                 return -1;
1371         }
1372
1373         return 0;
1374 }
1375
1376 int CGitHeadFileMap::GetHeadHash(const CString &gitdir, CGitHash &hash)
1377 {
1378         SHARED_TREE_PTR ptr;
1379         ptr = this->SafeGet(gitdir);
1380
1381         if(ptr.get() == NULL)
1382         {
1383                 SHARED_TREE_PTR ptr1(new CGitHeadFileList());
1384                 ptr1->ReadHeadHash(gitdir);
1385
1386                 hash = ptr1->m_Head;
1387
1388                 this->SafeSet(gitdir, ptr1);
1389
1390         }
1391         else
1392         {
1393                 if(ptr->CheckHeadUpdate())
1394                 {
1395                         SHARED_TREE_PTR ptr1(new CGitHeadFileList());
1396                         ptr1->ReadHeadHash(gitdir);
1397
1398                         hash = ptr1->m_Head;
1399                         this->SafeSet(gitdir, ptr1);
1400         }
1401
1402                 hash = ptr->m_Head;
1403         }
1404         return 0;
1405 }