src/libgit2/system-call.c

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2014 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 "buffer.h"
  21 #include "netops.h"
  22 #include "system-call.h"
  23
  24 static void safeCloseHandle(HANDLE *handle)
  25 {
  26         if (*handle != INVALID_HANDLE_VALUE) {
  27                 CloseHandle(*handle);
  28                 *handle = INVALID_HANDLE_VALUE;
  29         }
  30 }
  31
  32 static int command_read(HANDLE handle, char *buffer, size_t buf_size, size_t *bytes_read)
  33 {
  34         *bytes_read = 0;
  35
  36         if (!ReadFile(handle, buffer, (DWORD)buf_size, (DWORD*)bytes_read, NULL)) {
  37                 giterr_set(GITERR_OS, "could not read data from external process");
  38                 return -1;
  39         }
  40
  41         return 0;
  42 }
  43
  44 static int command_readall(HANDLE handle, git_buf *buf)
  45 {
  46         size_t bytes_read = 0;
  47         do {
  48                 char buffer[65536];
  49                 command_read(handle, buffer, sizeof(buffer), &bytes_read);
  50                 git_buf_put(buf, buffer, bytes_read);
  51         } while (bytes_read);
  52
  53         return 0;
  54 }
  55
  56 struct ASYNCREADINGTHREADARGS {
  57         HANDLE *handle;
  58         git_buf *dest;
  59 };
  60
  61 static DWORD WINAPI AsyncReadingThread(LPVOID lpParam)
  62 {
  63         struct ASYNCREADINGTHREADARGS* pDataArray = (struct ASYNCREADINGTHREADARGS*)lpParam;
  64
  65         int ret = command_readall(*pDataArray->handle, pDataArray->dest);
  66
  67         safeCloseHandle(pDataArray->handle);
  68
  69         git__free(pDataArray);
  70
  71         return ret;
  72 }
  73
  74 static HANDLE commmand_start_reading_thread(HANDLE *handle, git_buf *dest)
  75 {
  76         struct ASYNCREADINGTHREADARGS *threadArguments = git__calloc(1, sizeof(struct ASYNCREADINGTHREADARGS));
  77         HANDLE thread;
  78         if (!threadArguments)
  79                 return NULL;
  80
  81         threadArguments->handle = handle;
  82         threadArguments->dest = dest;
  83
  84         thread = CreateThread(NULL, 0, AsyncReadingThread, threadArguments, 0, NULL);
  85         if (!thread)
  86                 git__free(threadArguments);
  87         return thread;
  88 }
  89
  90 int commmand_start_stdout_reading_thread(COMMAND_HANDLE *commandHandle, git_buf *dest)
  91 {
  92         HANDLE thread = commmand_start_reading_thread(&commandHandle->out, dest);
  93         if (!thread)
  94                 return -1;
  95         commandHandle->asyncReadOutThread = thread;
  96         return 0;
  97 }
  98
  99 static int command_wait_reading_thread(HANDLE *handle)
 100 {
 101         DWORD exitCode = MAXDWORD;
 102         if (*handle == INVALID_HANDLE_VALUE)
 103                 return -1;
 104
 105         WaitForSingleObject(*handle, INFINITE);
 106         if (!GetExitCodeThread(*handle, &exitCode) || exitCode) {
 107                 safeCloseHandle(handle);
 108                 return -1;
 109         }
 110         safeCloseHandle(handle);
 111         return 0;
 112 }
 113
 114 int command_wait_stdout_reading_thread(COMMAND_HANDLE *commandHandle)
 115 {
 116         return command_wait_reading_thread(&commandHandle->asyncReadOutThread);
 117 }
 118
 119 int command_start(wchar_t *cmd, COMMAND_HANDLE *commandHandle, LPWSTR pEnv)
 120 {
 121         SECURITY_ATTRIBUTES sa;
 122         HANDLE hReadOut = INVALID_HANDLE_VALUE, hWriteOut = INVALID_HANDLE_VALUE, hReadIn = INVALID_HANDLE_VALUE, hWriteIn = INVALID_HANDLE_VALUE, hReadError = INVALID_HANDLE_VALUE, hWriteError = INVALID_HANDLE_VALUE;
 123         STARTUPINFOW si = { 0 };
 124         PROCESS_INFORMATION pi = { 0 };
 125
 126         si.cb = sizeof(STARTUPINFOW);
 127
 128         sa.nLength = sizeof(SECURITY_ATTRIBUTES);
 129         sa.lpSecurityDescriptor = NULL;
 130         sa.bInheritHandle = TRUE;
 131         if (!CreatePipe(&hReadOut, &hWriteOut, &sa, 0)) {
 132                 giterr_set(GITERR_OS, "Could not create pipe");
 133                 return -1;
 134         }
 135         if (!CreatePipe(&hReadIn, &hWriteIn, &sa, 0)) {
 136                 giterr_set(GITERR_OS, "Could not create pipe");
 137                 CloseHandle(hReadOut);
 138                 CloseHandle(hWriteOut);
 139                 return -1;
 140         }
 141         if (commandHandle->errBuf && !CreatePipe(&hReadError, &hWriteError, &sa, 0)) {
 142                 CloseHandle(hReadOut);
 143                 CloseHandle(hWriteOut);
 144                 CloseHandle(hReadIn);
 145                 CloseHandle(hWriteIn);
 146                 return -1;
 147         }
 148
 149         si.hStdOutput = hWriteOut;
 150         si.hStdInput = hReadIn;
 151         si.hStdError = hWriteError;
 152
 153         // Ensure the read/write handle to the pipe for STDOUT resp. STDIN are not inherited.
 154         if (!SetHandleInformation(hReadOut, HANDLE_FLAG_INHERIT, 0) || !SetHandleInformation(hWriteIn, HANDLE_FLAG_INHERIT, 0) || (commandHandle->errBuf && !SetHandleInformation(hReadError, HANDLE_FLAG_INHERIT, 0))) {
 155                 CloseHandle(hReadOut);
 156                 CloseHandle(hWriteOut);
 157                 CloseHandle(hReadIn);
 158                 CloseHandle(hWriteIn);
 159                 safeCloseHandle(&hReadError);
 160                 safeCloseHandle(&hWriteError);
 161                 return -1;
 162         }
 163
 164         si.wShowWindow = SW_HIDE;
 165         si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
 166
 167         if (!CreateProcessW(NULL, cmd, NULL, NULL, TRUE, pEnv ? CREATE_UNICODE_ENVIRONMENT : 0, pEnv, NULL, &si, &pi)) {
 168                 giterr_set(GITERR_OS, "Could not start external tool");
 169                 CloseHandle(hReadOut);
 170                 CloseHandle(hWriteOut);
 171                 CloseHandle(hReadIn);
 172                 CloseHandle(hWriteIn);
 173                 safeCloseHandle(&hReadError);
 174                 safeCloseHandle(&hWriteError);
 175                 return -1;
 176         }
 177
 178         AllowSetForegroundWindow(pi.dwProcessId);
 179         WaitForInputIdle(pi.hProcess, 10000);
 180
 181         CloseHandle(hReadIn);
 182         CloseHandle(hWriteOut);
 183         if (commandHandle->errBuf) {
 184                 HANDLE asyncReadErrorThread;
 185                 CloseHandle(hWriteError);
 186                 commandHandle->err = hReadError;
 187                 asyncReadErrorThread = commmand_start_reading_thread(&commandHandle->err, commandHandle->errBuf);
 188                 if (!asyncReadErrorThread) {
 189                         CloseHandle(hReadOut);
 190                         CloseHandle(hWriteIn);
 191                         CloseHandle(hReadError);
 192                         return -1;
 193                 }
 194                 commandHandle->asyncReadErrorThread = asyncReadErrorThread;
 195         }
 196
 197         commandHandle->pi = pi;
 198         commandHandle->out = hReadOut;
 199         commandHandle->in = hWriteIn;
 200         commandHandle->running = TRUE;
 201         return 0;
 202 }
 203
 204 int command_read_stdout(COMMAND_HANDLE *commandHandle, char *buffer, size_t buf_size, size_t *bytes_read)
 205 {
 206         return command_read(commandHandle->out, buffer, buf_size, bytes_read);
 207 }
 208
 209 int command_write(COMMAND_HANDLE *commandHandle, const char *buffer, size_t len)
 210 {
 211         size_t off = 0;
 212         DWORD written = 0;
 213
 214         do {
 215                 if (!WriteFile(commandHandle->in, buffer + off, (DWORD)(len - off), &written, NULL)) {
 216                         giterr_set(GITERR_OS, "could not write data to external process");
 217                         return -1;
 218                 }
 219
 220                 off += written;
 221         } while (off < len);
 222
 223         return 0;
 224 }
 225
 226 int command_write_gitbuf(COMMAND_HANDLE *commandHandle, const git_buf *buf)
 227 {
 228         return command_write(commandHandle, buf->ptr, buf->size);
 229 }
 230
 231 void command_close_stdin(COMMAND_HANDLE *commandHandle)
 232 {
 233         safeCloseHandle(&commandHandle->in);
 234 }
 235
 236 void command_close_stdout(COMMAND_HANDLE *commandHandle)
 237 {
 238         safeCloseHandle(&commandHandle->out);
 239 }
 240
 241 DWORD command_close(COMMAND_HANDLE *commandHandle)
 242 {
 243         DWORD exitcode = MAXDWORD;
 244         if (!commandHandle->running)
 245                 return 1;
 246
 247         commandHandle->running = FALSE;
 248
 249         command_close_stdin(commandHandle);
 250         command_wait_stdout_reading_thread(commandHandle);
 251         command_close_stdout(commandHandle);
 252
 253         CloseHandle(commandHandle->pi.hThread);
 254
 255         WaitForSingleObject(commandHandle->pi.hProcess, INFINITE);
 256
 257         if (commandHandle->errBuf)
 258                 command_wait_reading_thread(&commandHandle->asyncReadErrorThread);
 259
 260         GetExitCodeProcess(commandHandle->pi.hProcess, &exitcode);
 261         CloseHandle(commandHandle->pi.hProcess);
 262
 263         return exitcode;
 264 }