src/Git/GitIndex.cpp

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