src/Git/GitIndex.cpp

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