src/TGitCache/TGITCache.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // External Cache Copyright (C) 2005 - 2006,2010 - Will Dean, Stefan Kueng
   4 // Copyright (C) 2008-2014 - TortoiseGit
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20
  21 #include "stdafx.h"
  22 #include <ShellAPI.h>
  23 #include "TGITCache.h"
  24 #include "GitStatusCache.h"
  25 #include "CacheInterface.h"
  26 #include "Resource.h"
  27 #include "registry.h"
  28 #include "CrashReport.h"
  29 #include "GitAdminDir.h"
  30 #include <Dbt.h>
  31 #include <InitGuid.h>
  32 #include <Ioevent.h>
  33 #include "..\version.h"
  34 #include "SmartHandle.h"
  35 #include "DllVersion.h"
  36 #include "CreateProcessHelper.h"
  37 #include "gitindex.h"
  38
  39 #ifndef GET_X_LPARAM
  40 #define GET_X_LPARAM(lp)                        ((int)(short)LOWORD(lp))
  41 #endif
  42 #ifndef GET_Y_LPARAM
  43 #define GET_Y_LPARAM(lp)                        ((int)(short)HIWORD(lp))
  44 #endif
  45
  46
  47 #pragma comment(linker, "\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
  48
  49 #if ENABLE_CRASHHANLDER
  50 CCrashReportTGit crasher(L"TGitCache " _T(APP_X64_STRING), TGIT_VERMAJOR, TGIT_VERMINOR, TGIT_VERMICRO, TGIT_VERBUILD, TGIT_VERDATE);
  51 #endif
  52
  53 DWORD WINAPI            InstanceThread(LPVOID);
  54 DWORD WINAPI            PipeThread(LPVOID);
  55 DWORD WINAPI            CommandWaitThread(LPVOID);
  56 DWORD WINAPI            CommandThread(LPVOID);
  57 LRESULT CALLBACK        WndProc(HWND, UINT, WPARAM, LPARAM);
  58 bool                            bRun = true;
  59 bool                            bRestart = false;
  60 NOTIFYICONDATA          niData;
  61 HWND                            hWndHidden;
  62 HWND                            hTrayWnd;
  63 TCHAR                           szCurrentCrawledPath[MAX_CRAWLEDPATHS][MAX_CRAWLEDPATHSLEN];
  64 int                                     nCurrentCrawledpathIndex = 0;
  65 CComAutoCriticalSection critSec;
  66
  67 // must put this before any global variables that auto free git objects,
  68 // so this destructor is called after freeing git objects
  69 class CGit2InitClass
  70 {
  71 public:
  72         ~CGit2InitClass()
  73         {
  74                 git_libgit2_shutdown();
  75                 if (niData.hWnd)
  76                         Shell_NotifyIcon(NIM_DELETE, &niData);
  77         }
  78 } git2init;
  79
  80 CGitIndexFileMap g_IndexFileMap;
  81
  82 volatile LONG           nThreadCount = 0;
  83
  84 #define PACKVERSION(major,minor) MAKELONG(minor,major)
  85
  86 void DebugOutputLastError()
  87 {
  88         LPVOID lpMsgBuf;
  89         if (!FormatMessage(
  90                 FORMAT_MESSAGE_ALLOCATE_BUFFER |
  91                 FORMAT_MESSAGE_FROM_SYSTEM |
  92                 FORMAT_MESSAGE_IGNORE_INSERTS,
  93                 NULL,
  94                 GetLastError(),
  95                 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
  96                 (LPTSTR) &lpMsgBuf,
  97                 0,
  98                 NULL ))
  99         {
 100                 return;
 101         }
 102
 103         // Display the string.
 104         OutputDebugStringA("TGitCache GetLastError(): ");
 105         OutputDebugString((LPCTSTR)lpMsgBuf);
 106         OutputDebugStringA("\n");
 107
 108         // Free the buffer.
 109         LocalFree( lpMsgBuf );
 110 }
 111
 112 void HandleCommandLine(LPSTR lpCmdLine)
 113 {
 114         char *ptr = strstr(lpCmdLine, "/kill:");
 115         if (ptr)
 116         {
 117                 DWORD pid = (DWORD)atoi(ptr + strlen("/kill:"));
 118                 HANDLE hProcess = ::OpenProcess(PROCESS_TERMINATE, FALSE, pid);
 119                 if (hProcess)
 120                 {
 121                         if (::WaitForSingleObject(hProcess, 5000) != WAIT_OBJECT_0)
 122                         {
 123                                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Killing previous TGitCache PID %d\n", pid);
 124                                 if (!::TerminateProcess(hProcess, (UINT)-1))
 125                                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Kill previous TGitCache PID %d failed\n", pid);
 126                                 ::WaitForSingleObject(hProcess, 5000);
 127                         }
 128                         ::CloseHandle(hProcess);
 129                         for (int i = 0; i < 5; i++)
 130                         {
 131                                 HANDLE hMutex = ::OpenMutex(MUTEX_ALL_ACCESS, FALSE, GetCacheMutexName());
 132                                 if (!hMutex)
 133                                         break;
 134                                 ::CloseHandle(hMutex);
 135                                 ::Sleep(1000);
 136                         }
 137                 }
 138         }
 139 }
 140
 141 void HandleRestart()
 142 {
 143         if (bRestart)
 144         {
 145                 TCHAR exeName[MAX_PATH] = { 0 };
 146                 ::GetModuleFileName(nullptr, exeName, _countof(exeName));
 147                 TCHAR cmdLine[20] = { 0 };
 148                 _stprintf_s(cmdLine, _T(" /kill:%d"), GetCurrentProcessId());
 149                 if (!CCreateProcessHelper::CreateProcessDetached(exeName, cmdLine))
 150                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Failed to start cache\n");
 151         }
 152 }
 153
 154 int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPSTR lpCmdLine, int /*cmdShow*/)
 155 {
 156         SetDllDirectory(L"");
 157         git_libgit2_init();
 158         HandleCommandLine(lpCmdLine);
 159         CAutoGeneralHandle hReloadProtection = ::CreateMutex(NULL, FALSE, GetCacheMutexName());
 160
 161         if ((!hReloadProtection) || (GetLastError() == ERROR_ALREADY_EXISTS))
 162         {
 163                 // An instance of TGitCache is already running
 164                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": TGitCache ignoring restart\n");
 165                 return 0;
 166         }
 167
 168         CGitStatusCache::Create();
 169         CGitStatusCache::Instance().Init();
 170
 171         SecureZeroMemory(szCurrentCrawledPath, sizeof(szCurrentCrawledPath));
 172
 173         DWORD dwThreadId;
 174         MSG msg;
 175         TCHAR szWindowClass[] = {TGIT_CACHE_WINDOW_NAME};
 176
 177         // create a hidden window to receive window messages.
 178         WNDCLASSEX wcex;
 179         wcex.cbSize = sizeof(WNDCLASSEX);
 180         wcex.style                      = CS_HREDRAW | CS_VREDRAW;
 181         wcex.lpfnWndProc        = (WNDPROC)WndProc;
 182         wcex.cbClsExtra         = 0;
 183         wcex.cbWndExtra         = 0;
 184         wcex.hInstance          = hInstance;
 185         wcex.hIcon                      = 0;
 186         wcex.hCursor            = 0;
 187         wcex.hbrBackground      = 0;
 188         wcex.lpszMenuName       = NULL;
 189         wcex.lpszClassName      = szWindowClass;
 190         wcex.hIconSm            = 0;
 191         RegisterClassEx(&wcex);
 192         hWndHidden = CreateWindow(TGIT_CACHE_WINDOW_NAME, TGIT_CACHE_WINDOW_NAME, WS_CAPTION, 0, 0, 800, 300, NULL, 0, hInstance, 0);
 193         hTrayWnd = hWndHidden;
 194         if (hWndHidden == NULL)
 195         {
 196                 return 0;
 197         }
 198         if (CRegStdDWORD(_T("Software\\TortoiseGit\\CacheTrayIcon"), FALSE)==TRUE)
 199         {
 200                 SecureZeroMemory(&niData,sizeof(NOTIFYICONDATA));
 201
 202                 DWORD dwMajor = 0;
 203                 DWORD dwMinor = 0;
 204                 GetShellVersion(&dwMajor, &dwMinor);
 205                 DWORD dwVersion = PACKVERSION(dwMajor, dwMinor);
 206                 if (dwVersion >= PACKVERSION(6,0))
 207                         niData.cbSize = sizeof(NOTIFYICONDATA);
 208                 else if (dwVersion >= PACKVERSION(5,0))
 209                         niData.cbSize = NOTIFYICONDATA_V2_SIZE;
 210                 else
 211                         niData.cbSize = NOTIFYICONDATA_V1_SIZE;
 212
 213                 niData.uID = TRAY_ID;           // own tray icon ID
 214                 niData.hWnd      = hWndHidden;
 215                 niData.uFlags = NIF_ICON|NIF_MESSAGE;
 216
 217                 // load the icon
 218                 niData.hIcon =
 219                         (HICON)LoadImage(hInstance,
 220                         MAKEINTRESOURCE(IDI_TGITCACHE),
 221                         IMAGE_ICON,
 222                         GetSystemMetrics(SM_CXSMICON),
 223                         GetSystemMetrics(SM_CYSMICON),
 224                         LR_DEFAULTCOLOR);
 225
 226                 // set the message to send
 227                 // note: the message value should be in the
 228                 // range of WM_APP through 0xBFFF
 229                 niData.uCallbackMessage = TRAY_CALLBACK;
 230                 Shell_NotifyIcon(NIM_ADD,&niData);
 231                 // free icon handle
 232                 if(niData.hIcon && DestroyIcon(niData.hIcon))
 233                         niData.hIcon = NULL;
 234         }
 235
 236         // Create a thread which waits for incoming pipe connections
 237         CAutoGeneralHandle hPipeThread = CreateThread(
 238                 NULL,              // no security attribute
 239                 0,                 // default stack size
 240                 PipeThread,
 241                 (LPVOID) &bRun,    // thread parameter
 242                 0,                 // not suspended
 243                 &dwThreadId);      // returns thread ID
 244
 245         if (!hPipeThread)
 246         {
 247                 return 0;
 248         }
 249         else hPipeThread.CloseHandle();
 250
 251         // Create a thread which waits for incoming pipe connections
 252         CAutoGeneralHandle hCommandWaitThread = CreateThread(
 253                 NULL,              // no security attribute
 254                 0,                 // default stack size
 255                 CommandWaitThread,
 256                 (LPVOID) &bRun,    // thread parameter
 257                 0,                 // not suspended
 258                 &dwThreadId);      // returns thread ID
 259
 260         if (!hCommandWaitThread)
 261         {
 262                 return 0;
 263         }
 264
 265
 266         // loop to handle window messages.
 267         while (bRun)
 268         {
 269                 BOOL bLoopRet = GetMessage(&msg, NULL, 0, 0);
 270                 if ((bLoopRet != -1)&&(bLoopRet != 0))
 271                 {
 272                         DispatchMessage(&msg);
 273                 }
 274         }
 275
 276         bRun = false;
 277
 278         CGitStatusCache::Destroy();
 279         HandleRestart();
 280         return 0;
 281 }
 282
 283 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 284 {
 285         switch (message)
 286         {
 287         case TRAY_CALLBACK:
 288         {
 289                 switch(lParam)
 290                 {
 291                 case WM_LBUTTONDBLCLK:
 292                         if (IsWindowVisible(hWnd))
 293                                 ShowWindow(hWnd, SW_HIDE);
 294                         else
 295                                 ShowWindow(hWnd, SW_RESTORE);
 296                         break;
 297                 case WM_MOUSEMOVE:
 298                         {
 299                                 CString sInfoTip;
 300                                 NOTIFYICONDATA SystemTray;
 301                                 sInfoTip.Format(_T("TortoiseGit Overlay Icon Server\nCached Directories: %Id\nWatched paths: %d"),
 302                                         CGitStatusCache::Instance().GetCacheSize(),
 303                                         CGitStatusCache::Instance().GetNumberOfWatchedPaths());
 304
 305                                 SystemTray.cbSize = sizeof(NOTIFYICONDATA);
 306                                 SystemTray.hWnd   = hTrayWnd;
 307                                 SystemTray.uID    = TRAY_ID;
 308                                 SystemTray.uFlags = NIF_TIP;
 309                                 _tcscpy_s(SystemTray.szTip, sInfoTip);
 310                                 Shell_NotifyIcon(NIM_MODIFY, &SystemTray);
 311                         }
 312                         break;
 313                 case WM_RBUTTONUP:
 314                 case WM_CONTEXTMENU:
 315                         {
 316                                 POINT pt;
 317                                 GetCursorPos(&pt);
 318                                 HMENU hMenu = CreatePopupMenu();
 319                                 if(hMenu)
 320                                 {
 321                                         bool enabled = (DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\CacheType"), GetSystemMetrics(SM_REMOTESESSION) ? ShellCache::dll : ShellCache::exe) != ShellCache::none;
 322                                         InsertMenu(hMenu, (UINT)-1, MF_BYPOSITION, TRAYPOP_ENABLE, enabled ? _T("Disable Status Cache") : _T("Enable Status Cache"));
 323                                         InsertMenu(hMenu, (UINT)-1, MF_BYPOSITION, TRAYPOP_EXIT, _T("Exit"));
 324                                         SetForegroundWindow(hWnd);
 325                                         TrackPopupMenu(hMenu, TPM_BOTTOMALIGN, pt.x, pt.y, 0, hWnd, NULL);
 326                                         DestroyMenu(hMenu);
 327                                 }
 328                         }
 329                         break;
 330                 }
 331         }
 332         break;
 333         case WM_PAINT:
 334                 {
 335                         PAINTSTRUCT ps;
 336                         HDC hdc = BeginPaint(hWnd, &ps);
 337                         RECT rect;
 338                         GetClientRect(hWnd, &rect);
 339                         // clear the background
 340                         HBRUSH background = CreateSolidBrush(::GetSysColor(COLOR_WINDOW));
 341                         HGDIOBJ oldbrush = SelectObject(hdc, background);
 342                         FillRect(hdc, &rect, background);
 343
 344                         int line = 0;
 345                         SIZE fontsize = {0};
 346                         AutoLocker print(critSec);
 347                         GetTextExtentPoint32( hdc, szCurrentCrawledPath[0], (int)_tcslen(szCurrentCrawledPath[0]), &fontsize );
 348                         for (int i=nCurrentCrawledpathIndex; i<MAX_CRAWLEDPATHS; ++i)
 349                         {
 350                                 TextOut(hdc, 0, line*fontsize.cy, szCurrentCrawledPath[i], (int)_tcslen(szCurrentCrawledPath[i]));
 351                                 ++line;
 352                         }
 353                         for (int i=0; i<nCurrentCrawledpathIndex; ++i)
 354                         {
 355                                 TextOut(hdc, 0, line*fontsize.cy, szCurrentCrawledPath[i], (int)_tcslen(szCurrentCrawledPath[i]));
 356                                 ++line;
 357                         }
 358
 359                         SelectObject(hdc,oldbrush);
 360                         EndPaint(hWnd, &ps);
 361                         DeleteObject(background);
 362                         return 0L;
 363                 }
 364                 break;
 365         case WM_COMMAND:
 366                 {
 367                         WORD wmId    = LOWORD(wParam);
 368
 369                         switch (wmId)
 370                         {
 371                         case TRAYPOP_ENABLE:
 372                                 {
 373                                         CRegStdDWORD reg = CRegStdDWORD(_T("Software\\TortoiseGit\\CacheType"), GetSystemMetrics(SM_REMOTESESSION) ? ShellCache::dll : ShellCache::exe);
 374                                         bool enabled = (DWORD)reg != ShellCache::none;
 375                                         reg = enabled ? ShellCache::none : ShellCache::exe;
 376                                         if (enabled)
 377                                         {
 378                                                 bRestart = true;
 379                                                 DestroyWindow(hWnd);
 380                                         }
 381                                         break;
 382                                 }
 383                         case TRAYPOP_EXIT:
 384                                 DestroyWindow(hWnd);
 385                                 break;
 386                         }
 387                         return 1;
 388                 }
 389         case WM_QUERYENDSESSION:
 390                 {
 391                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": WM_QUERYENDSESSION\n");
 392                         CAutoWriteWeakLock writeLock(CGitStatusCache::Instance().GetGuard(), 200);
 393                         CGitStatusCache::Instance().Stop();
 394                         return TRUE;
 395                 }
 396                 break;
 397         case WM_CLOSE:
 398         case WM_ENDSESSION:
 399         case WM_DESTROY:
 400         case WM_QUIT:
 401                 {
 402                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": WM_CLOSE/DESTROY/ENDSESSION/QUIT\n");
 403                         if (niData.hWnd)
 404                         {
 405                                 niData.hIcon = (HICON)LoadImage(GetModuleHandle(NULL),
 406                                         MAKEINTRESOURCE(IDI_TGITCACHE_STOPPING),
 407                                         IMAGE_ICON,
 408                                         GetSystemMetrics(SM_CXSMICON),
 409                                         GetSystemMetrics(SM_CYSMICON),
 410                                         LR_DEFAULTCOLOR);
 411                                 Shell_NotifyIcon(NIM_MODIFY, &niData);
 412                         }
 413                         CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
 414                         CGitStatusCache::Instance().Stop();
 415                         CGitStatusCache::Instance().SaveCache();
 416                         if (message != WM_QUIT)
 417                                 PostQuitMessage(0);
 418                         bRun = false;
 419                         return 1;
 420                 }
 421                 break;
 422         case WM_DEVICECHANGE:
 423                 {
 424                         DEV_BROADCAST_HDR * phdr = (DEV_BROADCAST_HDR*)lParam;
 425                         switch (wParam)
 426                         {
 427                         case DBT_CUSTOMEVENT:
 428                                 {
 429                                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": WM_DEVICECHANGE with DBT_CUSTOMEVENT\n");
 430                                         if (phdr->dbch_devicetype == DBT_DEVTYP_HANDLE)
 431                                         {
 432                                                 DEV_BROADCAST_HANDLE * phandle = (DEV_BROADCAST_HANDLE*)lParam;
 433                                                 if (IsEqualGUID(phandle->dbch_eventguid, GUID_IO_VOLUME_DISMOUNT))
 434                                                 {
 435                                                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Device to be dismounted\n");
 436                                                         CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
 437                                                         CGitStatusCache::Instance().CloseWatcherHandles(phandle->dbch_handle);
 438                                                 }
 439                                                 if (IsEqualGUID(phandle->dbch_eventguid, GUID_IO_VOLUME_LOCK))
 440                                                 {
 441                                                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Device lock event\n");
 442                                                         CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
 443                                                         CGitStatusCache::Instance().CloseWatcherHandles(phandle->dbch_handle);
 444                                                 }
 445                                         }
 446                                 }
 447                                 break;
 448                         case DBT_DEVICEREMOVEPENDING:
 449                         case DBT_DEVICEQUERYREMOVE:
 450                         case DBT_DEVICEREMOVECOMPLETE:
 451                                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": WM_DEVICECHANGE with DBT_DEVICEREMOVEPENDING/DBT_DEVICEQUERYREMOVE/DBT_DEVICEREMOVECOMPLETE\n");
 452                                 if (phdr->dbch_devicetype == DBT_DEVTYP_HANDLE)
 453                                 {
 454                                         DEV_BROADCAST_HANDLE * phandle = (DEV_BROADCAST_HANDLE*)lParam;
 455                                         CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
 456                                         CGitStatusCache::Instance().CloseWatcherHandles(phandle->dbch_handle);
 457                                 }
 458                                 else if (phdr->dbch_devicetype == DBT_DEVTYP_VOLUME)
 459                                 {
 460                                         DEV_BROADCAST_VOLUME * pVolume = (DEV_BROADCAST_VOLUME*)lParam;
 461                                         CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
 462                                         for (BYTE i = 0; i < 26; ++i)
 463                                         {
 464                                                 if (pVolume->dbcv_unitmask & (1 << i))
 465                                                 {
 466                                                         TCHAR driveletter = 'A' + i;
 467                                                         CString drive = CString(driveletter);
 468                                                         drive += L":\\";
 469                                                         CGitStatusCache::Instance().CloseWatcherHandles(CTGitPath(drive));
 470                                                 }
 471                                         }
 472                                 }
 473                                 else
 474                                 {
 475                                         CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
 476                                         CGitStatusCache::Instance().CloseWatcherHandles(INVALID_HANDLE_VALUE);
 477                                 }
 478                                 break;
 479                         }
 480                 }
 481                 break;
 482         default:
 483                 break;
 484         }
 485         return DefWindowProc(hWnd, message, wParam, lParam);
 486 }
 487
 488 //////////////////////////////////////////////////////////////////////////
 489
 490 VOID GetAnswerToRequest(const TGITCacheRequest* pRequest, TGITCacheResponse* pReply, DWORD* pResponseLength)
 491 {
 492         CTGitPath path;
 493         *pResponseLength = 0;
 494         if(pRequest->flags & TGITCACHE_FLAGS_FOLDERISKNOWN)
 495         {
 496                 path.SetFromWin(pRequest->path, !!(pRequest->flags & TGITCACHE_FLAGS_ISFOLDER));
 497         }
 498         else
 499         {
 500                 path.SetFromWin(pRequest->path);
 501         }
 502
 503         CAutoReadWeakLock readLock(CGitStatusCache::Instance().GetGuard(), 2000);
 504         if (readLock.IsAcquired())
 505         {
 506                 CGitStatusCache::Instance().GetStatusForPath(path, pRequest->flags, false).BuildCacheResponse(*pReply, *pResponseLength);
 507         }
 508         else
 509         {
 510                 CStatusCacheEntry entry;
 511                 entry.BuildCacheResponse(*pReply, *pResponseLength);
 512         }
 513 }
 514
 515 DWORD WINAPI PipeThread(LPVOID lpvParam)
 516 {
 517         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": PipeThread started\n");
 518         bool* bThreadRun = (bool*)lpvParam;
 519         // The main loop creates an instance of the named pipe and
 520         // then waits for a client to connect to it. When the client
 521         // connects, a thread is created to handle communications
 522         // with that client, and the loop is repeated.
 523         DWORD dwThreadId;
 524         BOOL fConnected;
 525         CAutoFile hPipe;
 526
 527         while (*bThreadRun)
 528         {
 529                 hPipe = CreateNamedPipe(
 530                         GetCachePipeName(),
 531                         PIPE_ACCESS_DUPLEX,       // read/write access
 532                         PIPE_TYPE_MESSAGE |       // message type pipe
 533                         PIPE_READMODE_MESSAGE |   // message-read mode
 534                         PIPE_WAIT,                // blocking mode
 535                         PIPE_UNLIMITED_INSTANCES, // max. instances
 536                         BUFSIZE,                  // output buffer size
 537                         BUFSIZE,                  // input buffer size
 538                         NMPWAIT_USE_DEFAULT_WAIT, // client time-out
 539                         NULL);                                    // NULL DACL
 540
 541                 if (!hPipe)
 542                 {
 543                         if (*bThreadRun)
 544                                 Sleep(200);
 545                         continue; // never leave the thread!
 546                 }
 547
 548                 // Wait for the client to connect; if it succeeds,
 549                 // the function returns a nonzero value. If the function returns
 550                 // zero, GetLastError returns ERROR_PIPE_CONNECTED.
 551                 fConnected = ConnectNamedPipe(hPipe, NULL) ? TRUE : (GetLastError() == ERROR_PIPE_CONNECTED);
 552                 if (fConnected)
 553                 {
 554                         // Create a thread for this client.
 555                         CAutoGeneralHandle hInstanceThread = CreateThread(
 556                                 NULL,              // no security attribute
 557                                 0,                 // default stack size
 558                                 InstanceThread,
 559                                 (HANDLE) hPipe,    // thread parameter
 560                                 0,                 // not suspended
 561                                 &dwThreadId);      // returns thread ID
 562
 563                         if (!hInstanceThread)
 564                         {
 565                                 DisconnectNamedPipe(hPipe);
 566                                 // since we're now closing this thread, we also have to close the whole application!
 567                                 // otherwise the thread is dead, but the app is still running, refusing new instances
 568                                 // but no pipe will be available anymore.
 569                                 PostMessage(hWndHidden, WM_CLOSE, 0, 0);
 570                                 return 1;
 571                         }
 572                         // detach the handle, since we passed it to the thread
 573                         hPipe.Detach();
 574                 }
 575                 else
 576                 {
 577                         // The client could not connect, so close the pipe.
 578                         hPipe.CloseHandle();
 579                         if (*bThreadRun)
 580                                 Sleep(200);
 581                         continue;       // don't end the thread!
 582                 }
 583         }
 584         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Pipe thread exited\n");
 585         return 0;
 586 }
 587
 588 DWORD WINAPI CommandWaitThread(LPVOID lpvParam)
 589 {
 590         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CommandWaitThread started\n");
 591         bool* bThreadRun = (bool*)lpvParam;
 592         // The main loop creates an instance of the named pipe and
 593         // then waits for a client to connect to it. When the client
 594         // connects, a thread is created to handle communications
 595         // with that client, and the loop is repeated.
 596         DWORD dwThreadId;
 597         BOOL fConnected;
 598         CAutoFile hPipe;
 599
 600         while (*bThreadRun)
 601         {
 602                 hPipe = CreateNamedPipe(
 603                         GetCacheCommandPipeName(),
 604                         PIPE_ACCESS_DUPLEX,       // read/write access
 605                         PIPE_TYPE_MESSAGE |       // message type pipe
 606                         PIPE_READMODE_MESSAGE |   // message-read mode
 607                         PIPE_WAIT,                // blocking mode
 608                         PIPE_UNLIMITED_INSTANCES, // max. instances
 609                         BUFSIZE,                  // output buffer size
 610                         BUFSIZE,                  // input buffer size
 611                         NMPWAIT_USE_DEFAULT_WAIT, // client time-out
 612                         NULL);                // NULL DACL
 613
 614                 if (!hPipe)
 615                 {
 616                         if (*bThreadRun)
 617                                 Sleep(200);
 618                         continue; // never leave the thread!
 619                 }
 620
 621                 // Wait for the client to connect; if it succeeds,
 622                 // the function returns a nonzero value. If the function returns
 623                 // zero, GetLastError returns ERROR_PIPE_CONNECTED.
 624                 fConnected = ConnectNamedPipe(hPipe, NULL) ? TRUE : (GetLastError() == ERROR_PIPE_CONNECTED);
 625                 if (fConnected)
 626                 {
 627                         // Create a thread for this client.
 628                         CAutoGeneralHandle hCommandThread = CreateThread(
 629                                 NULL,              // no security attribute
 630                                 0,                 // default stack size
 631                                 CommandThread,
 632                                 (HANDLE) hPipe,    // thread parameter
 633                                 0,                 // not suspended
 634                                 &dwThreadId);      // returns thread ID
 635
 636                         if (!hCommandThread)
 637                         {
 638                                 DisconnectNamedPipe(hPipe);
 639                                 hPipe.CloseHandle();
 640                                 // since we're now closing this thread, we also have to close the whole application!
 641                                 // otherwise the thread is dead, but the app is still running, refusing new instances
 642                                 // but no pipe will be available anymore.
 643                                 PostMessage(hWndHidden, WM_CLOSE, 0, 0);
 644                                 return 1;
 645                         }
 646                         // detach the handle, since we passed it to the thread
 647                         hPipe.Detach();
 648                 }
 649                 else
 650                 {
 651                         // The client could not connect, so close the pipe.
 652                         hPipe.CloseHandle();
 653                         if (*bThreadRun)
 654                                 Sleep(200);
 655                         continue;       // don't end the thread!
 656                 }
 657         }
 658         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CommandWait thread exited\n");
 659         return 0;
 660 }
 661
 662 DWORD WINAPI InstanceThread(LPVOID lpvParam)
 663 {
 664         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": InstanceThread started\n");
 665         TGITCacheResponse response;
 666         DWORD cbBytesRead, cbWritten;
 667         CAutoFile hPipe;
 668
 669         // The thread's parameter is a handle to a pipe instance.
 670
 671         hPipe = lpvParam;
 672         InterlockedIncrement(&nThreadCount);
 673         while (bRun)
 674         {
 675                 // Read client requests from the pipe.
 676                 TGITCacheRequest request;
 677                 BOOL fSuccess = ReadFile(
 678                         hPipe,        // handle to pipe
 679                         &request,    // buffer to receive data
 680                         sizeof(request), // size of buffer
 681                         &cbBytesRead, // number of bytes read
 682                         NULL);        // not overlapped I/O
 683
 684                 if (! fSuccess || cbBytesRead == 0)
 685                 {
 686                         DisconnectNamedPipe(hPipe);
 687                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Instance thread exited\n");
 688                         InterlockedDecrement(&nThreadCount);
 689                         if (nThreadCount == 0)
 690                                 PostMessage(hWndHidden, WM_CLOSE, 0, 0);
 691                         return 1;
 692                 }
 693
 694                 DWORD responseLength;
 695                 GetAnswerToRequest(&request, &response, &responseLength);
 696
 697                 // Write the reply to the pipe.
 698                 fSuccess = WriteFile(
 699                         hPipe,        // handle to pipe
 700                         &response,      // buffer to write from
 701                         responseLength, // number of bytes to write
 702                         &cbWritten,   // number of bytes written
 703                         NULL);        // not overlapped I/O
 704
 705                 if (! fSuccess || responseLength != cbWritten)
 706                 {
 707                         DisconnectNamedPipe(hPipe);
 708                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Instance thread exited\n");
 709                         InterlockedDecrement(&nThreadCount);
 710                         if (nThreadCount == 0)
 711                                 PostMessage(hWndHidden, WM_CLOSE, 0, 0);
 712                         return 1;
 713                 }
 714         }
 715
 716         // Flush the pipe to allow the client to read the pipe's contents
 717         // before disconnecting. Then disconnect the pipe, and close the
 718         // handle to this pipe instance.
 719
 720         FlushFileBuffers(hPipe);
 721         DisconnectNamedPipe(hPipe);
 722         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Instance thread exited\n");
 723         InterlockedDecrement(&nThreadCount);
 724         if (nThreadCount == 0)
 725                 PostMessage(hWndHidden, WM_CLOSE, 0, 0);
 726         return 0;
 727 }
 728
 729 DWORD WINAPI CommandThread(LPVOID lpvParam)
 730 {
 731         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CommandThread started\n");
 732         DWORD cbBytesRead;
 733         CAutoFile hPipe;
 734
 735         // The thread's parameter is a handle to a pipe instance.
 736
 737         hPipe = lpvParam;
 738
 739         while (bRun)
 740         {
 741                 // Read client requests from the pipe.
 742                 TGITCacheCommand command;
 743                 BOOL fSuccess = ReadFile(
 744                         hPipe,                          // handle to pipe
 745                         &command,                       // buffer to receive data
 746                         sizeof(command),        // size of buffer
 747                         &cbBytesRead,           // number of bytes read
 748                         NULL);                          // not overlapped I/O
 749
 750                 if (! fSuccess || cbBytesRead == 0)
 751                 {
 752                         DisconnectNamedPipe(hPipe);
 753                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Command thread exited\n");
 754                         return 1;
 755                 }
 756
 757                 switch (command.command)
 758                 {
 759                         case TGITCACHECOMMAND_END:
 760                                 FlushFileBuffers(hPipe);
 761                                 DisconnectNamedPipe(hPipe);
 762                                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Command thread exited\n");
 763                                 return 0;
 764                         case TGITCACHECOMMAND_CRAWL:
 765                                 {
 766                                         CTGitPath changedpath;
 767                                         changedpath.SetFromWin(command.path, true);
 768                                         // remove the path from our cache - that will 'invalidate' it.
 769                                         {
 770                                                 CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
 771                                                 CGitStatusCache::Instance().RemoveCacheForPath(changedpath);
 772                                         }
 773                                         CGitStatusCache::Instance().AddFolderForCrawling(changedpath.GetDirectory());
 774                                 }
 775                                 break;
 776                         case TGITCACHECOMMAND_REFRESHALL:
 777                                 {
 778                                         CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
 779                                         CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": refresh all\n"));
 780                                         CGitStatusCache::Instance().Refresh();
 781                                 }
 782                                 break;
 783                         case TGITCACHECOMMAND_RELEASE:
 784                                 {
 785                                         CTGitPath changedpath;
 786                                         changedpath.SetFromWin(command.path, true);
 787                                         CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": release handle for path %s\n"), changedpath.GetWinPath());
 788                                         CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
 789                                         CGitStatusCache::Instance().CloseWatcherHandles(changedpath);
 790                                         CGitStatusCache::Instance().RemoveCacheForPath(changedpath);
 791                                 }
 792                                 break;
 793                         case TGITCACHECOMMAND_BLOCK:
 794                                 {
 795                                         CTGitPath changedpath;
 796                                         changedpath.SetFromWin(command.path);
 797                                         CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": block path %s\n"), changedpath.GetWinPath());
 798                                         CGitStatusCache::Instance().BlockPath(changedpath);
 799                                 }
 800                                 break;
 801                         case TGITCACHECOMMAND_UNBLOCK:
 802                                 {
 803                                         CTGitPath changedpath;
 804                                         changedpath.SetFromWin(command.path);
 805                                         CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": unblock path %s\n"), changedpath.GetWinPath());
 806                                         CGitStatusCache::Instance().UnBlockPath(changedpath);
 807                                 }
 808                                 break;
 809                 }
 810         }
 811
 812         // Flush the pipe to allow the client to read the pipe's contents
 813         // before disconnecting. Then disconnect the pipe, and close the
 814         // handle to this pipe instance.
 815
 816         FlushFileBuffers(hPipe);
 817         DisconnectNamedPipe(hPipe);
 818         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Command thread exited\n");
 819         return 0;
 820 }