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