src/TGitCache/CacheInterface.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // External Cache Copyright (C) 2007,2009-2012 - TortoiseSVN
   4 // Copyright (C) 2008-2013, 2016 - 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 #include "stdafx.h"
  21 #include "CacheInterface.h"
  22 #include "SmartHandle.h"
  23 #include <memory>
  24
  25 CString GetCachePipeName()
  26 {
  27         return TGIT_CACHE_PIPE_NAME + GetCacheID();
  28 }
  29
  30 CString GetCacheCommandPipeName()
  31 {
  32         return TGIT_CACHE_COMMANDPIPE_NAME + GetCacheID();
  33 }
  34
  35 CString GetCacheMutexName()
  36 {
  37         return TGIT_CACHE_MUTEX_NAME + GetCacheID();
  38 }
  39
  40 CString GetCacheID()
  41 {
  42         CString t;
  43         CAutoGeneralHandle token;
  44         BOOL result = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, token.GetPointer());
  45         if(result)
  46         {
  47                 DWORD len = 0;
  48                 GetTokenInformation(token, TokenStatistics, nullptr, 0, &len);
  49                 if (len >= sizeof (TOKEN_STATISTICS))
  50                 {
  51                         auto data = std::make_unique<BYTE[]>(len);
  52                         GetTokenInformation(token, TokenStatistics, data.get(), len, &len);
  53                         LUID uid = ((PTOKEN_STATISTICS)data.get())->AuthenticationId;
  54                         t.Format(L"-%08x%08x", uid.HighPart, uid.LowPart);
  55                 }
  56         }
  57         return t;
  58 }
  59
  60 bool SendCacheCommand(BYTE command, const WCHAR* path /* = nullptr */)
  61 {
  62         CAutoFile hPipe;
  63         CString pipeName = GetCacheCommandPipeName();
  64         for (int retry = 0; retry < 2; ++retry)
  65         {
  66                 if (retry > 0)
  67                         WaitNamedPipe(pipeName, 50);
  68
  69                 hPipe = CreateFile(
  70                         pipeName,                                               // pipe name
  71                         GENERIC_READ |                                  // read and write access
  72                         GENERIC_WRITE,
  73                         0,                                                              // no sharing
  74                         nullptr,                                                // default security attributes
  75                         OPEN_EXISTING,                                  // opens existing pipe
  76                         FILE_FLAG_OVERLAPPED,                   // default attributes
  77                         nullptr);                                               // no template file
  78
  79                 if (!hPipe && GetLastError() == ERROR_PIPE_BUSY)
  80                 {
  81                         // TGitCache is running but is busy connecting a different client.
  82                         // Do not give up immediately but wait for a few milliseconds until
  83                         // the server has created the next pipe instance
  84                         continue;
  85                 }
  86                 break;
  87         }
  88
  89         if (!hPipe)
  90         {
  91                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Could not connect to pipe\n");
  92                 return false;
  93         }
  94
  95         // The pipe connected; change to message-read mode.
  96         DWORD dwMode = PIPE_READMODE_MESSAGE;
  97         if (SetNamedPipeHandleState(
  98                 hPipe,          // pipe handle
  99                 &dwMode,        // new pipe mode
 100                 nullptr,        // don't set maximum bytes
 101                 nullptr))       // don't set maximum time
 102         {
 103                 DWORD cbWritten;
 104                 TGITCacheCommand cmd = { 0 };
 105                 cmd.command = command;
 106                 if (path)
 107                         wcsncpy_s(cmd.path, path, _TRUNCATE);
 108
 109                 int retrycount = 2;
 110                 BOOL fSuccess = FALSE;
 111                 do
 112                 {
 113                         fSuccess = WriteFile(
 114                                 hPipe,                  // handle to pipe
 115                                 &cmd,                   // buffer to write from
 116                                 sizeof(cmd),    // number of bytes to write
 117                                 &cbWritten,             // number of bytes written
 118                                 nullptr);               // not overlapped I/O
 119                         retrycount--;
 120                         if (! fSuccess || sizeof(cmd) != cbWritten)
 121                                 Sleep(10);
 122                 } while ((retrycount) && (! fSuccess || sizeof(cmd) != cbWritten));
 123
 124                 if (! fSuccess || sizeof(cmd) != cbWritten)
 125                 {
 126                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Could not write to pipe\n");
 127                         DisconnectNamedPipe(hPipe);
 128                         return false;
 129                 }
 130                 // now tell the cache we don't need it's command thread anymore
 131                 SecureZeroMemory(&cmd, sizeof(TGITCacheCommand));
 132                 cmd.command = TGITCACHECOMMAND_END;
 133                 WriteFile(
 134                         hPipe,                  // handle to pipe
 135                         &cmd,                   // buffer to write from
 136                         sizeof(cmd),    // number of bytes to write
 137                         &cbWritten,             // number of bytes written
 138                         nullptr);               // not overlapped I/O
 139                 DisconnectNamedPipe(hPipe);
 140         }
 141         else
 142         {
 143                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": SetNamedPipeHandleState failed");
 144                 return false;
 145         }
 146
 147         return true;
 148 }
 149
 150 CBlockCacheForPath::CBlockCacheForPath(const WCHAR * aPath)
 151         : m_bBlocked(false)
 152 {
 153         wcsncpy_s(path, aPath, _countof(path) - 1);
 154
 155         if (!SendCacheCommand(TGITCACHECOMMAND_BLOCK, path))
 156                 return;
 157
 158         // Wait a short while to make sure the cache has
 159         // processed this command. Without this, we risk
 160         // executing the svn command before the cache has
 161         // blocked the path and already gets change notifications.
 162         Sleep(20);
 163         m_bBlocked = true;
 164 }
 165
 166 CBlockCacheForPath::~CBlockCacheForPath()
 167 {
 168         if (!m_bBlocked)
 169                 return;
 170
 171         for (int retry = 0; retry < 3; ++retry)
 172         {
 173                 if (retry > 0)
 174                         Sleep(10);
 175
 176                 if (SendCacheCommand(TGITCACHECOMMAND_UNBLOCK, path))
 177                         break;
 178         }
 179 }