compat/mingw.c

   1 #include "../git-compat-util.h"
   2 #include "win32.h"
   3 #include <conio.h>
   4 #include <wchar.h>
   5 #include "../strbuf.h"
   6 #include "../run-command.h"
   7 #include "../cache.h"
   8
   9 static const int delay[] = { 0, 1, 10, 20, 40 };
  10 unsigned int _CRT_fmode = _O_BINARY;
  11
  12 int err_win_to_posix(DWORD winerr)
  13 {
  14         int error = ENOSYS;
  15         switch(winerr) {
  16         case ERROR_ACCESS_DENIED: error = EACCES; break;
  17         case ERROR_ACCOUNT_DISABLED: error = EACCES; break;
  18         case ERROR_ACCOUNT_RESTRICTION: error = EACCES; break;
  19         case ERROR_ALREADY_ASSIGNED: error = EBUSY; break;
  20         case ERROR_ALREADY_EXISTS: error = EEXIST; break;
  21         case ERROR_ARITHMETIC_OVERFLOW: error = ERANGE; break;
  22         case ERROR_BAD_COMMAND: error = EIO; break;
  23         case ERROR_BAD_DEVICE: error = ENODEV; break;
  24         case ERROR_BAD_DRIVER_LEVEL: error = ENXIO; break;
  25         case ERROR_BAD_EXE_FORMAT: error = ENOEXEC; break;
  26         case ERROR_BAD_FORMAT: error = ENOEXEC; break;
  27         case ERROR_BAD_LENGTH: error = EINVAL; break;
  28         case ERROR_BAD_PATHNAME: error = ENOENT; break;
  29         case ERROR_BAD_PIPE: error = EPIPE; break;
  30         case ERROR_BAD_UNIT: error = ENODEV; break;
  31         case ERROR_BAD_USERNAME: error = EINVAL; break;
  32         case ERROR_BROKEN_PIPE: error = EPIPE; break;
  33         case ERROR_BUFFER_OVERFLOW: error = ENAMETOOLONG; break;
  34         case ERROR_BUSY: error = EBUSY; break;
  35         case ERROR_BUSY_DRIVE: error = EBUSY; break;
  36         case ERROR_CALL_NOT_IMPLEMENTED: error = ENOSYS; break;
  37         case ERROR_CANNOT_MAKE: error = EACCES; break;
  38         case ERROR_CANTOPEN: error = EIO; break;
  39         case ERROR_CANTREAD: error = EIO; break;
  40         case ERROR_CANTWRITE: error = EIO; break;
  41         case ERROR_CRC: error = EIO; break;
  42         case ERROR_CURRENT_DIRECTORY: error = EACCES; break;
  43         case ERROR_DEVICE_IN_USE: error = EBUSY; break;
  44         case ERROR_DEV_NOT_EXIST: error = ENODEV; break;
  45         case ERROR_DIRECTORY: error = EINVAL; break;
  46         case ERROR_DIR_NOT_EMPTY: error = ENOTEMPTY; break;
  47         case ERROR_DISK_CHANGE: error = EIO; break;
  48         case ERROR_DISK_FULL: error = ENOSPC; break;
  49         case ERROR_DRIVE_LOCKED: error = EBUSY; break;
  50         case ERROR_ENVVAR_NOT_FOUND: error = EINVAL; break;
  51         case ERROR_EXE_MARKED_INVALID: error = ENOEXEC; break;
  52         case ERROR_FILENAME_EXCED_RANGE: error = ENAMETOOLONG; break;
  53         case ERROR_FILE_EXISTS: error = EEXIST; break;
  54         case ERROR_FILE_INVALID: error = ENODEV; break;
  55         case ERROR_FILE_NOT_FOUND: error = ENOENT; break;
  56         case ERROR_GEN_FAILURE: error = EIO; break;
  57         case ERROR_HANDLE_DISK_FULL: error = ENOSPC; break;
  58         case ERROR_INSUFFICIENT_BUFFER: error = ENOMEM; break;
  59         case ERROR_INVALID_ACCESS: error = EACCES; break;
  60         case ERROR_INVALID_ADDRESS: error = EFAULT; break;
  61         case ERROR_INVALID_BLOCK: error = EFAULT; break;
  62         case ERROR_INVALID_DATA: error = EINVAL; break;
  63         case ERROR_INVALID_DRIVE: error = ENODEV; break;
  64         case ERROR_INVALID_EXE_SIGNATURE: error = ENOEXEC; break;
  65         case ERROR_INVALID_FLAGS: error = EINVAL; break;
  66         case ERROR_INVALID_FUNCTION: error = ENOSYS; break;
  67         case ERROR_INVALID_HANDLE: error = EBADF; break;
  68         case ERROR_INVALID_LOGON_HOURS: error = EACCES; break;
  69         case ERROR_INVALID_NAME: error = EINVAL; break;
  70         case ERROR_INVALID_OWNER: error = EINVAL; break;
  71         case ERROR_INVALID_PARAMETER: error = EINVAL; break;
  72         case ERROR_INVALID_PASSWORD: error = EPERM; break;
  73         case ERROR_INVALID_PRIMARY_GROUP: error = EINVAL; break;
  74         case ERROR_INVALID_SIGNAL_NUMBER: error = EINVAL; break;
  75         case ERROR_INVALID_TARGET_HANDLE: error = EIO; break;
  76         case ERROR_INVALID_WORKSTATION: error = EACCES; break;
  77         case ERROR_IO_DEVICE: error = EIO; break;
  78         case ERROR_IO_INCOMPLETE: error = EINTR; break;
  79         case ERROR_LOCKED: error = EBUSY; break;
  80         case ERROR_LOCK_VIOLATION: error = EACCES; break;
  81         case ERROR_LOGON_FAILURE: error = EACCES; break;
  82         case ERROR_MAPPED_ALIGNMENT: error = EINVAL; break;
  83         case ERROR_META_EXPANSION_TOO_LONG: error = E2BIG; break;
  84         case ERROR_MORE_DATA: error = EPIPE; break;
  85         case ERROR_NEGATIVE_SEEK: error = ESPIPE; break;
  86         case ERROR_NOACCESS: error = EFAULT; break;
  87         case ERROR_NONE_MAPPED: error = EINVAL; break;
  88         case ERROR_NOT_ENOUGH_MEMORY: error = ENOMEM; break;
  89         case ERROR_NOT_READY: error = EAGAIN; break;
  90         case ERROR_NOT_SAME_DEVICE: error = EXDEV; break;
  91         case ERROR_NO_DATA: error = EPIPE; break;
  92         case ERROR_NO_MORE_SEARCH_HANDLES: error = EIO; break;
  93         case ERROR_NO_PROC_SLOTS: error = EAGAIN; break;
  94         case ERROR_NO_SUCH_PRIVILEGE: error = EACCES; break;
  95         case ERROR_OPEN_FAILED: error = EIO; break;
  96         case ERROR_OPEN_FILES: error = EBUSY; break;
  97         case ERROR_OPERATION_ABORTED: error = EINTR; break;
  98         case ERROR_OUTOFMEMORY: error = ENOMEM; break;
  99         case ERROR_PASSWORD_EXPIRED: error = EACCES; break;
 100         case ERROR_PATH_BUSY: error = EBUSY; break;
 101         case ERROR_PATH_NOT_FOUND: error = ENOENT; break;
 102         case ERROR_PIPE_BUSY: error = EBUSY; break;
 103         case ERROR_PIPE_CONNECTED: error = EPIPE; break;
 104         case ERROR_PIPE_LISTENING: error = EPIPE; break;
 105         case ERROR_PIPE_NOT_CONNECTED: error = EPIPE; break;
 106         case ERROR_PRIVILEGE_NOT_HELD: error = EACCES; break;
 107         case ERROR_READ_FAULT: error = EIO; break;
 108         case ERROR_SEEK: error = EIO; break;
 109         case ERROR_SEEK_ON_DEVICE: error = ESPIPE; break;
 110         case ERROR_SHARING_BUFFER_EXCEEDED: error = ENFILE; break;
 111         case ERROR_SHARING_VIOLATION: error = EACCES; break;
 112         case ERROR_STACK_OVERFLOW: error = ENOMEM; break;
 113         case ERROR_SWAPERROR: error = ENOENT; break;
 114         case ERROR_TOO_MANY_MODULES: error = EMFILE; break;
 115         case ERROR_TOO_MANY_OPEN_FILES: error = EMFILE; break;
 116         case ERROR_UNRECOGNIZED_MEDIA: error = ENXIO; break;
 117         case ERROR_UNRECOGNIZED_VOLUME: error = ENODEV; break;
 118         case ERROR_WAIT_NO_CHILDREN: error = ECHILD; break;
 119         case ERROR_WRITE_FAULT: error = EIO; break;
 120         case ERROR_WRITE_PROTECT: error = EROFS; break;
 121         }
 122         return error;
 123 }
 124
 125 static inline int is_file_in_use_error(DWORD errcode)
 126 {
 127         switch (errcode) {
 128         case ERROR_SHARING_VIOLATION:
 129         case ERROR_ACCESS_DENIED:
 130                 return 1;
 131         }
 132
 133         return 0;
 134 }
 135
 136 static int read_yes_no_answer(void)
 137 {
 138         char answer[1024];
 139
 140         if (fgets(answer, sizeof(answer), stdin)) {
 141                 size_t answer_len = strlen(answer);
 142                 int got_full_line = 0, c;
 143
 144                 /* remove the newline */
 145                 if (answer_len >= 2 && answer[answer_len-2] == '\r') {
 146                         answer[answer_len-2] = '\0';
 147                         got_full_line = 1;
 148                 } else if (answer_len >= 1 && answer[answer_len-1] == '\n') {
 149                         answer[answer_len-1] = '\0';
 150                         got_full_line = 1;
 151                 }
 152                 /* flush the buffer in case we did not get the full line */
 153                 if (!got_full_line)
 154                         while ((c = getchar()) != EOF && c != '\n')
 155                                 ;
 156         } else
 157                 /* we could not read, return the
 158                  * default answer which is no */
 159                 return 0;
 160
 161         if (tolower(answer[0]) == 'y' && !answer[1])
 162                 return 1;
 163         if (!strncasecmp(answer, "yes", sizeof(answer)))
 164                 return 1;
 165         if (tolower(answer[0]) == 'n' && !answer[1])
 166                 return 0;
 167         if (!strncasecmp(answer, "no", sizeof(answer)))
 168                 return 0;
 169
 170         /* did not find an answer we understand */
 171         return -1;
 172 }
 173
 174 static int ask_yes_no_if_possible(const char *format, ...)
 175 {
 176         char question[4096];
 177         const char *retry_hook[] = { NULL, NULL, NULL };
 178         va_list args;
 179
 180         va_start(args, format);
 181         vsnprintf(question, sizeof(question), format, args);
 182         va_end(args);
 183
 184         if ((retry_hook[0] = mingw_getenv("GIT_ASK_YESNO"))) {
 185                 retry_hook[1] = question;
 186                 return !run_command_v_opt(retry_hook, 0);
 187         }
 188
 189         if (!isatty(_fileno(stdin)) || !isatty(_fileno(stderr)))
 190                 return 0;
 191
 192         while (1) {
 193                 int answer;
 194                 fprintf(stderr, "%s (y/n) ", question);
 195
 196                 if ((answer = read_yes_no_answer()) >= 0)
 197                         return answer;
 198
 199                 fprintf(stderr, "Sorry, I did not understand your answer. "
 200                                 "Please type 'y' or 'n'\n");
 201         }
 202 }
 203
 204 int mingw_unlink(const char *pathname)
 205 {
 206         int ret, tries = 0;
 207         wchar_t wpathname[MAX_LONG_PATH];
 208         if (xutftowcs_long_path(wpathname, pathname) < 0)
 209                 return -1;
 210
 211         /* read-only files cannot be removed */
 212         _wchmod(wpathname, 0666);
 213         while ((ret = _wunlink(wpathname)) == -1 && tries < ARRAY_SIZE(delay)) {
 214                 if (!is_file_in_use_error(GetLastError()))
 215                         break;
 216                 /*
 217                  * We assume that some other process had the source or
 218                  * destination file open at the wrong moment and retry.
 219                  * In order to give the other process a higher chance to
 220                  * complete its operation, we give up our time slice now.
 221                  * If we have to retry again, we do sleep a bit.
 222                  */
 223                 Sleep(delay[tries]);
 224                 tries++;
 225         }
 226         while (ret == -1 && is_file_in_use_error(GetLastError()) &&
 227                ask_yes_no_if_possible("Unlink of file '%s' failed. "
 228                         "Should I try again?", pathname))
 229                ret = _wunlink(wpathname);
 230         return ret;
 231 }
 232
 233 static int is_dir_empty(const wchar_t *wpath)
 234 {
 235         WIN32_FIND_DATAW findbuf;
 236         HANDLE handle;
 237         wchar_t wbuf[MAX_LONG_PATH + 2];
 238         wcscpy(wbuf, wpath);
 239         wcscat(wbuf, L"\\*");
 240         handle = FindFirstFileW(wbuf, &findbuf);
 241         if (handle == INVALID_HANDLE_VALUE)
 242                 return GetLastError() == ERROR_NO_MORE_FILES;
 243
 244         while (!wcscmp(findbuf.cFileName, L".") ||
 245                         !wcscmp(findbuf.cFileName, L".."))
 246                 if (!FindNextFileW(handle, &findbuf)) {
 247                         DWORD err = GetLastError();
 248                         FindClose(handle);
 249                         return err == ERROR_NO_MORE_FILES;
 250                 }
 251         FindClose(handle);
 252         return 0;
 253 }
 254
 255 int mingw_rmdir(const char *pathname)
 256 {
 257         int ret, tries = 0;
 258         wchar_t wpathname[MAX_LONG_PATH];
 259         if (xutftowcs_long_path(wpathname, pathname) < 0)
 260                 return -1;
 261
 262         while ((ret = _wrmdir(wpathname)) == -1 && tries < ARRAY_SIZE(delay)) {
 263                 if (!is_file_in_use_error(GetLastError()))
 264                         errno = err_win_to_posix(GetLastError());
 265                 if (errno != EACCES)
 266                         break;
 267                 if (!is_dir_empty(wpathname)) {
 268                         errno = ENOTEMPTY;
 269                         break;
 270                 }
 271                 /*
 272                  * We assume that some other process had the source or
 273                  * destination file open at the wrong moment and retry.
 274                  * In order to give the other process a higher chance to
 275                  * complete its operation, we give up our time slice now.
 276                  * If we have to retry again, we do sleep a bit.
 277                  */
 278                 Sleep(delay[tries]);
 279                 tries++;
 280         }
 281         while (ret == -1 && errno == EACCES && is_file_in_use_error(GetLastError()) &&
 282                ask_yes_no_if_possible("Deletion of directory '%s' failed. "
 283                         "Should I try again?", pathname))
 284                ret = _wrmdir(wpathname);
 285         return ret;
 286 }
 287
 288 static int make_hidden(const wchar_t *path)
 289 {
 290         DWORD attribs = GetFileAttributesW(path);
 291         if (SetFileAttributesW(path, FILE_ATTRIBUTE_HIDDEN | attribs))
 292                 return 0;
 293         errno = err_win_to_posix(GetLastError());
 294         return -1;
 295 }
 296
 297 void mingw_mark_as_git_dir(const char *dir)
 298 {
 299         wchar_t wdir[MAX_LONG_PATH];
 300         if (hide_dotfiles != HIDE_DOTFILES_FALSE && !is_bare_repository())
 301                 if (xutftowcs_long_path(wdir, dir) < 0 || make_hidden(wdir))
 302                         warning("Failed to make '%s' hidden", dir);
 303         git_config_set("core.hideDotFiles",
 304                 hide_dotfiles == HIDE_DOTFILES_FALSE ? "false" :
 305                 (hide_dotfiles == HIDE_DOTFILES_DOTGITONLY ?
 306                  "dotGitOnly" : "true"));
 307 }
 308
 309 int mingw_mkdir(const char *path, int mode)
 310 {
 311         int ret;
 312         wchar_t wpath[MAX_LONG_PATH];
 313         /* CreateDirectoryW path limit is 248 (MAX_PATH - 8.3 file name) */
 314         if (xutftowcs_path_ex(wpath, path, MAX_LONG_PATH, -1, 248,
 315                         core_long_paths) < 0)
 316                 return -1;
 317
 318         ret = _wmkdir(wpath);
 319         if (!ret && hide_dotfiles == HIDE_DOTFILES_TRUE) {
 320                 /*
 321                  * In Windows a file or dir starting with a dot is not
 322                  * automatically hidden. So lets mark it as hidden when
 323                  * such a directory is created.
 324                  */
 325                 const char *start = basename((char*)path);
 326                 if (*start == '.')
 327                         return make_hidden(wpath);
 328         }
 329         return ret;
 330 }
 331
 332 int mingw_open (const char *filename, int oflags, ...)
 333 {
 334         va_list args;
 335         unsigned mode;
 336         int fd;
 337         wchar_t wfilename[MAX_LONG_PATH];
 338
 339         va_start(args, oflags);
 340         mode = va_arg(args, int);
 341         va_end(args);
 342
 343         if (filename && !strcmp(filename, "/dev/null"))
 344                 filename = "nul";
 345
 346         if (xutftowcs_long_path(wfilename, filename) < 0)
 347                 return -1;
 348         fd = _wopen(wfilename, oflags, mode);
 349
 350         if (fd < 0 && (oflags & O_CREAT) && errno == EACCES) {
 351                 DWORD attrs = GetFileAttributesW(wfilename);
 352                 if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY))
 353                         errno = EISDIR;
 354         }
 355         if ((oflags & O_CREAT) && fd >= 0 &&
 356             hide_dotfiles == HIDE_DOTFILES_TRUE) {
 357                 /*
 358                  * In Windows a file or dir starting with a dot is not
 359                  * automatically hidden. So lets mark it as hidden when
 360                  * such a file is created.
 361                  */
 362                 const char *start = basename((char*)filename);
 363                 if (*start == '.' && make_hidden(wfilename))
 364                         warning("Could not mark '%s' as hidden.", filename);
 365         }
 366         return fd;
 367 }
 368
 369 static BOOL WINAPI ctrl_ignore(DWORD type)
 370 {
 371         return TRUE;
 372 }
 373
 374 #undef fgetc
 375 int mingw_fgetc(FILE *stream)
 376 {
 377         int ch;
 378         if (!isatty(_fileno(stream)))
 379                 return fgetc(stream);
 380
 381         SetConsoleCtrlHandler(ctrl_ignore, TRUE);
 382         while (1) {
 383                 ch = fgetc(stream);
 384                 if (ch != EOF || GetLastError() != ERROR_OPERATION_ABORTED)
 385                         break;
 386
 387                 /* Ctrl+C was pressed, simulate SIGINT and retry */
 388                 mingw_raise(SIGINT);
 389         }
 390         SetConsoleCtrlHandler(ctrl_ignore, FALSE);
 391         return ch;
 392 }
 393
 394 #undef fopen
 395 FILE *mingw_fopen (const char *filename, const char *otype)
 396 {
 397         int hide = 0;
 398         FILE *file;
 399         wchar_t wfilename[MAX_LONG_PATH], wotype[4];
 400         if (hide_dotfiles == HIDE_DOTFILES_TRUE &&
 401             basename((char*)filename)[0] == '.')
 402                 hide = access(filename, F_OK);
 403         if (filename && !strcmp(filename, "/dev/null"))
 404                 filename = "nul";
 405         if (xutftowcs_long_path(wfilename, filename) < 0 ||
 406                 xutftowcs(wotype, otype, ARRAY_SIZE(wotype)) < 0)
 407                 return NULL;
 408         file = _wfopen(wfilename, wotype);
 409         if (file && hide && make_hidden(wfilename))
 410                 warning("Could not mark '%s' as hidden.", filename);
 411         return file;
 412 }
 413
 414 FILE *mingw_freopen (const char *filename, const char *otype, FILE *stream)
 415 {
 416         int hide = 0;
 417         FILE *file;
 418         wchar_t wfilename[MAX_LONG_PATH], wotype[4];
 419         if (hide_dotfiles == HIDE_DOTFILES_TRUE &&
 420             basename((char*)filename)[0] == '.')
 421                 hide = access(filename, F_OK);
 422         if (filename && !strcmp(filename, "/dev/null"))
 423                 filename = "nul";
 424         if (xutftowcs_long_path(wfilename, filename) < 0 ||
 425                 xutftowcs(wotype, otype, ARRAY_SIZE(wotype)) < 0)
 426                 return NULL;
 427         file = _wfreopen(wfilename, wotype, stream);
 428         if (file && hide && make_hidden(wfilename))
 429                 warning("Could not mark '%s' as hidden.", filename);
 430         return file;
 431 }
 432
 433 #undef fflush
 434 int mingw_fflush(FILE *stream)
 435 {
 436         int ret = fflush(stream);
 437
 438         /*
 439          * write() is used behind the scenes of stdio output functions.
 440          * Since git code does not check for errors after each stdio write
 441          * operation, it can happen that write() is called by a later
 442          * stdio function even if an earlier write() call failed. In the
 443          * case of a pipe whose readable end was closed, only the first
 444          * call to write() reports EPIPE on Windows. Subsequent write()
 445          * calls report EINVAL. It is impossible to notice whether this
 446          * fflush invocation triggered such a case, therefore, we have to
 447          * catch all EINVAL errors whole-sale.
 448          */
 449         if (ret && errno == EINVAL)
 450                 errno = EPIPE;
 451
 452         return ret;
 453 }
 454
 455 int mingw_access(const char *filename, int mode)
 456 {
 457         wchar_t wfilename[MAX_LONG_PATH];
 458         if (xutftowcs_long_path(wfilename, filename) < 0)
 459                 return -1;
 460         /* X_OK is not supported by the MSVCRT version */
 461         return _waccess(wfilename, mode & ~X_OK);
 462 }
 463
 464 /* cached length of current directory for handle_long_path */
 465 static int current_directory_len = 0;
 466
 467 int mingw_chdir(const char *dirname)
 468 {
 469         int result;
 470         wchar_t wdirname[MAX_PATH];
 471         /* SetCurrentDirectoryW doesn't support long paths */
 472         if (xutftowcs_path(wdirname, dirname) < 0)
 473                 return -1;
 474         result = _wchdir(wdirname);
 475         current_directory_len = GetCurrentDirectoryW(0, NULL);
 476         return result;
 477 }
 478
 479 int mingw_chmod(const char *filename, int mode)
 480 {
 481         wchar_t wfilename[MAX_LONG_PATH];
 482         if (xutftowcs_long_path(wfilename, filename) < 0)
 483                 return -1;
 484         return _wchmod(wfilename, mode);
 485 }
 486
 487 /* We keep the do_lstat code in a separate function to avoid recursion.
 488  * When a path ends with a slash, the stat will fail with ENOENT. In
 489  * this case, we strip the trailing slashes and stat again.
 490  *
 491  * If follow is true then act like stat() and report on the link
 492  * target. Otherwise report on the link itself.
 493  */
 494 static int do_lstat(int follow, const char *file_name, struct stat *buf)
 495 {
 496         WIN32_FILE_ATTRIBUTE_DATA fdata;
 497         wchar_t wfilename[MAX_LONG_PATH];
 498         if (xutftowcs_long_path(wfilename, file_name) < 0)
 499                 return -1;
 500
 501         if (GetFileAttributesExW(wfilename, GetFileExInfoStandard, &fdata)) {
 502                 buf->st_ino = 0;
 503                 buf->st_gid = 0;
 504                 buf->st_uid = 0;
 505                 buf->st_nlink = 1;
 506                 buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
 507                 buf->st_size = fdata.nFileSizeLow |
 508                         (((off_t)fdata.nFileSizeHigh)<<32);
 509                 buf->st_dev = buf->st_rdev = 0; /* not used by Git */
 510                 buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
 511                 buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
 512                 buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
 513                 if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
 514                         WIN32_FIND_DATAW findbuf;
 515                         HANDLE handle = FindFirstFileW(wfilename, &findbuf);
 516                         if (handle != INVALID_HANDLE_VALUE) {
 517                                 if ((findbuf.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) &&
 518                                                 (findbuf.dwReserved0 == IO_REPARSE_TAG_SYMLINK)) {
 519                                         if (follow) {
 520                                                 char buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
 521                                                 buf->st_size = readlink(file_name, buffer, MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
 522                                         } else {
 523                                                 buf->st_mode = S_IFLNK;
 524                                         }
 525                                         buf->st_mode |= S_IREAD;
 526                                         if (!(findbuf.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
 527                                                 buf->st_mode |= S_IWRITE;
 528                                 }
 529                                 FindClose(handle);
 530                         }
 531                 }
 532                 return 0;
 533         }
 534         switch (GetLastError()) {
 535         case ERROR_ACCESS_DENIED:
 536         case ERROR_SHARING_VIOLATION:
 537         case ERROR_LOCK_VIOLATION:
 538         case ERROR_SHARING_BUFFER_EXCEEDED:
 539                 errno = EACCES;
 540                 break;
 541         case ERROR_BUFFER_OVERFLOW:
 542                 errno = ENAMETOOLONG;
 543                 break;
 544         case ERROR_NOT_ENOUGH_MEMORY:
 545                 errno = ENOMEM;
 546                 break;
 547         default:
 548                 errno = ENOENT;
 549                 break;
 550         }
 551         return -1;
 552 }
 553
 554 /* We provide our own lstat/fstat functions, since the provided
 555  * lstat/fstat functions are so slow. These stat functions are
 556  * tailored for Git's usage (read: fast), and are not meant to be
 557  * complete. Note that Git stat()s are redirected to mingw_lstat()
 558  * too, since Windows doesn't really handle symlinks that well.
 559  */
 560 static int do_stat_internal(int follow, const char *file_name, struct stat *buf)
 561 {
 562         int namelen;
 563         char alt_name[MAX_LONG_PATH];
 564
 565         if (!do_lstat(follow, file_name, buf))
 566                 return 0;
 567
 568         /* if file_name ended in a '/', Windows returned ENOENT;
 569          * try again without trailing slashes
 570          */
 571         if (errno != ENOENT)
 572                 return -1;
 573
 574         namelen = strlen(file_name);
 575         if (namelen && file_name[namelen-1] != '/')
 576                 return -1;
 577         while (namelen && file_name[namelen-1] == '/')
 578                 --namelen;
 579         if (!namelen || namelen >= MAX_LONG_PATH)
 580                 return -1;
 581
 582         memcpy(alt_name, file_name, namelen);
 583         alt_name[namelen] = 0;
 584         return do_lstat(follow, alt_name, buf);
 585 }
 586
 587 int (*lstat)(const char *file_name, struct stat *buf) = mingw_lstat;
 588
 589 int mingw_lstat(const char *file_name, struct stat *buf)
 590 {
 591         return do_stat_internal(0, file_name, buf);
 592 }
 593 int mingw_stat(const char *file_name, struct stat *buf)
 594 {
 595         return do_stat_internal(1, file_name, buf);
 596 }
 597
 598 int mingw_fstat(int fd, struct stat *buf)
 599 {
 600         HANDLE fh = (HANDLE)_get_osfhandle(fd);
 601         BY_HANDLE_FILE_INFORMATION fdata;
 602
 603         if (fh == INVALID_HANDLE_VALUE) {
 604                 errno = EBADF;
 605                 return -1;
 606         }
 607         /* direct non-file handles to MS's fstat() */
 608         if (GetFileType(fh) != FILE_TYPE_DISK)
 609                 return _fstati64(fd, buf);
 610
 611         if (GetFileInformationByHandle(fh, &fdata)) {
 612                 buf->st_ino = 0;
 613                 buf->st_gid = 0;
 614                 buf->st_uid = 0;
 615                 buf->st_nlink = 1;
 616                 buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
 617                 buf->st_size = fdata.nFileSizeLow |
 618                         (((off_t)fdata.nFileSizeHigh)<<32);
 619                 buf->st_dev = buf->st_rdev = 0; /* not used by Git */
 620                 buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
 621                 buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
 622                 buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
 623                 return 0;
 624         }
 625         errno = EBADF;
 626         return -1;
 627 }
 628
 629 static inline void time_t_to_filetime(time_t t, FILETIME *ft)
 630 {
 631         long long winTime = t * 10000000LL + 116444736000000000LL;
 632         ft->dwLowDateTime = winTime;
 633         ft->dwHighDateTime = winTime >> 32;
 634 }
 635
 636 int mingw_utime (const char *file_name, const struct utimbuf *times)
 637 {
 638         FILETIME mft, aft;
 639         int fh, rc;
 640         DWORD attrs;
 641         wchar_t wfilename[MAX_LONG_PATH];
 642         if (xutftowcs_long_path(wfilename, file_name) < 0)
 643                 return -1;
 644
 645         /* must have write permission */
 646         attrs = GetFileAttributesW(wfilename);
 647         if (attrs != INVALID_FILE_ATTRIBUTES &&
 648             (attrs & FILE_ATTRIBUTE_READONLY)) {
 649                 /* ignore errors here; open() will report them */
 650                 SetFileAttributesW(wfilename, attrs & ~FILE_ATTRIBUTE_READONLY);
 651         }
 652
 653         if ((fh = _wopen(wfilename, O_RDWR | O_BINARY)) < 0) {
 654                 rc = -1;
 655                 goto revert_attrs;
 656         }
 657
 658         if (times) {
 659                 time_t_to_filetime(times->modtime, &mft);
 660                 time_t_to_filetime(times->actime, &aft);
 661         } else {
 662                 GetSystemTimeAsFileTime(&mft);
 663                 aft = mft;
 664         }
 665         if (!SetFileTime((HANDLE)_get_osfhandle(fh), NULL, &aft, &mft)) {
 666                 errno = EINVAL;
 667                 rc = -1;
 668         } else
 669                 rc = 0;
 670         close(fh);
 671
 672 revert_attrs:
 673         if (attrs != INVALID_FILE_ATTRIBUTES &&
 674             (attrs & FILE_ATTRIBUTE_READONLY)) {
 675                 /* ignore errors again */
 676                 SetFileAttributesW(wfilename, attrs);
 677         }
 678         return rc;
 679 }
 680
 681 unsigned int sleep (unsigned int seconds)
 682 {
 683         Sleep(seconds*1000);
 684         return 0;
 685 }
 686
 687 char *mingw_mktemp(char *template)
 688 {
 689         wchar_t wtemplate[MAX_PATH];
 690         /* we need to return the path, thus no long paths here! */
 691         if (xutftowcs_path(wtemplate, template) < 0)
 692                 return NULL;
 693         if (!_wmktemp(wtemplate))
 694                 return NULL;
 695         if (xwcstoutf(template, wtemplate, strlen(template) + 1) < 0)
 696                 return NULL;
 697         return template;
 698 }
 699
 700 int mkstemp(char *template)
 701 {
 702         char *filename = mktemp(template);
 703         if (filename == NULL)
 704                 return -1;
 705         return open(filename, O_RDWR | O_CREAT, 0600);
 706 }
 707
 708 int gettimeofday(struct timeval *tv, void *tz)
 709 {
 710         FILETIME ft;
 711         long long hnsec;
 712
 713         GetSystemTimeAsFileTime(&ft);
 714         hnsec = filetime_to_hnsec(&ft);
 715         tv->tv_sec = hnsec / 10000000;
 716         tv->tv_usec = (hnsec % 10000000) / 10;
 717         return 0;
 718 }
 719
 720 int pipe(int filedes[2])
 721 {
 722         HANDLE h[2];
 723
 724         /* this creates non-inheritable handles */
 725         if (!CreatePipe(&h[0], &h[1], NULL, 8192)) {
 726                 errno = err_win_to_posix(GetLastError());
 727                 return -1;
 728         }
 729         filedes[0] = _open_osfhandle((int)h[0], O_NOINHERIT);
 730         if (filedes[0] < 0) {
 731                 CloseHandle(h[0]);
 732                 CloseHandle(h[1]);
 733                 return -1;
 734         }
 735         filedes[1] = _open_osfhandle((int)h[1], O_NOINHERIT);
 736         if (filedes[0] < 0) {
 737                 close(filedes[0]);
 738                 CloseHandle(h[1]);
 739                 return -1;
 740         }
 741         return 0;
 742 }
 743
 744 struct tm *gmtime_r(const time_t *timep, struct tm *result)
 745 {
 746         /* gmtime() in MSVCRT.DLL is thread-safe, but not reentrant */
 747         memcpy(result, gmtime(timep), sizeof(struct tm));
 748         return result;
 749 }
 750
 751 struct tm *localtime_r(const time_t *timep, struct tm *result)
 752 {
 753         /* localtime() in MSVCRT.DLL is thread-safe, but not reentrant */
 754         memcpy(result, localtime(timep), sizeof(struct tm));
 755         return result;
 756 }
 757
 758 char *mingw_getcwd(char *pointer, int len)
 759 {
 760         int i;
 761         wchar_t wpointer[MAX_PATH];
 762         if (!_wgetcwd(wpointer, ARRAY_SIZE(wpointer)))
 763                 return NULL;
 764         if (xwcstoutf(pointer, wpointer, len) < 0)
 765                 return NULL;
 766         for (i = 0; pointer[i]; i++)
 767                 if (pointer[i] == '\\')
 768                         pointer[i] = '/';
 769         return pointer;
 770 }
 771
 772 /*
 773  * See http://msdn2.microsoft.com/en-us/library/17w5ykft(vs.71).aspx
 774  * (Parsing C++ Command-Line Arguments)
 775  */
 776 static const char *quote_arg(const char *arg)
 777 {
 778         /* count chars to quote */
 779         int len = 0, n = 0;
 780         int force_quotes = 0;
 781         char *q, *d;
 782         const char *p = arg;
 783         if (!*p) force_quotes = 1;
 784         while (*p) {
 785                 if (isspace(*p) || *p == '*' || *p == '?' || *p == '{' || *p == '\'')
 786                         force_quotes = 1;
 787                 else if (*p == '"')
 788                         n++;
 789                 else if (*p == '\\') {
 790                         int count = 0;
 791                         while (*p == '\\') {
 792                                 count++;
 793                                 p++;
 794                                 len++;
 795                         }
 796                         if (*p == '"')
 797                                 n += count*2 + 1;
 798                         continue;
 799                 }
 800                 len++;
 801                 p++;
 802         }
 803         if (!force_quotes && n == 0)
 804                 return arg;
 805
 806         /* insert \ where necessary */
 807         d = q = xmalloc(len+n+3);
 808         *d++ = '"';
 809         while (*arg) {
 810                 if (*arg == '"')
 811                         *d++ = '\\';
 812                 else if (*arg == '\\') {
 813                         int count = 0;
 814                         while (*arg == '\\') {
 815                                 count++;
 816                                 *d++ = *arg++;
 817                         }
 818                         if (*arg == '"') {
 819                                 while (count-- > 0)
 820                                         *d++ = '\\';
 821                                 *d++ = '\\';
 822                         }
 823                 }
 824                 *d++ = *arg++;
 825         }
 826         *d++ = '"';
 827         *d++ = 0;
 828         return q;
 829 }
 830
 831 static const char *parse_interpreter(const char *cmd)
 832 {
 833         static char buf[100];
 834         char *p, *opt;
 835         int n, fd;
 836
 837         /* don't even try a .exe */
 838         n = strlen(cmd);
 839         if (n >= 4 && !strcasecmp(cmd+n-4, ".exe"))
 840                 return NULL;
 841
 842         fd = open(cmd, O_RDONLY);
 843         if (fd < 0)
 844                 return NULL;
 845         n = read(fd, buf, sizeof(buf)-1);
 846         close(fd);
 847         if (n < 4)      /* at least '#!/x' and not error */
 848                 return NULL;
 849
 850         if (buf[0] != '#' || buf[1] != '!')
 851                 return NULL;
 852         buf[n] = '\0';
 853         p = buf + strcspn(buf, "\r\n");
 854         if (!*p)
 855                 return NULL;
 856
 857         *p = '\0';
 858         if (!(p = strrchr(buf+2, '/')) && !(p = strrchr(buf+2, '\\')))
 859                 return NULL;
 860         /* strip options */
 861         if ((opt = strchr(p+1, ' ')))
 862                 *opt = '\0';
 863         return p+1;
 864 }
 865
 866 /*
 867  * Splits the PATH into parts.
 868  */
 869 static char **get_path_split(void)
 870 {
 871         char *p, **path, *envpath = mingw_getenv("PATH");
 872         int i, n = 0;
 873
 874         if (!envpath || !*envpath)
 875                 return NULL;
 876
 877         envpath = xstrdup(envpath);
 878         p = envpath;
 879         while (p) {
 880                 char *dir = p;
 881                 p = strchr(p, ';');
 882                 if (p) *p++ = '\0';
 883                 if (*dir) {     /* not earlier, catches series of ; */
 884                         ++n;
 885                 }
 886         }
 887         if (!n)
 888                 return NULL;
 889
 890         path = xmalloc((n+1)*sizeof(char *));
 891         p = envpath;
 892         i = 0;
 893         do {
 894                 if (*p)
 895                         path[i++] = xstrdup(p);
 896                 p = p+strlen(p)+1;
 897         } while (i < n);
 898         path[i] = NULL;
 899
 900         free(envpath);
 901
 902         return path;
 903 }
 904
 905 static void free_path_split(char **path)
 906 {
 907         char **p = path;
 908
 909         if (!path)
 910                 return;
 911
 912         while (*p)
 913                 free(*p++);
 914         free(path);
 915 }
 916
 917 /*
 918  * exe_only means that we only want to detect .exe files, but not scripts
 919  * (which do not have an extension)
 920  */
 921 static char *lookup_prog(const char *dir, const char *cmd, int isexe, int exe_only)
 922 {
 923         char path[MAX_PATH];
 924         snprintf(path, sizeof(path), "%s/%s.exe", dir, cmd);
 925
 926         if (!isexe && access(path, F_OK) == 0)
 927                 return xstrdup(path);
 928         path[strlen(path)-4] = '\0';
 929         if ((!exe_only || isexe) && access(path, F_OK) == 0)
 930                 if (!(GetFileAttributes(path) & FILE_ATTRIBUTE_DIRECTORY))
 931                         return xstrdup(path);
 932         return NULL;
 933 }
 934
 935 /*
 936  * Determines the absolute path of cmd using the split path in path.
 937  * If cmd contains a slash or backslash, no lookup is performed.
 938  */
 939 static char *path_lookup(const char *cmd, char **path, int exe_only)
 940 {
 941         char *prog = NULL;
 942         int len = strlen(cmd);
 943         int isexe = len >= 4 && !strcasecmp(cmd+len-4, ".exe");
 944
 945         if (strchr(cmd, '/') || strchr(cmd, '\\'))
 946                 prog = xstrdup(cmd);
 947
 948         while (!prog && *path)
 949                 prog = lookup_prog(*path++, cmd, isexe, exe_only);
 950
 951         return prog;
 952 }
 953
 954 static int do_putenv(char **env, const char *name, int size, int free_old);
 955
 956 /* used number of elements of environ array, including terminating NULL */
 957 static int environ_size = 0;
 958 /* allocated size of environ array, in bytes */
 959 static int environ_alloc = 0;
 960
 961 /*
 962  * Create environment block suitable for CreateProcess. Merges current
 963  * process environment and the supplied environment changes.
 964  */
 965 static wchar_t *make_environment_block(char **deltaenv)
 966 {
 967         wchar_t *wenvblk = NULL;
 968         char **tmpenv;
 969         int i = 0, size = environ_size, wenvsz = 0, wenvpos = 0;
 970
 971         while (deltaenv && deltaenv[i])
 972                 i++;
 973
 974         /* copy the environment, leaving space for changes */
 975         tmpenv = xmalloc((size + i) * sizeof(char*));
 976         memcpy(tmpenv, environ, size * sizeof(char*));
 977
 978         /* merge supplied environment changes into the temporary environment */
 979         for (i = 0; deltaenv && deltaenv[i]; i++)
 980                 size = do_putenv(tmpenv, deltaenv[i], size, 0);
 981
 982         /* create environment block from temporary environment */
 983         for (i = 0; tmpenv[i]; i++) {
 984                 size = 2 * strlen(tmpenv[i]) + 2; /* +2 for final \0 */
 985                 ALLOC_GROW(wenvblk, (wenvpos + size) * sizeof(wchar_t), wenvsz);
 986                 wenvpos += xutftowcs(&wenvblk[wenvpos], tmpenv[i], size) + 1;
 987         }
 988         /* add final \0 terminator */
 989         wenvblk[wenvpos] = 0;
 990         free(tmpenv);
 991         return wenvblk;
 992 }
 993
 994 struct pinfo_t {
 995         struct pinfo_t *next;
 996         pid_t pid;
 997         HANDLE proc;
 998 };
 999 static struct pinfo_t *pinfo = NULL;
1000 CRITICAL_SECTION pinfo_cs;
1001
1002 static pid_t mingw_spawnve_fd(const char *cmd, const char **argv, char **deltaenv,
1003                               const char *dir,
1004                               int prepend_cmd, int fhin, int fhout, int fherr)
1005 {
1006         STARTUPINFOW si;
1007         PROCESS_INFORMATION pi;
1008         struct strbuf args;
1009         wchar_t wcmd[MAX_PATH], wdir[MAX_PATH], *wargs, *wenvblk = NULL;
1010         unsigned flags = CREATE_UNICODE_ENVIRONMENT;
1011         BOOL ret;
1012
1013         /* Determine whether or not we are associated to a console */
1014         HANDLE cons = CreateFile("CONOUT$", GENERIC_WRITE,
1015                         FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
1016                         FILE_ATTRIBUTE_NORMAL, NULL);
1017         if (cons == INVALID_HANDLE_VALUE) {
1018                 /* There is no console associated with this process.
1019                  * Since the child is a console process, Windows
1020                  * would normally create a console window. But
1021                  * since we'll be redirecting std streams, we do
1022                  * not need the console.
1023                  * It is necessary to use DETACHED_PROCESS
1024                  * instead of CREATE_NO_WINDOW to make ssh
1025                  * recognize that it has no console.
1026                  */
1027                 flags |= DETACHED_PROCESS;
1028         } else {
1029                 /* There is already a console. If we specified
1030                  * DETACHED_PROCESS here, too, Windows would
1031                  * disassociate the child from the console.
1032                  * The same is true for CREATE_NO_WINDOW.
1033                  * Go figure!
1034                  */
1035                 CloseHandle(cons);
1036         }
1037         memset(&si, 0, sizeof(si));
1038         si.cb = sizeof(si);
1039         si.dwFlags = STARTF_USESTDHANDLES;
1040         si.hStdInput = winansi_get_osfhandle(fhin);
1041         si.hStdOutput = winansi_get_osfhandle(fhout);
1042         si.hStdError = winansi_get_osfhandle(fherr);
1043
1044         /* executables and the current directory don't support long paths */
1045         if (xutftowcs_path(wcmd, cmd) < 0)
1046                 return -1;
1047         if (dir && xutftowcs_path(wdir, dir) < 0)
1048                 return -1;
1049
1050         /* concatenate argv, quoting args as we go */
1051         strbuf_init(&args, 0);
1052         if (prepend_cmd) {
1053                 char *quoted = (char *)quote_arg(cmd);
1054                 strbuf_addstr(&args, quoted);
1055                 if (quoted != cmd)
1056                         free(quoted);
1057         }
1058         for (; *argv; argv++) {
1059                 char *quoted = (char *)quote_arg(*argv);
1060                 if (*args.buf)
1061                         strbuf_addch(&args, ' ');
1062                 strbuf_addstr(&args, quoted);
1063                 if (quoted != *argv)
1064                         free(quoted);
1065         }
1066
1067         wargs = xmalloc((2 * args.len + 1) * sizeof(wchar_t));
1068         xutftowcs(wargs, args.buf, 2 * args.len + 1);
1069         strbuf_release(&args);
1070
1071         wenvblk = make_environment_block(deltaenv);
1072
1073         memset(&pi, 0, sizeof(pi));
1074         ret = CreateProcessW(wcmd, wargs, NULL, NULL, TRUE, flags,
1075                 wenvblk, dir ? wdir : NULL, &si, &pi);
1076
1077         free(wenvblk);
1078         free(wargs);
1079
1080         if (!ret) {
1081                 errno = ENOENT;
1082                 return -1;
1083         }
1084         CloseHandle(pi.hThread);
1085
1086         /*
1087          * The process ID is the human-readable identifier of the process
1088          * that we want to present in log and error messages. The handle
1089          * is not useful for this purpose. But we cannot close it, either,
1090          * because it is not possible to turn a process ID into a process
1091          * handle after the process terminated.
1092          * Keep the handle in a list for waitpid.
1093          */
1094         EnterCriticalSection(&pinfo_cs);
1095         {
1096                 struct pinfo_t *info = xmalloc(sizeof(struct pinfo_t));
1097                 info->pid = pi.dwProcessId;
1098                 info->proc = pi.hProcess;
1099                 info->next = pinfo;
1100                 pinfo = info;
1101         }
1102         LeaveCriticalSection(&pinfo_cs);
1103
1104         return (pid_t)pi.dwProcessId;
1105 }
1106
1107 static pid_t mingw_spawnv(const char *cmd, const char **argv, int prepend_cmd)
1108 {
1109         return mingw_spawnve_fd(cmd, argv, NULL, NULL, prepend_cmd, 0, 1, 2);
1110 }
1111
1112 pid_t mingw_spawnvpe(const char *cmd, const char **argv, char **deltaenv,
1113                      const char *dir,
1114                      int fhin, int fhout, int fherr)
1115 {
1116         pid_t pid;
1117         char **path = get_path_split();
1118         char *prog = path_lookup(cmd, path, 0);
1119
1120         if (!prog) {
1121                 errno = ENOENT;
1122                 pid = -1;
1123         }
1124         else {
1125                 const char *interpr = parse_interpreter(prog);
1126
1127                 if (interpr) {
1128                         const char *argv0 = argv[0];
1129                         char *iprog = path_lookup(interpr, path, 1);
1130                         argv[0] = prog;
1131                         if (!iprog) {
1132                                 errno = ENOENT;
1133                                 pid = -1;
1134                         }
1135                         else {
1136                                 pid = mingw_spawnve_fd(iprog, argv, deltaenv, dir, 1,
1137                                                        fhin, fhout, fherr);
1138                                 free(iprog);
1139                         }
1140                         argv[0] = argv0;
1141                 }
1142                 else
1143                         pid = mingw_spawnve_fd(prog, argv, deltaenv, dir, 0,
1144                                                fhin, fhout, fherr);
1145                 free(prog);
1146         }
1147         free_path_split(path);
1148         return pid;
1149 }
1150
1151 static int try_shell_exec(const char *cmd, char *const *argv)
1152 {
1153         const char *interpr = parse_interpreter(cmd);
1154         char **path;
1155         char *prog;
1156         int pid = 0;
1157
1158         if (!interpr)
1159                 return 0;
1160         path = get_path_split();
1161         prog = path_lookup(interpr, path, 1);
1162         if (prog) {
1163                 int argc = 0;
1164                 const char **argv2;
1165                 while (argv[argc]) argc++;
1166                 argv2 = xmalloc(sizeof(*argv) * (argc+1));
1167                 argv2[0] = (char *)cmd; /* full path to the script file */
1168                 memcpy(&argv2[1], &argv[1], sizeof(*argv) * argc);
1169                 pid = mingw_spawnv(prog, argv2, 1);
1170                 if (pid >= 0) {
1171                         int status;
1172                         if (waitpid(pid, &status, 0) < 0)
1173                                 status = 255;
1174                         exit(status);
1175                 }
1176                 pid = 1;        /* indicate that we tried but failed */
1177                 free(prog);
1178                 free(argv2);
1179         }
1180         free_path_split(path);
1181         return pid;
1182 }
1183
1184 int mingw_execv(const char *cmd, char *const *argv)
1185 {
1186         /* check if git_command is a shell script */
1187         if (!try_shell_exec(cmd, argv)) {
1188                 int pid, status;
1189
1190                 pid = mingw_spawnv(cmd, (const char **)argv, 0);
1191                 if (pid < 0)
1192                         return -1;
1193                 if (waitpid(pid, &status, 0) < 0)
1194                         status = 255;
1195                 exit(status);
1196         }
1197         return -1;
1198 }
1199
1200 int mingw_execvp(const char *cmd, char *const *argv)
1201 {
1202         char **path = get_path_split();
1203         char *prog = path_lookup(cmd, path, 0);
1204
1205         if (prog) {
1206                 mingw_execv(prog, argv);
1207                 free(prog);
1208         } else
1209                 errno = ENOENT;
1210
1211         free_path_split(path);
1212         return -1;
1213 }
1214
1215 int mingw_kill(pid_t pid, int sig)
1216 {
1217         if (pid > 0 && sig == SIGTERM) {
1218                 HANDLE h = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
1219
1220                 if (TerminateProcess(h, -1)) {
1221                         CloseHandle(h);
1222                         return 0;
1223                 }
1224
1225                 errno = err_win_to_posix(GetLastError());
1226                 CloseHandle(h);
1227                 return -1;
1228         } else if (pid > 0 && sig == 0) {
1229                 HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
1230                 if (h) {
1231                         CloseHandle(h);
1232                         return 0;
1233                 }
1234         }
1235
1236         errno = EINVAL;
1237         return -1;
1238 }
1239
1240 /*
1241  * Compare environment entries by key (i.e. stopping at '=' or '\0').
1242  */
1243 static int compareenv(const void *v1, const void *v2)
1244 {
1245         const char *e1 = *(const char**)v1;
1246         const char *e2 = *(const char**)v2;
1247
1248         for (;;) {
1249                 int c1 = *e1++;
1250                 int c2 = *e2++;
1251                 c1 = (c1 == '=') ? 0 : tolower(c1);
1252                 c2 = (c2 == '=') ? 0 : tolower(c2);
1253                 if (c1 > c2)
1254                         return 1;
1255                 if (c1 < c2)
1256                         return -1;
1257                 if (c1 == 0)
1258                         return 0;
1259         }
1260 }
1261
1262 static int bsearchenv(char **env, const char *name, size_t size)
1263 {
1264         unsigned low = 0, high = size;
1265         while (low < high) {
1266                 unsigned mid = low + ((high - low) >> 1);
1267                 int cmp = compareenv(&env[mid], &name);
1268                 if (cmp < 0)
1269                         low = mid + 1;
1270                 else if (cmp > 0)
1271                         high = mid;
1272                 else
1273                         return mid;
1274         }
1275         return ~low; /* not found, return 1's complement of insert position */
1276 }
1277
1278 /*
1279  * If name contains '=', then sets the variable, otherwise it unsets it
1280  * Size includes the terminating NULL. Env must have room for size + 1 entries
1281  * (in case of insert). Returns the new size. Optionally frees removed entries.
1282  */
1283 static int do_putenv(char **env, const char *name, int size, int free_old)
1284 {
1285         int i = bsearchenv(env, name, size - 1);
1286
1287         /* optionally free removed / replaced entry */
1288         if (i >= 0 && free_old)
1289                 free(env[i]);
1290
1291         if (strchr(name, '=')) {
1292                 /* if new value ('key=value') is specified, insert or replace entry */
1293                 if (i < 0) {
1294                         i = ~i;
1295                         memmove(&env[i + 1], &env[i], (size - i) * sizeof(char*));
1296                         size++;
1297                 }
1298                 env[i] = (char*) name;
1299         } else if (i >= 0) {
1300                 /* otherwise ('key') remove existing entry */
1301                 size--;
1302                 memmove(&env[i], &env[i + 1], (size - i) * sizeof(char*));
1303         }
1304         return size;
1305 }
1306
1307 char *mingw_getenv(const char *name)
1308 {
1309         char *value;
1310         int pos = bsearchenv(environ, name, environ_size - 1);
1311         if (pos < 0)
1312                 return NULL;
1313         value = strchr(environ[pos], '=');
1314         return value ? &value[1] : NULL;
1315 }
1316
1317 int mingw_putenv(const char *namevalue)
1318 {
1319         ALLOC_GROW(environ, (environ_size + 1) * sizeof(char*), environ_alloc);
1320         environ_size = do_putenv(environ, namevalue, environ_size, 1);
1321         return 0;
1322 }
1323
1324 /*
1325  * Note, this isn't a complete replacement for getaddrinfo. It assumes
1326  * that service contains a numerical port, or that it is null. It
1327  * does a simple search using gethostbyname, and returns one IPv4 host
1328  * if one was found.
1329  */
1330 static int WSAAPI getaddrinfo_stub(const char *node, const char *service,
1331                                    const struct addrinfo *hints,
1332                                    struct addrinfo **res)
1333 {
1334         struct hostent *h = NULL;
1335         struct addrinfo *ai;
1336         struct sockaddr_in *sin;
1337
1338         if (node) {
1339                 h = gethostbyname(node);
1340                 if (!h)
1341                         return WSAGetLastError();
1342         }
1343
1344         ai = xmalloc(sizeof(struct addrinfo));
1345         *res = ai;
1346         ai->ai_flags = 0;
1347         ai->ai_family = AF_INET;
1348         ai->ai_socktype = hints ? hints->ai_socktype : 0;
1349         switch (ai->ai_socktype) {
1350         case SOCK_STREAM:
1351                 ai->ai_protocol = IPPROTO_TCP;
1352                 break;
1353         case SOCK_DGRAM:
1354                 ai->ai_protocol = IPPROTO_UDP;
1355                 break;
1356         default:
1357                 ai->ai_protocol = 0;
1358                 break;
1359         }
1360         ai->ai_addrlen = sizeof(struct sockaddr_in);
1361         if (hints && (hints->ai_flags & AI_CANONNAME))
1362                 ai->ai_canonname = h ? xstrdup(h->h_name) : NULL;
1363         else
1364                 ai->ai_canonname = NULL;
1365
1366         sin = xcalloc(1, ai->ai_addrlen);
1367         sin->sin_family = AF_INET;
1368         /* Note: getaddrinfo is supposed to allow service to be a string,
1369          * which should be looked up using getservbyname. This is
1370          * currently not implemented */
1371         if (service)
1372                 sin->sin_port = htons(atoi(service));
1373         if (h)
1374                 sin->sin_addr = *(struct in_addr *)h->h_addr;
1375         else if (hints && (hints->ai_flags & AI_PASSIVE))
1376                 sin->sin_addr.s_addr = INADDR_ANY;
1377         else
1378                 sin->sin_addr.s_addr = INADDR_LOOPBACK;
1379         ai->ai_addr = (struct sockaddr *)sin;
1380         ai->ai_next = NULL;
1381         return 0;
1382 }
1383
1384 static void WSAAPI freeaddrinfo_stub(struct addrinfo *res)
1385 {
1386         free(res->ai_canonname);
1387         free(res->ai_addr);
1388         free(res);
1389 }
1390
1391 static int WSAAPI getnameinfo_stub(const struct sockaddr *sa, socklen_t salen,
1392                                    char *host, DWORD hostlen,
1393                                    char *serv, DWORD servlen, int flags)
1394 {
1395         const struct sockaddr_in *sin = (const struct sockaddr_in *)sa;
1396         if (sa->sa_family != AF_INET)
1397                 return EAI_FAMILY;
1398         if (!host && !serv)
1399                 return EAI_NONAME;
1400
1401         if (host && hostlen > 0) {
1402                 struct hostent *ent = NULL;
1403                 if (!(flags & NI_NUMERICHOST))
1404                         ent = gethostbyaddr((const char *)&sin->sin_addr,
1405                                             sizeof(sin->sin_addr), AF_INET);
1406
1407                 if (ent)
1408                         snprintf(host, hostlen, "%s", ent->h_name);
1409                 else if (flags & NI_NAMEREQD)
1410                         return EAI_NONAME;
1411                 else
1412                         snprintf(host, hostlen, "%s", inet_ntoa(sin->sin_addr));
1413         }
1414
1415         if (serv && servlen > 0) {
1416                 struct servent *ent = NULL;
1417                 if (!(flags & NI_NUMERICSERV))
1418                         ent = getservbyport(sin->sin_port,
1419                                             flags & NI_DGRAM ? "udp" : "tcp");
1420
1421                 if (ent)
1422                         snprintf(serv, servlen, "%s", ent->s_name);
1423                 else
1424                         snprintf(serv, servlen, "%d", ntohs(sin->sin_port));
1425         }
1426
1427         return 0;
1428 }
1429
1430 static HMODULE ipv6_dll = NULL;
1431 static void (WSAAPI *ipv6_freeaddrinfo)(struct addrinfo *res);
1432 static int (WSAAPI *ipv6_getaddrinfo)(const char *node, const char *service,
1433                                       const struct addrinfo *hints,
1434                                       struct addrinfo **res);
1435 static int (WSAAPI *ipv6_getnameinfo)(const struct sockaddr *sa, socklen_t salen,
1436                                       char *host, DWORD hostlen,
1437                                       char *serv, DWORD servlen, int flags);
1438 /*
1439  * gai_strerror is an inline function in the ws2tcpip.h header, so we
1440  * don't need to try to load that one dynamically.
1441  */
1442
1443 static void socket_cleanup(void)
1444 {
1445         WSACleanup();
1446         if (ipv6_dll)
1447                 FreeLibrary(ipv6_dll);
1448         ipv6_dll = NULL;
1449         ipv6_freeaddrinfo = freeaddrinfo_stub;
1450         ipv6_getaddrinfo = getaddrinfo_stub;
1451         ipv6_getnameinfo = getnameinfo_stub;
1452 }
1453
1454 static void ensure_socket_initialization(void)
1455 {
1456         WSADATA wsa;
1457         static int initialized = 0;
1458         const char *libraries[] = { "ws2_32.dll", "wship6.dll", NULL };
1459         const char **name;
1460
1461         if (initialized)
1462                 return;
1463
1464         if (WSAStartup(MAKEWORD(2,2), &wsa))
1465                 die("unable to initialize winsock subsystem, error %d",
1466                         WSAGetLastError());
1467
1468         for (name = libraries; *name; name++) {
1469                 ipv6_dll = LoadLibrary(*name);
1470                 if (!ipv6_dll)
1471                         continue;
1472
1473                 ipv6_freeaddrinfo = (void (WSAAPI *)(struct addrinfo *))
1474                         GetProcAddress(ipv6_dll, "freeaddrinfo");
1475                 ipv6_getaddrinfo = (int (WSAAPI *)(const char *, const char *,
1476                                                    const struct addrinfo *,
1477                                                    struct addrinfo **))
1478                         GetProcAddress(ipv6_dll, "getaddrinfo");
1479                 ipv6_getnameinfo = (int (WSAAPI *)(const struct sockaddr *,
1480                                                    socklen_t, char *, DWORD,
1481                                                    char *, DWORD, int))
1482                         GetProcAddress(ipv6_dll, "getnameinfo");
1483                 if (!ipv6_freeaddrinfo || !ipv6_getaddrinfo || !ipv6_getnameinfo) {
1484                         FreeLibrary(ipv6_dll);
1485                         ipv6_dll = NULL;
1486                 } else
1487                         break;
1488         }
1489         if (!ipv6_freeaddrinfo || !ipv6_getaddrinfo || !ipv6_getnameinfo) {
1490                 ipv6_freeaddrinfo = freeaddrinfo_stub;
1491                 ipv6_getaddrinfo = getaddrinfo_stub;
1492                 ipv6_getnameinfo = getnameinfo_stub;
1493         }
1494
1495         atexit(socket_cleanup);
1496         initialized = 1;
1497 }
1498
1499 #undef gethostname
1500 int mingw_gethostname(char *name, int namelen)
1501 {
1502     ensure_socket_initialization();
1503     return gethostname(name, namelen);
1504 }
1505
1506 #undef gethostbyname
1507 struct hostent *mingw_gethostbyname(const char *host)
1508 {
1509         ensure_socket_initialization();
1510         return gethostbyname(host);
1511 }
1512
1513 void mingw_freeaddrinfo(struct addrinfo *res)
1514 {
1515         ipv6_freeaddrinfo(res);
1516 }
1517
1518 int mingw_getaddrinfo(const char *node, const char *service,
1519                       const struct addrinfo *hints, struct addrinfo **res)
1520 {
1521         ensure_socket_initialization();
1522         return ipv6_getaddrinfo(node, service, hints, res);
1523 }
1524
1525 int mingw_getnameinfo(const struct sockaddr *sa, socklen_t salen,
1526                       char *host, DWORD hostlen, char *serv, DWORD servlen,
1527                       int flags)
1528 {
1529         ensure_socket_initialization();
1530         return ipv6_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
1531 }
1532
1533 int mingw_socket(int domain, int type, int protocol)
1534 {
1535         int sockfd;
1536         SOCKET s;
1537
1538         ensure_socket_initialization();
1539         s = WSASocket(domain, type, protocol, NULL, 0, 0);
1540         if (s == INVALID_SOCKET) {
1541                 /*
1542                  * WSAGetLastError() values are regular BSD error codes
1543                  * biased by WSABASEERR.
1544                  * However, strerror() does not know about networking
1545                  * specific errors, which are values beginning at 38 or so.
1546                  * Therefore, we choose to leave the biased error code
1547                  * in errno so that _if_ someone looks up the code somewhere,
1548                  * then it is at least the number that are usually listed.
1549                  */
1550                 errno = WSAGetLastError();
1551                 return -1;
1552         }
1553         /* convert into a file descriptor */
1554         if ((sockfd = _open_osfhandle(s, O_RDWR|O_BINARY)) < 0) {
1555                 closesocket(s);
1556                 return error("unable to make a socket file descriptor: %s",
1557                         strerror(errno));
1558         }
1559         return sockfd;
1560 }
1561
1562 #undef connect
1563 int mingw_connect(int sockfd, struct sockaddr *sa, size_t sz)
1564 {
1565         SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1566         return connect(s, sa, sz);
1567 }
1568
1569 #undef bind
1570 int mingw_bind(int sockfd, struct sockaddr *sa, size_t sz)
1571 {
1572         SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1573         return bind(s, sa, sz);
1574 }
1575
1576 #undef setsockopt
1577 int mingw_setsockopt(int sockfd, int lvl, int optname, void *optval, int optlen)
1578 {
1579         SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1580         return setsockopt(s, lvl, optname, (const char*)optval, optlen);
1581 }
1582
1583 #undef shutdown
1584 int mingw_shutdown(int sockfd, int how)
1585 {
1586         SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1587         return shutdown(s, how);
1588 }
1589
1590 #undef listen
1591 int mingw_listen(int sockfd, int backlog)
1592 {
1593         SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1594         return listen(s, backlog);
1595 }
1596
1597 #undef accept
1598 int mingw_accept(int sockfd1, struct sockaddr *sa, socklen_t *sz)
1599 {
1600         int sockfd2;
1601
1602         SOCKET s1 = (SOCKET)_get_osfhandle(sockfd1);
1603         SOCKET s2 = accept(s1, sa, sz);
1604
1605         /* convert into a file descriptor */
1606         if ((sockfd2 = _open_osfhandle(s2, O_RDWR|O_BINARY)) < 0) {
1607                 int err = errno;
1608                 closesocket(s2);
1609                 return error("unable to make a socket file descriptor: %s",
1610                         strerror(err));
1611         }
1612         return sockfd2;
1613 }
1614
1615 #undef rename
1616 int mingw_rename(const char *pold, const char *pnew)
1617 {
1618         DWORD attrs, gle;
1619         int tries = 0;
1620         wchar_t wpold[MAX_LONG_PATH], wpnew[MAX_LONG_PATH];
1621         if (xutftowcs_long_path(wpold, pold) < 0 ||
1622             xutftowcs_long_path(wpnew, pnew) < 0)
1623                 return -1;
1624
1625         /*
1626          * Try native rename() first to get errno right.
1627          * It is based on MoveFile(), which cannot overwrite existing files.
1628          */
1629         if (!_wrename(wpold, wpnew))
1630                 return 0;
1631         if (errno != EEXIST)
1632                 return -1;
1633 repeat:
1634         if (MoveFileExW(wpold, wpnew, MOVEFILE_REPLACE_EXISTING))
1635                 return 0;
1636         /* TODO: translate more errors */
1637         gle = GetLastError();
1638         if (gle == ERROR_ACCESS_DENIED &&
1639             (attrs = GetFileAttributesW(wpnew)) != INVALID_FILE_ATTRIBUTES) {
1640                 if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
1641                         errno = EISDIR;
1642                         return -1;
1643                 }
1644                 if ((attrs & FILE_ATTRIBUTE_READONLY) &&
1645                     SetFileAttributesW(wpnew, attrs & ~FILE_ATTRIBUTE_READONLY)) {
1646                         if (MoveFileExW(wpold, wpnew, MOVEFILE_REPLACE_EXISTING))
1647                                 return 0;
1648                         gle = GetLastError();
1649                         /* revert file attributes on failure */
1650                         SetFileAttributesW(wpnew, attrs);
1651                 }
1652         }
1653         if (tries < ARRAY_SIZE(delay) && gle == ERROR_ACCESS_DENIED) {
1654                 /*
1655                  * We assume that some other process had the source or
1656                  * destination file open at the wrong moment and retry.
1657                  * In order to give the other process a higher chance to
1658                  * complete its operation, we give up our time slice now.
1659                  * If we have to retry again, we do sleep a bit.
1660                  */
1661                 Sleep(delay[tries]);
1662                 tries++;
1663                 goto repeat;
1664         }
1665         if (gle == ERROR_ACCESS_DENIED &&
1666                ask_yes_no_if_possible("Rename from '%s' to '%s' failed. "
1667                        "Should I try again?", pold, pnew))
1668                 goto repeat;
1669
1670         errno = EACCES;
1671         return -1;
1672 }
1673
1674 /*
1675  * Note that this doesn't return the actual pagesize, but
1676  * the allocation granularity. If future Windows specific git code
1677  * needs the real getpagesize function, we need to find another solution.
1678  */
1679 int mingw_getpagesize(void)
1680 {
1681         SYSTEM_INFO si;
1682         GetSystemInfo(&si);
1683         return si.dwAllocationGranularity;
1684 }
1685
1686 struct passwd *getpwuid(int uid)
1687 {
1688         static char user_name[100];
1689         static struct passwd p;
1690
1691         DWORD len = sizeof(user_name);
1692         if (!GetUserName(user_name, &len))
1693                 return NULL;
1694         p.pw_name = user_name;
1695         p.pw_gecos = "unknown";
1696         p.pw_dir = NULL;
1697         return &p;
1698 }
1699
1700 static HANDLE timer_event;
1701 static HANDLE timer_thread;
1702 static int timer_interval;
1703 static int one_shot;
1704 static sig_handler_t timer_fn = SIG_DFL, sigint_fn = SIG_DFL;
1705
1706 /* The timer works like this:
1707  * The thread, ticktack(), is a trivial routine that most of the time
1708  * only waits to receive the signal to terminate. The main thread tells
1709  * the thread to terminate by setting the timer_event to the signalled
1710  * state.
1711  * But ticktack() interrupts the wait state after the timer's interval
1712  * length to call the signal handler.
1713  */
1714
1715 static unsigned __stdcall ticktack(void *dummy)
1716 {
1717         while (WaitForSingleObject(timer_event, timer_interval) == WAIT_TIMEOUT) {
1718                 mingw_raise(SIGALRM);
1719                 if (one_shot)
1720                         break;
1721         }
1722         return 0;
1723 }
1724
1725 static int start_timer_thread(void)
1726 {
1727         timer_event = CreateEvent(NULL, FALSE, FALSE, NULL);
1728         if (timer_event) {
1729                 timer_thread = (HANDLE) _beginthreadex(NULL, 0, ticktack, NULL, 0, NULL);
1730                 if (!timer_thread )
1731                         return errno = ENOMEM,
1732                                 error("cannot start timer thread");
1733         } else
1734                 return errno = ENOMEM,
1735                         error("cannot allocate resources for timer");
1736         return 0;
1737 }
1738
1739 static void stop_timer_thread(void)
1740 {
1741         if (timer_event)
1742                 SetEvent(timer_event);  /* tell thread to terminate */
1743         if (timer_thread) {
1744                 int rc = WaitForSingleObject(timer_thread, 1000);
1745                 if (rc == WAIT_TIMEOUT)
1746                         error("timer thread did not terminate timely");
1747                 else if (rc != WAIT_OBJECT_0)
1748                         error("waiting for timer thread failed: %lu",
1749                               GetLastError());
1750                 CloseHandle(timer_thread);
1751         }
1752         if (timer_event)
1753                 CloseHandle(timer_event);
1754         timer_event = NULL;
1755         timer_thread = NULL;
1756 }
1757
1758 static inline int is_timeval_eq(const struct timeval *i1, const struct timeval *i2)
1759 {
1760         return i1->tv_sec == i2->tv_sec && i1->tv_usec == i2->tv_usec;
1761 }
1762
1763 int setitimer(int type, struct itimerval *in, struct itimerval *out)
1764 {
1765         static const struct timeval zero;
1766         static int atexit_done;
1767
1768         if (out != NULL)
1769                 return errno = EINVAL,
1770                         error("setitimer param 3 != NULL not implemented");
1771         if (!is_timeval_eq(&in->it_interval, &zero) &&
1772             !is_timeval_eq(&in->it_interval, &in->it_value))
1773                 return errno = EINVAL,
1774                         error("setitimer: it_interval must be zero or eq it_value");
1775
1776         if (timer_thread)
1777                 stop_timer_thread();
1778
1779         if (is_timeval_eq(&in->it_value, &zero) &&
1780             is_timeval_eq(&in->it_interval, &zero))
1781                 return 0;
1782
1783         timer_interval = in->it_value.tv_sec * 1000 + in->it_value.tv_usec / 1000;
1784         one_shot = is_timeval_eq(&in->it_interval, &zero);
1785         if (!atexit_done) {
1786                 atexit(stop_timer_thread);
1787                 atexit_done = 1;
1788         }
1789         return start_timer_thread();
1790 }
1791
1792 int sigaction(int sig, struct sigaction *in, struct sigaction *out)
1793 {
1794         if (sig != SIGALRM)
1795                 return errno = EINVAL,
1796                         error("sigaction only implemented for SIGALRM");
1797         if (out != NULL)
1798                 return errno = EINVAL,
1799                         error("sigaction: param 3 != NULL not implemented");
1800
1801         timer_fn = in->sa_handler;
1802         return 0;
1803 }
1804
1805 #undef signal
1806 sig_handler_t mingw_signal(int sig, sig_handler_t handler)
1807 {
1808         sig_handler_t old;
1809
1810         switch (sig) {
1811         case SIGALRM:
1812                 old = timer_fn;
1813                 timer_fn = handler;
1814                 break;
1815
1816         case SIGINT:
1817                 old = sigint_fn;
1818                 sigint_fn = handler;
1819                 break;
1820
1821         default:
1822                 return signal(sig, handler);
1823         }
1824
1825         return old;
1826 }
1827
1828 #undef raise
1829 int mingw_raise(int sig)
1830 {
1831         switch (sig) {
1832         case SIGALRM:
1833                 if (timer_fn == SIG_DFL) {
1834                         if (isatty(STDERR_FILENO))
1835                                 fputs("Alarm clock\n", stderr);
1836                         exit(128 + SIGALRM);
1837                 } else if (timer_fn != SIG_IGN)
1838                         timer_fn(SIGALRM);
1839                 return 0;
1840
1841         case SIGINT:
1842                 if (sigint_fn == SIG_DFL)
1843                         exit(128 + SIGINT);
1844                 else if (sigint_fn != SIG_IGN)
1845                         sigint_fn(SIGINT);
1846                 return 0;
1847
1848         default:
1849                 return raise(sig);
1850         }
1851 }
1852
1853
1854 static const char *make_backslash_path(const char *path)
1855 {
1856         static char buf[PATH_MAX + 1];
1857         char *c;
1858
1859         if (strlcpy(buf, path, PATH_MAX) >= PATH_MAX)
1860                 die("Too long path: %.*s", 60, path);
1861
1862         for (c = buf; *c; c++) {
1863                 if (*c == '/')
1864                         *c = '\\';
1865         }
1866         return buf;
1867 }
1868
1869 void mingw_open_html(const char *unixpath)
1870 {
1871         const char *htmlpath = make_backslash_path(unixpath);
1872         typedef HINSTANCE (WINAPI *T)(HWND, const char *,
1873                         const char *, const char *, const char *, INT);
1874         T ShellExecute;
1875         HMODULE shell32;
1876         int r;
1877
1878         shell32 = LoadLibrary("shell32.dll");
1879         if (!shell32)
1880                 die("cannot load shell32.dll");
1881         ShellExecute = (T)GetProcAddress(shell32, "ShellExecuteA");
1882         if (!ShellExecute)
1883                 die("cannot run browser");
1884
1885         printf("Launching default browser to display HTML ...\n");
1886         r = (int)ShellExecute(NULL, "open", htmlpath, NULL, "\\", SW_SHOWNORMAL);
1887         FreeLibrary(shell32);
1888         /* see the MSDN documentation referring to the result codes here */
1889         if (r <= 32) {
1890                 die("failed to launch browser for %.*s", MAX_PATH, unixpath);
1891         }
1892 }
1893
1894 int link(const char *oldpath, const char *newpath)
1895 {
1896         typedef BOOL (WINAPI *T)(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);
1897         static T create_hard_link = NULL;
1898         wchar_t woldpath[MAX_LONG_PATH], wnewpath[MAX_LONG_PATH];
1899         if (xutftowcs_long_path(woldpath, oldpath) < 0 ||
1900             xutftowcs_long_path(wnewpath, newpath) < 0)
1901                 return -1;
1902
1903         if (!create_hard_link) {
1904                 create_hard_link = (T) GetProcAddress(
1905                         GetModuleHandle("kernel32.dll"), "CreateHardLinkW");
1906                 if (!create_hard_link)
1907                         create_hard_link = (T)-1;
1908         }
1909         if (create_hard_link == (T)-1) {
1910                 errno = ENOSYS;
1911                 return -1;
1912         }
1913         if (!create_hard_link(wnewpath, woldpath, NULL)) {
1914                 errno = err_win_to_posix(GetLastError());
1915                 return -1;
1916         }
1917         return 0;
1918 }
1919
1920 pid_t waitpid(pid_t pid, int *status, int options)
1921 {
1922         HANDLE h = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION,
1923             FALSE, pid);
1924         if (!h) {
1925                 errno = ECHILD;
1926                 return -1;
1927         }
1928
1929         if (pid > 0 && options & WNOHANG) {
1930                 if (WAIT_OBJECT_0 != WaitForSingleObject(h, 0)) {
1931                         CloseHandle(h);
1932                         return 0;
1933                 }
1934                 options &= ~WNOHANG;
1935         }
1936
1937         if (options == 0) {
1938                 struct pinfo_t **ppinfo;
1939                 if (WaitForSingleObject(h, INFINITE) != WAIT_OBJECT_0) {
1940                         CloseHandle(h);
1941                         return 0;
1942                 }
1943
1944                 if (status)
1945                         GetExitCodeProcess(h, (LPDWORD)status);
1946
1947                 EnterCriticalSection(&pinfo_cs);
1948
1949                 ppinfo = &pinfo;
1950                 while (*ppinfo) {
1951                         struct pinfo_t *info = *ppinfo;
1952                         if (info->pid == pid) {
1953                                 CloseHandle(info->proc);
1954                                 *ppinfo = info->next;
1955                                 free(info);
1956                                 break;
1957                         }
1958                         ppinfo = &info->next;
1959                 }
1960
1961                 LeaveCriticalSection(&pinfo_cs);
1962
1963                 CloseHandle(h);
1964                 return pid;
1965         }
1966         CloseHandle(h);
1967
1968         errno = EINVAL;
1969         return -1;
1970 }
1971
1972 int mingw_offset_1st_component(const char *path)
1973 {
1974         int offset = 0;
1975         if (has_dos_drive_prefix(path))
1976                 offset = 2;
1977
1978         /* unc paths */
1979         else if (is_dir_sep(path[0]) && is_dir_sep(path[1])) {
1980
1981                 /* skip server name */
1982                 char *pos = strpbrk(path + 2, "\\/");
1983                 if (!pos)
1984                         return 0; /* Error: malformed unc path */
1985
1986                 do {
1987                         pos++;
1988                 } while (*pos && !is_dir_sep(*pos));
1989
1990                 offset = pos - path;
1991         }
1992
1993         return offset + is_dir_sep(path[offset]);
1994 }
1995
1996 int xutftowcsn(wchar_t *wcs, const char *utfs, size_t wcslen, int utflen)
1997 {
1998         int upos = 0, wpos = 0;
1999         const unsigned char *utf = (const unsigned char*) utfs;
2000         if (!utf || !wcs || wcslen < 1) {
2001                 errno = EINVAL;
2002                 return -1;
2003         }
2004         /* reserve space for \0 */
2005         wcslen--;
2006         if (utflen < 0)
2007                 utflen = INT_MAX;
2008
2009         while (upos < utflen) {
2010                 int c = utf[upos++] & 0xff;
2011                 if (utflen == INT_MAX && c == 0)
2012                         break;
2013
2014                 if (wpos >= wcslen) {
2015                         wcs[wpos] = 0;
2016                         errno = ERANGE;
2017                         return -1;
2018                 }
2019
2020                 if (c < 0x80) {
2021                         /* ASCII */
2022                         wcs[wpos++] = c;
2023                 } else if (c >= 0xc2 && c < 0xe0 && upos < utflen &&
2024                                 (utf[upos] & 0xc0) == 0x80) {
2025                         /* 2-byte utf-8 */
2026                         c = ((c & 0x1f) << 6);
2027                         c |= (utf[upos++] & 0x3f);
2028                         wcs[wpos++] = c;
2029                 } else if (c >= 0xe0 && c < 0xf0 && upos + 1 < utflen &&
2030                                 !(c == 0xe0 && utf[upos] < 0xa0) && /* over-long encoding */
2031                                 (utf[upos] & 0xc0) == 0x80 &&
2032                                 (utf[upos + 1] & 0xc0) == 0x80) {
2033                         /* 3-byte utf-8 */
2034                         c = ((c & 0x0f) << 12);
2035                         c |= ((utf[upos++] & 0x3f) << 6);
2036                         c |= (utf[upos++] & 0x3f);
2037                         wcs[wpos++] = c;
2038                 } else if (c >= 0xf0 && c < 0xf5 && upos + 2 < utflen &&
2039                                 wpos + 1 < wcslen &&
2040                                 !(c == 0xf0 && utf[upos] < 0x90) && /* over-long encoding */
2041                                 !(c == 0xf4 && utf[upos] >= 0x90) && /* > \u10ffff */
2042                                 (utf[upos] & 0xc0) == 0x80 &&
2043                                 (utf[upos + 1] & 0xc0) == 0x80 &&
2044                                 (utf[upos + 2] & 0xc0) == 0x80) {
2045                         /* 4-byte utf-8: convert to \ud8xx \udcxx surrogate pair */
2046                         c = ((c & 0x07) << 18);
2047                         c |= ((utf[upos++] & 0x3f) << 12);
2048                         c |= ((utf[upos++] & 0x3f) << 6);
2049                         c |= (utf[upos++] & 0x3f);
2050                         c -= 0x10000;
2051                         wcs[wpos++] = 0xd800 | (c >> 10);
2052                         wcs[wpos++] = 0xdc00 | (c & 0x3ff);
2053                 } else if (c >= 0xa0) {
2054                         /* invalid utf-8 byte, printable unicode char: convert 1:1 */
2055                         wcs[wpos++] = c;
2056                 } else {
2057                         /* invalid utf-8 byte, non-printable unicode: convert to hex */
2058                         static const char *hex = "0123456789abcdef";
2059                         wcs[wpos++] = hex[c >> 4];
2060                         if (wpos < wcslen)
2061                                 wcs[wpos++] = hex[c & 0x0f];
2062                 }
2063         }
2064         wcs[wpos] = 0;
2065         return wpos;
2066 }
2067
2068 int xwcstoutf(char *utf, const wchar_t *wcs, size_t utflen)
2069 {
2070         if (!wcs || !utf || utflen < 1) {
2071                 errno = EINVAL;
2072                 return -1;
2073         }
2074         utflen = WideCharToMultiByte(CP_UTF8, 0, wcs, -1, utf, utflen, NULL, NULL);
2075         if (utflen)
2076                 return utflen - 1;
2077         errno = ERANGE;
2078         return -1;
2079 }
2080
2081 int handle_long_path(wchar_t *path, int len, int max_path, int expand)
2082 {
2083         int result;
2084         wchar_t buf[MAX_LONG_PATH];
2085
2086         /*
2087          * we don't need special handling if path is relative to the current
2088          * directory, and current directory + path don't exceed the desired
2089          * max_path limit. This should cover > 99 % of cases with minimal
2090          * performance impact (git almost always uses relative paths).
2091          */
2092         if ((len < 2 || (!is_dir_sep(path[0]) && path[1] != ':')) &&
2093             (current_directory_len + len < max_path))
2094                 return len;
2095
2096         /*
2097          * handle everything else:
2098          * - absolute paths: "C:\dir\file"
2099          * - absolute UNC paths: "\\server\share\dir\file"
2100          * - absolute paths on current drive: "\dir\file"
2101          * - relative paths on other drive: "X:file"
2102          * - prefixed paths: "\\?\...", "\\.\..."
2103          */
2104
2105         /* convert to absolute path using GetFullPathNameW */
2106         result = GetFullPathNameW(path, MAX_LONG_PATH, buf, NULL);
2107         if (!result) {
2108                 errno = err_win_to_posix(GetLastError());
2109                 return -1;
2110         }
2111
2112         /*
2113          * return absolute path if it fits within max_path (even if
2114          * "cwd + path" doesn't due to '..' components)
2115          */
2116         if (result < max_path) {
2117                 wcscpy(path, buf);
2118                 return result;
2119         }
2120
2121         /* error out if we shouldn't expand the path or buf is too small */
2122         if (!expand || result >= MAX_LONG_PATH - 6) {
2123                 errno = ENAMETOOLONG;
2124                 return -1;
2125         }
2126
2127         /* prefix full path with "\\?\" or "\\?\UNC\" */
2128         if (buf[0] == '\\') {
2129                 /* ...unless already prefixed */
2130                 if (buf[1] == '\\' && (buf[2] == '?' || buf[2] == '.'))
2131                         return len;
2132
2133                 wcscpy(path, L"\\\\?\\UNC\\");
2134                 wcscpy(path + 8, buf + 2);
2135                 return result + 6;
2136         } else {
2137                 wcscpy(path, L"\\\\?\\");
2138                 wcscpy(path + 4, buf);
2139                 return result + 4;
2140         }
2141 }
2142
2143 /*
2144  * Disable MSVCRT command line wildcard expansion (__getmainargs called from
2145  * mingw startup code, see init.c in mingw runtime).
2146  */
2147 int _CRT_glob = 0;
2148
2149 typedef struct {
2150         int newmode;
2151 } _startupinfo;
2152
2153 extern int __wgetmainargs(int *argc, wchar_t ***argv, wchar_t ***env, int glob,
2154                 _startupinfo *si);
2155
2156 static NORETURN void die_startup()
2157 {
2158         fputs("fatal: not enough memory for initialization", stderr);
2159         exit(128);
2160 }
2161
2162 static void *malloc_startup(size_t size)
2163 {
2164         void *result = malloc(size);
2165         if (!result)
2166                 die_startup();
2167         return result;
2168 }
2169
2170 static char *wcstoutfdup_startup(char *buffer, const wchar_t *wcs, size_t len)
2171 {
2172         len = xwcstoutf(buffer, wcs, len) + 1;
2173         return memcpy(malloc_startup(len), buffer, len);
2174 }
2175
2176 void mingw_startup()
2177 {
2178         int i, maxlen, argc;
2179         char *buffer;
2180         wchar_t **wenv, **wargv;
2181         _startupinfo si;
2182
2183         /* get wide char arguments and environment */
2184         si.newmode = 0;
2185         if (__wgetmainargs(&argc, &wargv, &wenv, _CRT_glob, &si) < 0)
2186                 die_startup();
2187
2188         /* determine size of argv and environ conversion buffer */
2189         maxlen = wcslen(_wpgmptr);
2190         for (i = 1; i < argc; i++)
2191                 maxlen = max(maxlen, wcslen(wargv[i]));
2192         for (i = 0; wenv[i]; i++)
2193                 maxlen = max(maxlen, wcslen(wenv[i]));
2194
2195         /*
2196          * nedmalloc can't free CRT memory, allocate resizable environment
2197          * list. Note that xmalloc / xmemdupz etc. call getenv, so we cannot
2198          * use it while initializing the environment itself.
2199          */
2200         environ_size = i + 1;
2201         environ_alloc = alloc_nr(environ_size * sizeof(char*));
2202         environ = malloc_startup(environ_alloc);
2203
2204         /* allocate buffer (wchar_t encodes to max 3 UTF-8 bytes) */
2205         maxlen = 3 * maxlen + 1;
2206         buffer = malloc_startup(maxlen);
2207
2208         /* convert command line arguments and environment to UTF-8 */
2209         __argv[0] = wcstoutfdup_startup(buffer, _wpgmptr, maxlen);
2210         for (i = 1; i < argc; i++)
2211                 __argv[i] = wcstoutfdup_startup(buffer, wargv[i], maxlen);
2212         for (i = 0; wenv[i]; i++)
2213                 environ[i] = wcstoutfdup_startup(buffer, wenv[i], maxlen);
2214         environ[i] = NULL;
2215         free(buffer);
2216
2217         /* sort environment for O(log n) getenv / putenv */
2218         qsort(environ, i, sizeof(char*), compareenv);
2219
2220         /* fix Windows specific environment settings */
2221
2222         /* on Windows it is TMP and TEMP */
2223         if (!mingw_getenv("TMPDIR")) {
2224                 const char *tmp = mingw_getenv("TMP");
2225                 if (!tmp)
2226                         tmp = mingw_getenv("TEMP");
2227                 if (tmp)
2228                         setenv("TMPDIR", tmp, 1);
2229         }
2230
2231         /* simulate TERM to enable auto-color (see color.c) */
2232         if (!getenv("TERM"))
2233                 setenv("TERM", "cygwin", 1);
2234
2235         /* initialize critical section for waitpid pinfo_t list */
2236         InitializeCriticalSection(&pinfo_cs);
2237
2238         /* set up default file mode and file modes for stdin/out/err */
2239         _fmode = _O_BINARY;
2240         _setmode(_fileno(stdin), _O_BINARY);
2241         _setmode(_fileno(stdout), _O_BINARY);
2242         _setmode(_fileno(stderr), _O_BINARY);
2243
2244         /* initialize Unicode console */
2245         winansi_init();
2246
2247         /* init length of current directory for handle_long_path */
2248         current_directory_len = GetCurrentDirectoryW(0, NULL);
2249 }