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