src/Git/GitIndex.cpp

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