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