compat/mingw.c

   1 #include "../git-compat-util.h"
   2 #include "win32.h"
   3 #include <conio.h>
   4 #include "../strbuf.h"
   5 #include "../cache.h"
   6 #include "../run-command.h"
   7
   8 unsigned int _CRT_fmode = _O_BINARY;
   9 static const int delay[] = { 0, 1, 10, 20, 40 };
  10
  11 int err_win_to_posix(DWORD winerr)
  12 {
  13         int error = ENOSYS;
  14         switch(winerr) {
  15         case ERROR_ACCESS_DENIED: error = EACCES; break;
  16         case ERROR_ACCOUNT_DISABLED: error = EACCES; break;
  17         case ERROR_ACCOUNT_RESTRICTION: error = EACCES; break;
  18         case ERROR_ALREADY_ASSIGNED: error = EBUSY; break;
  19         case ERROR_ALREADY_EXISTS: error = EEXIST; break;
  20         case ERROR_ARITHMETIC_OVERFLOW: error = ERANGE; break;
  21         case ERROR_BAD_COMMAND: error = EIO; break;
  22         case ERROR_BAD_DEVICE: error = ENODEV; break;
  23         case ERROR_BAD_DRIVER_LEVEL: error = ENXIO; break;
  24         case ERROR_BAD_EXE_FORMAT: error = ENOEXEC; break;
  25         case ERROR_BAD_FORMAT: error = ENOEXEC; break;
  26         case ERROR_BAD_LENGTH: error = EINVAL; break;
  27         case ERROR_BAD_PATHNAME: error = ENOENT; break;
  28         case ERROR_BAD_PIPE: error = EPIPE; break;
  29         case ERROR_BAD_UNIT: error = ENODEV; break;
  30         case ERROR_BAD_USERNAME: error = EINVAL; break;
  31         case ERROR_BROKEN_PIPE: error = EPIPE; break;
  32         case ERROR_BUFFER_OVERFLOW: error = ENAMETOOLONG; break;
  33         case ERROR_BUSY: error = EBUSY; break;
  34         case ERROR_BUSY_DRIVE: error = EBUSY; break;
  35         case ERROR_CALL_NOT_IMPLEMENTED: error = ENOSYS; break;
  36         case ERROR_CANNOT_MAKE: error = EACCES; break;
  37         case ERROR_CANTOPEN: error = EIO; break;
  38         case ERROR_CANTREAD: error = EIO; break;
  39         case ERROR_CANTWRITE: error = EIO; break;
  40         case ERROR_CRC: error = EIO; break;
  41         case ERROR_CURRENT_DIRECTORY: error = EACCES; break;
  42         case ERROR_DEVICE_IN_USE: error = EBUSY; break;
  43         case ERROR_DEV_NOT_EXIST: error = ENODEV; break;
  44         case ERROR_DIRECTORY: error = EINVAL; break;
  45         case ERROR_DIR_NOT_EMPTY: error = ENOTEMPTY; break;
  46         case ERROR_DISK_CHANGE: error = EIO; break;
  47         case ERROR_DISK_FULL: error = ENOSPC; break;
  48         case ERROR_DRIVE_LOCKED: error = EBUSY; break;
  49         case ERROR_ENVVAR_NOT_FOUND: error = EINVAL; break;
  50         case ERROR_EXE_MARKED_INVALID: error = ENOEXEC; break;
  51         case ERROR_FILENAME_EXCED_RANGE: error = ENAMETOOLONG; break;
  52         case ERROR_FILE_EXISTS: error = EEXIST; break;
  53         case ERROR_FILE_INVALID: error = ENODEV; break;
  54         case ERROR_FILE_NOT_FOUND: error = ENOENT; break;
  55         case ERROR_GEN_FAILURE: error = EIO; break;
  56         case ERROR_HANDLE_DISK_FULL: error = ENOSPC; break;
  57         case ERROR_INSUFFICIENT_BUFFER: error = ENOMEM; break;
  58         case ERROR_INVALID_ACCESS: error = EACCES; break;
  59         case ERROR_INVALID_ADDRESS: error = EFAULT; break;
  60         case ERROR_INVALID_BLOCK: error = EFAULT; break;
  61         case ERROR_INVALID_DATA: error = EINVAL; break;
  62         case ERROR_INVALID_DRIVE: error = ENODEV; break;
  63         case ERROR_INVALID_EXE_SIGNATURE: error = ENOEXEC; break;
  64         case ERROR_INVALID_FLAGS: error = EINVAL; break;
  65         case ERROR_INVALID_FUNCTION: error = ENOSYS; break;
  66         case ERROR_INVALID_HANDLE: error = EBADF; break;
  67         case ERROR_INVALID_LOGON_HOURS: error = EACCES; break;
  68         case ERROR_INVALID_NAME: error = EINVAL; break;
  69         case ERROR_INVALID_OWNER: error = EINVAL; break;
  70         case ERROR_INVALID_PARAMETER: error = EINVAL; break;
  71         case ERROR_INVALID_PASSWORD: error = EPERM; break;
  72         case ERROR_INVALID_PRIMARY_GROUP: error = EINVAL; break;
  73         case ERROR_INVALID_SIGNAL_NUMBER: error = EINVAL; break;
  74         case ERROR_INVALID_TARGET_HANDLE: error = EIO; break;
  75         case ERROR_INVALID_WORKSTATION: error = EACCES; break;
  76         case ERROR_IO_DEVICE: error = EIO; break;
  77         case ERROR_IO_INCOMPLETE: error = EINTR; break;
  78         case ERROR_LOCKED: error = EBUSY; break;
  79         case ERROR_LOCK_VIOLATION: error = EACCES; break;
  80         case ERROR_LOGON_FAILURE: error = EACCES; break;
  81         case ERROR_MAPPED_ALIGNMENT: error = EINVAL; break;
  82         case ERROR_META_EXPANSION_TOO_LONG: error = E2BIG; break;
  83         case ERROR_MORE_DATA: error = EPIPE; break;
  84         case ERROR_NEGATIVE_SEEK: error = ESPIPE; break;
  85         case ERROR_NOACCESS: error = EFAULT; break;
  86         case ERROR_NONE_MAPPED: error = EINVAL; break;
  87         case ERROR_NOT_ENOUGH_MEMORY: error = ENOMEM; break;
  88         case ERROR_NOT_READY: error = EAGAIN; break;
  89         case ERROR_NOT_SAME_DEVICE: error = EXDEV; break;
  90         case ERROR_NO_DATA: error = EPIPE; break;
  91         case ERROR_NO_MORE_SEARCH_HANDLES: error = EIO; break;
  92         case ERROR_NO_PROC_SLOTS: error = EAGAIN; break;
  93         case ERROR_NO_SUCH_PRIVILEGE: error = EACCES; break;
  94         case ERROR_OPEN_FAILED: error = EIO; break;
  95         case ERROR_OPEN_FILES: error = EBUSY; break;
  96         case ERROR_OPERATION_ABORTED: error = EINTR; break;
  97         case ERROR_OUTOFMEMORY: error = ENOMEM; break;
  98         case ERROR_PASSWORD_EXPIRED: error = EACCES; break;
  99         case ERROR_PATH_BUSY: error = EBUSY; break;
 100         case ERROR_PATH_NOT_FOUND: error = ENOENT; break;
 101         case ERROR_PIPE_BUSY: error = EBUSY; break;
 102         case ERROR_PIPE_CONNECTED: error = EPIPE; break;
 103         case ERROR_PIPE_LISTENING: error = EPIPE; break;
 104         case ERROR_PIPE_NOT_CONNECTED: error = EPIPE; break;
 105         case ERROR_PRIVILEGE_NOT_HELD: error = EACCES; break;
 106         case ERROR_READ_FAULT: error = EIO; break;
 107         case ERROR_SEEK: error = EIO; break;
 108         case ERROR_SEEK_ON_DEVICE: error = ESPIPE; break;
 109         case ERROR_SHARING_BUFFER_EXCEEDED: error = ENFILE; break;
 110         case ERROR_SHARING_VIOLATION: error = EACCES; break;
 111         case ERROR_STACK_OVERFLOW: error = ENOMEM; break;
 112         case ERROR_SWAPERROR: error = ENOENT; break;
 113         case ERROR_TOO_MANY_MODULES: error = EMFILE; break;
 114         case ERROR_TOO_MANY_OPEN_FILES: error = EMFILE; break;
 115         case ERROR_UNRECOGNIZED_MEDIA: error = ENXIO; break;
 116         case ERROR_UNRECOGNIZED_VOLUME: error = ENODEV; break;
 117         case ERROR_WAIT_NO_CHILDREN: error = ECHILD; break;
 118         case ERROR_WRITE_FAULT: error = EIO; break;
 119         case ERROR_WRITE_PROTECT: error = EROFS; break;
 120         }
 121         return error;
 122 }
 123
 124 static int make_hidden(const char *path)
 125 {
 126         DWORD attribs = GetFileAttributes(path);
 127         if (SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN | attribs))
 128                 return 0;
 129         errno = err_win_to_posix(GetLastError());
 130         return -1;
 131 }
 132
 133 void mingw_mark_as_git_dir(const char *dir)
 134 {
 135         if (hide_dotfiles != HIDE_DOTFILES_FALSE && make_hidden(dir))
 136                 warning("Failed to make '%s' hidden", dir);
 137         git_config_set("core.hideDotFiles",
 138                 hide_dotfiles == HIDE_DOTFILES_FALSE ? "false" :
 139                 (hide_dotfiles == HIDE_DOTFILES_DOTGITONLY ?
 140                  "dotGitOnly" : "true"));
 141 }
 142
 143 #undef mkdir
 144 int mingw_mkdir(const char *path, int mode)
 145 {
 146         int ret = mkdir(path);
 147         if (!ret && hide_dotfiles == HIDE_DOTFILES_TRUE) {
 148                 /*
 149                  * In Windows a file or dir starting with a dot is not
 150                  * automatically hidden. So lets mark it as hidden when
 151                  * such a directory is created.
 152                  */
 153                 const char *start = basename((char*)path);
 154                 if (*start == '.')
 155                         return make_hidden(path);
 156         }
 157         return ret;
 158 }
 159
 160 static int ask_user_yes_no(const char *format, ...)
 161 {
 162         char answer[5];
 163         char question[4096];
 164         const char *retry_hook[] = { NULL, NULL, NULL };
 165         va_list args;
 166
 167         if ((retry_hook[0] = getenv("GIT_ASK_YESNO"))) {
 168
 169                 va_start(args, format);
 170                 vsnprintf(question, sizeof(question), format, args);
 171                 va_end(args);
 172
 173                 retry_hook[1] = question;
 174                 return !run_command_v_opt(retry_hook, 0);
 175         }
 176
 177         if (!isatty(_fileno(stdin)))
 178                 return 0;
 179
 180         while (1) {
 181                 va_start(args, format);
 182                 vfprintf(stderr, format, args);
 183                 va_end(args);
 184                 fprintf(stderr, " (y/n)? ");
 185
 186                 if (fgets(answer, sizeof(answer), stdin)) {
 187                         /* remove the newline */
 188                         if (answer[strlen(answer)-2] == '\r')
 189                                 answer[strlen(answer)-2] = '\0';
 190                         if (answer[strlen(answer)-1] == '\n')
 191                                 answer[strlen(answer)-1] = '\0';
 192                 } else
 193                         return 0;
 194
 195                 if (answer[0] == 'y' && strlen(answer) == 1)
 196                         return 1;
 197                 if (!strncasecmp(answer, "yes", sizeof(answer)))
 198                         return 1;
 199                 if (answer[0] == 'n' && strlen(answer) == 1)
 200                         return 0;
 201                 if (!strncasecmp(answer, "no", sizeof(answer)))
 202                         return 0;
 203                 fprintf(stderr, "I did not understand your answer: '%s'\n",
 204                                 answer);
 205         }
 206 }
 207
 208 #undef unlink
 209 int mingw_unlink(const char *pathname)
 210 {
 211         int ret, tries = 0;
 212
 213         /* read-only files cannot be removed */
 214         chmod(pathname, 0666);
 215         while ((ret = unlink(pathname)) == -1 && tries < ARRAY_SIZE(delay)) {
 216                 if (errno != EACCES)
 217                         break;
 218                 /*
 219                  * We assume that some other process had the source or
 220                  * destination file open at the wrong moment and retry.
 221                  * In order to give the other process a higher chance to
 222                  * complete its operation, we give up our time slice now.
 223                  * If we have to retry again, we do sleep a bit.
 224                  */
 225                 Sleep(delay[tries]);
 226                 tries++;
 227         }
 228         while (ret == -1 && errno == EACCES &&
 229                ask_user_yes_no("Unlink of file '%s' failed. "
 230                         "Should I try again?", pathname))
 231                ret = unlink(pathname);
 232         return ret;
 233 }
 234
 235 #undef rmdir
 236 int mingw_rmdir(const char *pathname)
 237 {
 238     int ret, tries = 0;
 239
 240         while ((ret = rmdir(pathname)) == -1 && tries < ARRAY_SIZE(delay)) {
 241                 if (errno != EACCES)
 242                         break;
 243                 /*
 244                  * We assume that some other process had the source or
 245                  * destination file open at the wrong moment and retry.
 246                  * In order to give the other process a higher chance to
 247                  * complete its operation, we give up our time slice now.
 248                  * If we have to retry again, we do sleep a bit.
 249                  */
 250                 Sleep(delay[tries]);
 251                 tries++;
 252         }
 253         while (ret == -1 && errno == EACCES &&
 254                ask_user_yes_no("Deletion of directory '%s' failed. "
 255                         "Should I try again?", pathname))
 256                ret = rmdir(pathname);
 257         return ret;
 258 }
 259
 260 #undef open
 261 int mingw_open (const char *filename, int oflags, ...)
 262 {
 263         va_list args;
 264         unsigned mode;
 265         int fd;
 266
 267         va_start(args, oflags);
 268         mode = va_arg(args, int);
 269         va_end(args);
 270
 271         if (filename && !strcmp(filename, "/dev/null"))
 272                 filename = "nul";
 273
 274         fd = open(filename, oflags, mode);
 275
 276         if (fd < 0 && (oflags & O_CREAT) && errno == EACCES) {
 277                 DWORD attrs = GetFileAttributes(filename);
 278                 if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY))
 279                         errno = EISDIR;
 280         }
 281         if ((oflags & O_CREAT) && fd >= 0 &&
 282             hide_dotfiles == HIDE_DOTFILES_TRUE) {
 283                 /*
 284                  * In Windows a file or dir starting with a dot is not
 285                  * automatically hidden. So lets mark it as hidden when
 286                  * such a file is created.
 287                  */
 288                 const char *start = basename((char*)filename);
 289                 if (*start == '.' && make_hidden(filename))
 290                         warning("Could not mark '%s' as hidden.", filename);
 291         }
 292         return fd;
 293 }
 294
 295 #undef write
 296 ssize_t mingw_write(int fd, const void *buf, size_t count)
 297 {
 298         /*
 299          * While write() calls to a file on a local disk are translated
 300          * into WriteFile() calls with a maximum size of 64KB on Windows
 301          * XP and 256KB on Vista, no such cap is placed on writes to
 302          * files over the network on Windows XP.  Unfortunately, there
 303          * seems to be a limit of 32MB-28KB on X64 and 64MB-32KB on x86;
 304          * bigger writes fail on Windows XP.
 305          * So we cap to a nice 31MB here to avoid write failures over
 306          * the net without changing the number of WriteFile() calls in
 307          * the local case.
 308          */
 309         return write(fd, buf, min(count, 31 * 1024 * 1024));
 310 }
 311
 312 #undef fopen
 313 FILE *mingw_fopen (const char *filename, const char *otype)
 314 {
 315         int hide = 0;
 316         FILE *file;
 317         if (hide_dotfiles == HIDE_DOTFILES_TRUE &&
 318             basename((char*)filename)[0] == '.')
 319                 hide = access(filename, F_OK);
 320         if (filename && !strcmp(filename, "/dev/null"))
 321                 filename = "nul";
 322         file = fopen(filename, otype);
 323         if (file && hide && make_hidden(filename))
 324                 warning("Could not mark '%s' as hidden.", filename);
 325         return file;
 326 }
 327
 328 #undef freopen
 329 FILE *mingw_freopen (const char *filename, const char *otype, FILE *stream)
 330 {
 331         int hide = 0;
 332         FILE *file;
 333         if (hide_dotfiles == HIDE_DOTFILES_TRUE &&
 334             basename((char*)filename)[0] == '.')
 335                 hide = access(filename, F_OK);
 336         if (filename && !strcmp(filename, "/dev/null"))
 337                 filename = "nul";
 338         file = freopen(filename, otype, stream);
 339         if (file && hide && make_hidden(filename))
 340                 warning("Could not mark '%s' as hidden.", filename);
 341         return file;
 342 }
 343
 344 /*
 345  * The unit of FILETIME is 100-nanoseconds since January 1, 1601, UTC.
 346  * Returns the 100-nanoseconds ("hekto nanoseconds") since the epoch.
 347  */
 348 static inline long long filetime_to_hnsec(const FILETIME *ft)
 349 {
 350         long long winTime = ((long long)ft->dwHighDateTime << 32) + ft->dwLowDateTime;
 351         /* Windows to Unix Epoch conversion */
 352         return winTime - 116444736000000000LL;
 353 }
 354
 355 static inline time_t filetime_to_time_t(const FILETIME *ft)
 356 {
 357         return (time_t)(filetime_to_hnsec(ft) / 10000000);
 358 }
 359
 360 /* We keep the do_lstat code in a separate function to avoid recursion.
 361  * When a path ends with a slash, the stat will fail with ENOENT. In
 362  * this case, we strip the trailing slashes and stat again.
 363  *
 364  * If follow is true then act like stat() and report on the link
 365  * target. Otherwise report on the link itself.
 366  */
 367 static int do_lstat(int follow, const char *file_name, struct stat *buf)
 368 {
 369         int err;
 370         WIN32_FILE_ATTRIBUTE_DATA fdata;
 371
 372         if (!(err = get_file_attr(file_name, &fdata))) {
 373                 buf->st_ino = 0;
 374                 buf->st_gid = 0;
 375                 buf->st_uid = 0;
 376                 buf->st_nlink = 1;
 377                 buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
 378                 buf->st_size = fdata.nFileSizeLow |
 379                         (((off_t)fdata.nFileSizeHigh)<<32);
 380                 buf->st_dev = buf->st_rdev = 0; /* not used by Git */
 381                 buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
 382                 buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
 383                 buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
 384                 if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
 385                         WIN32_FIND_DATAA findbuf;
 386                         HANDLE handle = FindFirstFileA(file_name, &findbuf);
 387                         if (handle != INVALID_HANDLE_VALUE) {
 388                                 if ((findbuf.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) &&
 389                                                 (findbuf.dwReserved0 == IO_REPARSE_TAG_SYMLINK)) {
 390                                         if (follow) {
 391                                                 char buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
 392                                                 buf->st_size = readlink(file_name, buffer, MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
 393                                         } else {
 394                                                 buf->st_mode = S_IFLNK;
 395                                         }
 396                                         buf->st_mode |= S_IREAD;
 397                                         if (!(findbuf.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
 398                                                 buf->st_mode |= S_IWRITE;
 399                                 }
 400                                 FindClose(handle);
 401                         }
 402                 }
 403                 return 0;
 404         }
 405         errno = err;
 406         return -1;
 407 }
 408
 409 /* We provide our own lstat/fstat functions, since the provided
 410  * lstat/fstat functions are so slow. These stat functions are
 411  * tailored for Git's usage (read: fast), and are not meant to be
 412  * complete. Note that Git stat()s are redirected to mingw_lstat()
 413  * too, since Windows doesn't really handle symlinks that well.
 414  */
 415 static int do_stat_internal(int follow, const char *file_name, struct stat *buf)
 416 {
 417         int namelen;
 418         static char alt_name[PATH_MAX];
 419
 420         if (!do_lstat(follow, file_name, buf))
 421                 return 0;
 422
 423         /* if file_name ended in a '/', Windows returned ENOENT;
 424          * try again without trailing slashes
 425          */
 426         if (errno != ENOENT)
 427                 return -1;
 428
 429         namelen = strlen(file_name);
 430         if (namelen && file_name[namelen-1] != '/')
 431                 return -1;
 432         while (namelen && file_name[namelen-1] == '/')
 433                 --namelen;
 434         if (!namelen || namelen >= PATH_MAX)
 435                 return -1;
 436
 437         memcpy(alt_name, file_name, namelen);
 438         alt_name[namelen] = 0;
 439         return do_lstat(follow, alt_name, buf);
 440 }
 441
 442 int mingw_lstat(const char *file_name, struct stat *buf)
 443 {
 444         return do_stat_internal(0, file_name, buf);
 445 }
 446 int mingw_stat(const char *file_name, struct stat *buf)
 447 {
 448         return do_stat_internal(1, file_name, buf);
 449 }
 450
 451 #undef fstat
 452 int mingw_fstat(int fd, struct stat *buf)
 453 {
 454         HANDLE fh = (HANDLE)_get_osfhandle(fd);
 455         BY_HANDLE_FILE_INFORMATION fdata;
 456
 457         if (fh == INVALID_HANDLE_VALUE) {
 458                 errno = EBADF;
 459                 return -1;
 460         }
 461         /* direct non-file handles to MS's fstat() */
 462         if (GetFileType(fh) != FILE_TYPE_DISK)
 463                 return _fstati64(fd, buf);
 464
 465         if (GetFileInformationByHandle(fh, &fdata)) {
 466                 buf->st_ino = 0;
 467                 buf->st_gid = 0;
 468                 buf->st_uid = 0;
 469                 buf->st_nlink = 1;
 470                 buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
 471                 buf->st_size = fdata.nFileSizeLow |
 472                         (((off_t)fdata.nFileSizeHigh)<<32);
 473                 buf->st_dev = buf->st_rdev = 0; /* not used by Git */
 474                 buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
 475                 buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
 476                 buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
 477                 return 0;
 478         }
 479         errno = EBADF;
 480         return -1;
 481 }
 482
 483 static inline void time_t_to_filetime(time_t t, FILETIME *ft)
 484 {
 485         long long winTime = t * 10000000LL + 116444736000000000LL;
 486         ft->dwLowDateTime = winTime;
 487         ft->dwHighDateTime = winTime >> 32;
 488 }
 489
 490 int mingw_utime (const char *file_name, const struct utimbuf *times)
 491 {
 492         FILETIME mft, aft;
 493         int fh, rc;
 494
 495         /* must have write permission */
 496         DWORD attrs = GetFileAttributes(file_name);
 497         if (attrs != INVALID_FILE_ATTRIBUTES &&
 498             (attrs & FILE_ATTRIBUTE_READONLY)) {
 499                 /* ignore errors here; open() will report them */
 500                 SetFileAttributes(file_name, attrs & ~FILE_ATTRIBUTE_READONLY);
 501         }
 502
 503         if ((fh = open(file_name, O_RDWR | O_BINARY)) < 0) {
 504                 rc = -1;
 505                 goto revert_attrs;
 506         }
 507
 508         if (times) {
 509                 time_t_to_filetime(times->modtime, &mft);
 510                 time_t_to_filetime(times->actime, &aft);
 511         } else {
 512                 GetSystemTimeAsFileTime(&mft);
 513                 aft = mft;
 514         }
 515         if (!SetFileTime((HANDLE)_get_osfhandle(fh), NULL, &aft, &mft)) {
 516                 errno = EINVAL;
 517                 rc = -1;
 518         } else
 519                 rc = 0;
 520         close(fh);
 521
 522 revert_attrs:
 523         if (attrs != INVALID_FILE_ATTRIBUTES &&
 524             (attrs & FILE_ATTRIBUTE_READONLY)) {
 525                 /* ignore errors again */
 526                 SetFileAttributes(file_name, attrs);
 527         }
 528         return rc;
 529 }
 530
 531 unsigned int sleep (unsigned int seconds)
 532 {
 533         Sleep(seconds*1000);
 534         return 0;
 535 }
 536
 537 int mkstemp(char *template)
 538 {
 539         char *filename = mktemp(template);
 540         if (filename == NULL)
 541                 return -1;
 542         return open(filename, O_RDWR | O_CREAT, 0600);
 543 }
 544
 545 int gettimeofday(struct timeval *tv, void *tz)
 546 {
 547         FILETIME ft;
 548         long long hnsec;
 549
 550         GetSystemTimeAsFileTime(&ft);
 551         hnsec = filetime_to_hnsec(&ft);
 552         tv->tv_sec = hnsec / 10000000;
 553         tv->tv_usec = (hnsec % 10000000) / 10;
 554         return 0;
 555 }
 556
 557 int pipe(int filedes[2])
 558 {
 559         HANDLE h[2];
 560
 561         /* this creates non-inheritable handles */
 562         if (!CreatePipe(&h[0], &h[1], NULL, 8192)) {
 563                 errno = err_win_to_posix(GetLastError());
 564                 return -1;
 565         }
 566         filedes[0] = _open_osfhandle((int)h[0], O_NOINHERIT);
 567         if (filedes[0] < 0) {
 568                 CloseHandle(h[0]);
 569                 CloseHandle(h[1]);
 570                 return -1;
 571         }
 572         filedes[1] = _open_osfhandle((int)h[1], O_NOINHERIT);
 573         if (filedes[0] < 0) {
 574                 close(filedes[0]);
 575                 CloseHandle(h[1]);
 576                 return -1;
 577         }
 578         return 0;
 579 }
 580
 581 struct tm *gmtime_r(const time_t *timep, struct tm *result)
 582 {
 583         /* gmtime() in MSVCRT.DLL is thread-safe, but not reentrant */
 584         memcpy(result, gmtime(timep), sizeof(struct tm));
 585         return result;
 586 }
 587
 588 struct tm *localtime_r(const time_t *timep, struct tm *result)
 589 {
 590         /* localtime() in MSVCRT.DLL is thread-safe, but not reentrant */
 591         memcpy(result, localtime(timep), sizeof(struct tm));
 592         return result;
 593 }
 594
 595 #undef getcwd
 596 char *mingw_getcwd(char *pointer, int len)
 597 {
 598         int i;
 599         char *ret = getcwd(pointer, len);
 600         if (!ret)
 601                 return ret;
 602         for (i = 0; pointer[i]; i++)
 603                 if (pointer[i] == '\\')
 604                         pointer[i] = '/';
 605         return ret;
 606 }
 607
 608 #undef getenv
 609 char *mingw_getenv(const char *name)
 610 {
 611         char *result = getenv(name);
 612         if (!result && !strcmp(name, "TMPDIR")) {
 613                 /* on Windows it is TMP and TEMP */
 614                 result = getenv("TMP");
 615                 if (!result)
 616                         result = getenv("TEMP");
 617         }
 618         return result;
 619 }
 620
 621 /*
 622  * See http://msdn2.microsoft.com/en-us/library/17w5ykft(vs.71).aspx
 623  * (Parsing C++ Command-Line Arguments)
 624  */
 625 static const char *quote_arg(const char *arg)
 626 {
 627         /* count chars to quote */
 628         int len = 0, n = 0;
 629         int force_quotes = 0;
 630         char *q, *d;
 631         const char *p = arg;
 632         if (!*p) force_quotes = 1;
 633         while (*p) {
 634                 if (isspace(*p) || *p == '*' || *p == '?' || *p == '{' || *p == '\'')
 635                         force_quotes = 1;
 636                 else if (*p == '"')
 637                         n++;
 638                 else if (*p == '\\') {
 639                         int count = 0;
 640                         while (*p == '\\') {
 641                                 count++;
 642                                 p++;
 643                                 len++;
 644                         }
 645                         if (*p == '"')
 646                                 n += count*2 + 1;
 647                         continue;
 648                 }
 649                 len++;
 650                 p++;
 651         }
 652         if (!force_quotes && n == 0)
 653                 return arg;
 654
 655         /* insert \ where necessary */
 656         d = q = xmalloc(len+n+3);
 657         *d++ = '"';
 658         while (*arg) {
 659                 if (*arg == '"')
 660                         *d++ = '\\';
 661                 else if (*arg == '\\') {
 662                         int count = 0;
 663                         while (*arg == '\\') {
 664                                 count++;
 665                                 *d++ = *arg++;
 666                         }
 667                         if (*arg == '"') {
 668                                 while (count-- > 0)
 669                                         *d++ = '\\';
 670                                 *d++ = '\\';
 671                         }
 672                 }
 673                 *d++ = *arg++;
 674         }
 675         *d++ = '"';
 676         *d++ = 0;
 677         return q;
 678 }
 679
 680 static const char *parse_interpreter(const char *cmd)
 681 {
 682         static char buf[100];
 683         char *p, *opt;
 684         int n, fd;
 685
 686         /* don't even try a .exe */
 687         n = strlen(cmd);
 688         if (n >= 4 && !strcasecmp(cmd+n-4, ".exe"))
 689                 return NULL;
 690
 691         fd = open(cmd, O_RDONLY);
 692         if (fd < 0)
 693                 return NULL;
 694         n = read(fd, buf, sizeof(buf)-1);
 695         close(fd);
 696         if (n < 4)      /* at least '#!/x' and not error */
 697                 return NULL;
 698
 699         if (buf[0] != '#' || buf[1] != '!')
 700                 return NULL;
 701         buf[n] = '\0';
 702         p = buf + strcspn(buf, "\r\n");
 703         if (!*p)
 704                 return NULL;
 705
 706         *p = '\0';
 707         if (!(p = strrchr(buf+2, '/')) && !(p = strrchr(buf+2, '\\')))
 708                 return NULL;
 709         /* strip options */
 710         if ((opt = strchr(p+1, ' ')))
 711                 *opt = '\0';
 712         return p+1;
 713 }
 714
 715 /*
 716  * Splits the PATH into parts.
 717  */
 718 static char **get_path_split(void)
 719 {
 720         char *p, **path, *envpath = getenv("PATH");
 721         int i, n = 0;
 722
 723         if (!envpath || !*envpath)
 724                 return NULL;
 725
 726         envpath = xstrdup(envpath);
 727         p = envpath;
 728         while (p) {
 729                 char *dir = p;
 730                 p = strchr(p, ';');
 731                 if (p) *p++ = '\0';
 732                 if (*dir) {     /* not earlier, catches series of ; */
 733                         ++n;
 734                 }
 735         }
 736         if (!n)
 737                 return NULL;
 738
 739         path = xmalloc((n+1)*sizeof(char *));
 740         p = envpath;
 741         i = 0;
 742         do {
 743                 if (*p)
 744                         path[i++] = xstrdup(p);
 745                 p = p+strlen(p)+1;
 746         } while (i < n);
 747         path[i] = NULL;
 748
 749         free(envpath);
 750
 751         return path;
 752 }
 753
 754 static void free_path_split(char **path)
 755 {
 756         char **p = path;
 757
 758         if (!path)
 759                 return;
 760
 761         while (*p)
 762                 free(*p++);
 763         free(path);
 764 }
 765
 766 /*
 767  * exe_only means that we only want to detect .exe files, but not scripts
 768  * (which do not have an extension)
 769  */
 770 static char *lookup_prog(const char *dir, const char *cmd, int isexe, int exe_only)
 771 {
 772         char path[MAX_PATH];
 773         snprintf(path, sizeof(path), "%s/%s.exe", dir, cmd);
 774
 775         if (!isexe && access(path, F_OK) == 0)
 776                 return xstrdup(path);
 777         path[strlen(path)-4] = '\0';
 778         if ((!exe_only || isexe) && access(path, F_OK) == 0)
 779                 if (!(GetFileAttributes(path) & FILE_ATTRIBUTE_DIRECTORY))
 780                         return xstrdup(path);
 781         return NULL;
 782 }
 783
 784 /*
 785  * Determines the absolute path of cmd using the split path in path.
 786  * If cmd contains a slash or backslash, no lookup is performed.
 787  */
 788 static char *path_lookup(const char *cmd, char **path, int exe_only)
 789 {
 790         char *prog = NULL;
 791         int len = strlen(cmd);
 792         int isexe = len >= 4 && !strcasecmp(cmd+len-4, ".exe");
 793
 794         if (strchr(cmd, '/') || strchr(cmd, '\\'))
 795                 prog = xstrdup(cmd);
 796
 797         while (!prog && *path)
 798                 prog = lookup_prog(*path++, cmd, isexe, exe_only);
 799
 800         return prog;
 801 }
 802
 803 static int env_compare(const void *a, const void *b)
 804 {
 805         char *const *ea = a;
 806         char *const *eb = b;
 807         return strcasecmp(*ea, *eb);
 808 }
 809
 810 struct pinfo_t {
 811         struct pinfo_t *next;
 812         pid_t pid;
 813         HANDLE proc;
 814 } pinfo_t;
 815 struct pinfo_t *pinfo = NULL;
 816 CRITICAL_SECTION pinfo_cs;
 817
 818 static pid_t mingw_spawnve_fd(const char *cmd, const char **argv, char **env,
 819                               const char *dir,
 820                               int prepend_cmd, int fhin, int fhout, int fherr)
 821 {
 822         STARTUPINFO si;
 823         PROCESS_INFORMATION pi;
 824         struct strbuf envblk, args;
 825         unsigned flags;
 826         BOOL ret;
 827
 828         /* Determine whether or not we are associated to a console */
 829         HANDLE cons = CreateFile("CONOUT$", GENERIC_WRITE,
 830                         FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
 831                         FILE_ATTRIBUTE_NORMAL, NULL);
 832         if (cons == INVALID_HANDLE_VALUE) {
 833                 /* There is no console associated with this process.
 834                  * Since the child is a console process, Windows
 835                  * would normally create a console window. But
 836                  * since we'll be redirecting std streams, we do
 837                  * not need the console.
 838                  * It is necessary to use DETACHED_PROCESS
 839                  * instead of CREATE_NO_WINDOW to make ssh
 840                  * recognize that it has no console.
 841                  */
 842                 flags = DETACHED_PROCESS;
 843         } else {
 844                 /* There is already a console. If we specified
 845                  * DETACHED_PROCESS here, too, Windows would
 846                  * disassociate the child from the console.
 847                  * The same is true for CREATE_NO_WINDOW.
 848                  * Go figure!
 849                  */
 850                 flags = 0;
 851                 CloseHandle(cons);
 852         }
 853         memset(&si, 0, sizeof(si));
 854         si.cb = sizeof(si);
 855         si.dwFlags = STARTF_USESTDHANDLES;
 856         si.hStdInput = (HANDLE) _get_osfhandle(fhin);
 857         si.hStdOutput = (HANDLE) _get_osfhandle(fhout);
 858         si.hStdError = (HANDLE) _get_osfhandle(fherr);
 859
 860         /* concatenate argv, quoting args as we go */
 861         strbuf_init(&args, 0);
 862         if (prepend_cmd) {
 863                 char *quoted = (char *)quote_arg(cmd);
 864                 strbuf_addstr(&args, quoted);
 865                 if (quoted != cmd)
 866                         free(quoted);
 867         }
 868         for (; *argv; argv++) {
 869                 char *quoted = (char *)quote_arg(*argv);
 870                 if (*args.buf)
 871                         strbuf_addch(&args, ' ');
 872                 strbuf_addstr(&args, quoted);
 873                 if (quoted != *argv)
 874                         free(quoted);
 875         }
 876
 877         if (env) {
 878                 int count = 0;
 879                 char **e, **sorted_env;
 880
 881                 for (e = env; *e; e++)
 882                         count++;
 883
 884                 /* environment must be sorted */
 885                 sorted_env = xmalloc(sizeof(*sorted_env) * (count + 1));
 886                 memcpy(sorted_env, env, sizeof(*sorted_env) * (count + 1));
 887                 qsort(sorted_env, count, sizeof(*sorted_env), env_compare);
 888
 889                 strbuf_init(&envblk, 0);
 890                 for (e = sorted_env; *e; e++) {
 891                         strbuf_addstr(&envblk, *e);
 892                         strbuf_addch(&envblk, '\0');
 893                 }
 894                 free(sorted_env);
 895         }
 896
 897         memset(&pi, 0, sizeof(pi));
 898         ret = CreateProcess(cmd, args.buf, NULL, NULL, TRUE, flags,
 899                 env ? envblk.buf : NULL, dir, &si, &pi);
 900
 901         if (env)
 902                 strbuf_release(&envblk);
 903         strbuf_release(&args);
 904
 905         if (!ret) {
 906                 errno = ENOENT;
 907                 return -1;
 908         }
 909         CloseHandle(pi.hThread);
 910
 911         /*
 912          * The process ID is the human-readable identifier of the process
 913          * that we want to present in log and error messages. The handle
 914          * is not useful for this purpose. But we cannot close it, either,
 915          * because it is not possible to turn a process ID into a process
 916          * handle after the process terminated.
 917          * Keep the handle in a list for waitpid.
 918          */
 919         EnterCriticalSection(&pinfo_cs);
 920         {
 921                 struct pinfo_t *info = xmalloc(sizeof(struct pinfo_t));
 922                 info->pid = pi.dwProcessId;
 923                 info->proc = pi.hProcess;
 924                 info->next = pinfo;
 925                 pinfo = info;
 926         }
 927         LeaveCriticalSection(&pinfo_cs);
 928
 929         return (pid_t)pi.dwProcessId;
 930 }
 931
 932 static pid_t mingw_spawnve(const char *cmd, const char **argv, char **env,
 933                            int prepend_cmd)
 934 {
 935         return mingw_spawnve_fd(cmd, argv, env, NULL, prepend_cmd, 0, 1, 2);
 936 }
 937
 938 pid_t mingw_spawnvpe(const char *cmd, const char **argv, char **env,
 939                      const char *dir,
 940                      int fhin, int fhout, int fherr)
 941 {
 942         pid_t pid;
 943         char **path = get_path_split();
 944         char *prog = path_lookup(cmd, path, 0);
 945
 946         if (!prog) {
 947                 errno = ENOENT;
 948                 pid = -1;
 949         }
 950         else {
 951                 const char *interpr = parse_interpreter(prog);
 952
 953                 if (interpr) {
 954                         const char *argv0 = argv[0];
 955                         char *iprog = path_lookup(interpr, path, 1);
 956                         argv[0] = prog;
 957                         if (!iprog) {
 958                                 errno = ENOENT;
 959                                 pid = -1;
 960                         }
 961                         else {
 962                                 pid = mingw_spawnve_fd(iprog, argv, env, dir, 1,
 963                                                        fhin, fhout, fherr);
 964                                 free(iprog);
 965                         }
 966                         argv[0] = argv0;
 967                 }
 968                 else
 969                         pid = mingw_spawnve_fd(prog, argv, env, dir, 0,
 970                                                fhin, fhout, fherr);
 971                 free(prog);
 972         }
 973         free_path_split(path);
 974         return pid;
 975 }
 976
 977 static int try_shell_exec(const char *cmd, char *const *argv, char **env)
 978 {
 979         const char *interpr = parse_interpreter(cmd);
 980         char **path;
 981         char *prog;
 982         int pid = 0;
 983
 984         if (!interpr)
 985                 return 0;
 986         path = get_path_split();
 987         prog = path_lookup(interpr, path, 1);
 988         if (prog) {
 989                 int argc = 0;
 990                 const char **argv2;
 991                 while (argv[argc]) argc++;
 992                 argv2 = xmalloc(sizeof(*argv) * (argc+1));
 993                 argv2[0] = (char *)cmd; /* full path to the script file */
 994                 memcpy(&argv2[1], &argv[1], sizeof(*argv) * argc);
 995                 pid = mingw_spawnve(prog, argv2, env, 1);
 996                 if (pid >= 0) {
 997                         int status;
 998                         if (waitpid(pid, &status, 0) < 0)
 999                                 status = 255;
1000                         exit(status);
1001                 }
1002                 pid = 1;        /* indicate that we tried but failed */
1003                 free(prog);
1004                 free(argv2);
1005         }
1006         free_path_split(path);
1007         return pid;
1008 }
1009
1010 static void mingw_execve(const char *cmd, char *const *argv, char *const *env)
1011 {
1012         /* check if git_command is a shell script */
1013         if (!try_shell_exec(cmd, argv, (char **)env)) {
1014                 int pid, status;
1015
1016                 pid = mingw_spawnve(cmd, (const char **)argv, (char **)env, 0);
1017                 if (pid < 0)
1018                         return;
1019                 if (waitpid(pid, &status, 0) < 0)
1020                         status = 255;
1021                 exit(status);
1022         }
1023 }
1024
1025 void mingw_execvp(const char *cmd, char *const *argv)
1026 {
1027         char **path = get_path_split();
1028         char *prog = path_lookup(cmd, path, 0);
1029
1030         if (prog) {
1031                 mingw_execve(prog, argv, environ);
1032                 free(prog);
1033         } else
1034                 errno = ENOENT;
1035
1036         free_path_split(path);
1037 }
1038
1039 void mingw_execv(const char *cmd, char *const *argv)
1040 {
1041         mingw_execve(cmd, argv, environ);
1042 }
1043
1044 int mingw_kill(pid_t pid, int sig)
1045 {
1046         if (pid > 0 && sig == SIGTERM) {
1047                 HANDLE h = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
1048
1049                 if (TerminateProcess(h, -1)) {
1050                         CloseHandle(h);
1051                         return 0;
1052                 }
1053
1054                 errno = err_win_to_posix(GetLastError());
1055                 CloseHandle(h);
1056                 return -1;
1057         }
1058
1059         errno = EINVAL;
1060         return -1;
1061 }
1062
1063 static char **copy_environ(void)
1064 {
1065         char **env;
1066         int i = 0;
1067         while (environ[i])
1068                 i++;
1069         env = xmalloc((i+1)*sizeof(*env));
1070         for (i = 0; environ[i]; i++)
1071                 env[i] = xstrdup(environ[i]);
1072         env[i] = NULL;
1073         return env;
1074 }
1075
1076 void free_environ(char **env)
1077 {
1078         int i;
1079         for (i = 0; env[i]; i++)
1080                 free(env[i]);
1081         free(env);
1082 }
1083
1084 static int lookup_env(char **env, const char *name, size_t nmln)
1085 {
1086         int i;
1087
1088         for (i = 0; env[i]; i++) {
1089                 if (0 == strncmp(env[i], name, nmln)
1090                     && '=' == env[i][nmln])
1091                         /* matches */
1092                         return i;
1093         }
1094         return -1;
1095 }
1096
1097 /*
1098  * If name contains '=', then sets the variable, otherwise it unsets it
1099  */
1100 static char **env_setenv(char **env, const char *name)
1101 {
1102         char *eq = strchrnul(name, '=');
1103         int i = lookup_env(env, name, eq-name);
1104
1105         if (i < 0) {
1106                 if (*eq) {
1107                         for (i = 0; env[i]; i++)
1108                                 ;
1109                         env = xrealloc(env, (i+2)*sizeof(*env));
1110                         env[i] = xstrdup(name);
1111                         env[i+1] = NULL;
1112                 }
1113         }
1114         else {
1115                 free(env[i]);
1116                 if (*eq)
1117                         env[i] = xstrdup(name);
1118                 else
1119                         for (; env[i]; i++)
1120                                 env[i] = env[i+1];
1121         }
1122         return env;
1123 }
1124
1125 /*
1126  * Copies global environ and adjusts variables as specified by vars.
1127  */
1128 char **make_augmented_environ(const char *const *vars)
1129 {
1130         char **env = copy_environ();
1131
1132         while (*vars)
1133                 env = env_setenv(env, *vars++);
1134         return env;
1135 }
1136
1137 /*
1138  * Note, this isn't a complete replacement for getaddrinfo. It assumes
1139  * that service contains a numerical port, or that it it is null. It
1140  * does a simple search using gethostbyname, and returns one IPv4 host
1141  * if one was found.
1142  */
1143 static int WSAAPI getaddrinfo_stub(const char *node, const char *service,
1144                                    const struct addrinfo *hints,
1145                                    struct addrinfo **res)
1146 {
1147         struct hostent *h = NULL;
1148         struct addrinfo *ai;
1149         struct sockaddr_in *sin;
1150
1151         if (node) {
1152                 h = gethostbyname(node);
1153                 if (!h)
1154                         return WSAGetLastError();
1155         }
1156
1157         ai = xmalloc(sizeof(struct addrinfo));
1158         *res = ai;
1159         ai->ai_flags = 0;
1160         ai->ai_family = AF_INET;
1161         ai->ai_socktype = hints ? hints->ai_socktype : 0;
1162         switch (ai->ai_socktype) {
1163         case SOCK_STREAM:
1164                 ai->ai_protocol = IPPROTO_TCP;
1165                 break;
1166         case SOCK_DGRAM:
1167                 ai->ai_protocol = IPPROTO_UDP;
1168                 break;
1169         default:
1170                 ai->ai_protocol = 0;
1171                 break;
1172         }
1173         ai->ai_addrlen = sizeof(struct sockaddr_in);
1174         if (hints && (hints->ai_flags & AI_CANONNAME))
1175                 ai->ai_canonname = h ? strdup(h->h_name) : NULL;
1176         else
1177                 ai->ai_canonname = NULL;
1178
1179         sin = xmalloc(ai->ai_addrlen);
1180         memset(sin, 0, ai->ai_addrlen);
1181         sin->sin_family = AF_INET;
1182         /* Note: getaddrinfo is supposed to allow service to be a string,
1183          * which should be looked up using getservbyname. This is
1184          * currently not implemented */
1185         if (service)
1186                 sin->sin_port = htons(atoi(service));
1187         if (h)
1188                 sin->sin_addr = *(struct in_addr *)h->h_addr;
1189         else if (hints && (hints->ai_flags & AI_PASSIVE))
1190                 sin->sin_addr.s_addr = INADDR_ANY;
1191         else
1192                 sin->sin_addr.s_addr = INADDR_LOOPBACK;
1193         ai->ai_addr = (struct sockaddr *)sin;
1194         ai->ai_next = 0;
1195         return 0;
1196 }
1197
1198 static void WSAAPI freeaddrinfo_stub(struct addrinfo *res)
1199 {
1200         free(res->ai_canonname);
1201         free(res->ai_addr);
1202         free(res);
1203 }
1204
1205 static int WSAAPI getnameinfo_stub(const struct sockaddr *sa, socklen_t salen,
1206                                    char *host, DWORD hostlen,
1207                                    char *serv, DWORD servlen, int flags)
1208 {
1209         const struct sockaddr_in *sin = (const struct sockaddr_in *)sa;
1210         if (sa->sa_family != AF_INET)
1211                 return EAI_FAMILY;
1212         if (!host && !serv)
1213                 return EAI_NONAME;
1214
1215         if (host && hostlen > 0) {
1216                 struct hostent *ent = NULL;
1217                 if (!(flags & NI_NUMERICHOST))
1218                         ent = gethostbyaddr((const char *)&sin->sin_addr,
1219                                             sizeof(sin->sin_addr), AF_INET);
1220
1221                 if (ent)
1222                         snprintf(host, hostlen, "%s", ent->h_name);
1223                 else if (flags & NI_NAMEREQD)
1224                         return EAI_NONAME;
1225                 else
1226                         snprintf(host, hostlen, "%s", inet_ntoa(sin->sin_addr));
1227         }
1228
1229         if (serv && servlen > 0) {
1230                 struct servent *ent = NULL;
1231                 if (!(flags & NI_NUMERICSERV))
1232                         ent = getservbyport(sin->sin_port,
1233                                             flags & NI_DGRAM ? "udp" : "tcp");
1234
1235                 if (ent)
1236                         snprintf(serv, servlen, "%s", ent->s_name);
1237                 else
1238                         snprintf(serv, servlen, "%d", ntohs(sin->sin_port));
1239         }
1240
1241         return 0;
1242 }
1243
1244 static HMODULE ipv6_dll = NULL;
1245 static void (WSAAPI *ipv6_freeaddrinfo)(struct addrinfo *res);
1246 static int (WSAAPI *ipv6_getaddrinfo)(const char *node, const char *service,
1247                                       const struct addrinfo *hints,
1248                                       struct addrinfo **res);
1249 static int (WSAAPI *ipv6_getnameinfo)(const struct sockaddr *sa, socklen_t salen,
1250                                       char *host, DWORD hostlen,
1251                                       char *serv, DWORD servlen, int flags);
1252 /*
1253  * gai_strerror is an inline function in the ws2tcpip.h header, so we
1254  * don't need to try to load that one dynamically.
1255  */
1256
1257 static void socket_cleanup(void)
1258 {
1259         WSACleanup();
1260         if (ipv6_dll)
1261                 FreeLibrary(ipv6_dll);
1262         ipv6_dll = NULL;
1263         ipv6_freeaddrinfo = freeaddrinfo_stub;
1264         ipv6_getaddrinfo = getaddrinfo_stub;
1265         ipv6_getnameinfo = getnameinfo_stub;
1266 }
1267
1268 static void ensure_socket_initialization(void)
1269 {
1270         WSADATA wsa;
1271         static int initialized = 0;
1272         const char *libraries[] = { "ws2_32.dll", "wship6.dll", NULL };
1273         const char **name;
1274
1275         if (initialized)
1276                 return;
1277
1278         if (WSAStartup(MAKEWORD(2,2), &wsa))
1279                 die("unable to initialize winsock subsystem, error %d",
1280                         WSAGetLastError());
1281
1282         for (name = libraries; *name; name++) {
1283                 ipv6_dll = LoadLibrary(*name);
1284                 if (!ipv6_dll)
1285                         continue;
1286
1287                 ipv6_freeaddrinfo = (void (WSAAPI *)(struct addrinfo *))
1288                         GetProcAddress(ipv6_dll, "freeaddrinfo");
1289                 ipv6_getaddrinfo = (int (WSAAPI *)(const char *, const char *,
1290                                                    const struct addrinfo *,
1291                                                    struct addrinfo **))
1292                         GetProcAddress(ipv6_dll, "getaddrinfo");
1293                 ipv6_getnameinfo = (int (WSAAPI *)(const struct sockaddr *,
1294                                                    socklen_t, char *, DWORD,
1295                                                    char *, DWORD, int))
1296                         GetProcAddress(ipv6_dll, "getnameinfo");
1297                 if (!ipv6_freeaddrinfo || !ipv6_getaddrinfo || !ipv6_getnameinfo) {
1298                         FreeLibrary(ipv6_dll);
1299                         ipv6_dll = NULL;
1300                 } else
1301                         break;
1302         }
1303         if (!ipv6_freeaddrinfo || !ipv6_getaddrinfo || !ipv6_getnameinfo) {
1304                 ipv6_freeaddrinfo = freeaddrinfo_stub;
1305                 ipv6_getaddrinfo = getaddrinfo_stub;
1306                 ipv6_getnameinfo = getnameinfo_stub;
1307         }
1308
1309         atexit(socket_cleanup);
1310         initialized = 1;
1311 }
1312
1313 #undef gethostbyname
1314 struct hostent *mingw_gethostbyname(const char *host)
1315 {
1316         ensure_socket_initialization();
1317         return gethostbyname(host);
1318 }
1319
1320 void mingw_freeaddrinfo(struct addrinfo *res)
1321 {
1322         ipv6_freeaddrinfo(res);
1323 }
1324
1325 int mingw_getaddrinfo(const char *node, const char *service,
1326                       const struct addrinfo *hints, struct addrinfo **res)
1327 {
1328         ensure_socket_initialization();
1329         return ipv6_getaddrinfo(node, service, hints, res);
1330 }
1331
1332 int mingw_getnameinfo(const struct sockaddr *sa, socklen_t salen,
1333                       char *host, DWORD hostlen, char *serv, DWORD servlen,
1334                       int flags)
1335 {
1336         ensure_socket_initialization();
1337         return ipv6_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
1338 }
1339
1340 int mingw_socket(int domain, int type, int protocol)
1341 {
1342         int sockfd;
1343         SOCKET s;
1344
1345         ensure_socket_initialization();
1346         s = WSASocket(domain, type, protocol, NULL, 0, 0);
1347         if (s == INVALID_SOCKET) {
1348                 /*
1349                  * WSAGetLastError() values are regular BSD error codes
1350                  * biased by WSABASEERR.
1351                  * However, strerror() does not know about networking
1352                  * specific errors, which are values beginning at 38 or so.
1353                  * Therefore, we choose to leave the biased error code
1354                  * in errno so that _if_ someone looks up the code somewhere,
1355                  * then it is at least the number that are usually listed.
1356                  */
1357                 errno = WSAGetLastError();
1358                 return -1;
1359         }
1360         /* convert into a file descriptor */
1361         if ((sockfd = _open_osfhandle(s, O_RDWR|O_BINARY)) < 0) {
1362                 closesocket(s);
1363                 return error("unable to make a socket file descriptor: %s",
1364                         strerror(errno));
1365         }
1366         return sockfd;
1367 }
1368
1369 #undef connect
1370 int mingw_connect(int sockfd, struct sockaddr *sa, size_t sz)
1371 {
1372         SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1373         return connect(s, sa, sz);
1374 }
1375
1376 #undef bind
1377 int mingw_bind(int sockfd, struct sockaddr *sa, size_t sz)
1378 {
1379         SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1380         return bind(s, sa, sz);
1381 }
1382
1383 #undef setsockopt
1384 int mingw_setsockopt(int sockfd, int lvl, int optname, void *optval, int optlen)
1385 {
1386         SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1387         return setsockopt(s, lvl, optname, (const char*)optval, optlen);
1388 }
1389
1390 #undef listen
1391 int mingw_listen(int sockfd, int backlog)
1392 {
1393         SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1394         return listen(s, backlog);
1395 }
1396
1397 #undef accept
1398 int mingw_accept(int sockfd1, struct sockaddr *sa, socklen_t *sz)
1399 {
1400         int sockfd2;
1401
1402         SOCKET s1 = (SOCKET)_get_osfhandle(sockfd1);
1403         SOCKET s2 = accept(s1, sa, sz);
1404
1405         /* convert into a file descriptor */
1406         if ((sockfd2 = _open_osfhandle(s2, O_RDWR|O_BINARY)) < 0) {
1407                 int err = errno;
1408                 closesocket(s2);
1409                 return error("unable to make a socket file descriptor: %s",
1410                         strerror(err));
1411         }
1412         return sockfd2;
1413 }
1414
1415 #undef rename
1416 int mingw_rename(const char *pold, const char *pnew)
1417 {
1418         DWORD attrs, gle;
1419         int tries = 0;
1420
1421         /*
1422          * Try native rename() first to get errno right.
1423          * It is based on MoveFile(), which cannot overwrite existing files.
1424          */
1425         if (!rename(pold, pnew))
1426                 return 0;
1427         if (errno != EEXIST)
1428                 return -1;
1429 repeat:
1430         if (MoveFileEx(pold, pnew, MOVEFILE_REPLACE_EXISTING))
1431                 return 0;
1432         /* TODO: translate more errors */
1433         gle = GetLastError();
1434         if (gle == ERROR_ACCESS_DENIED &&
1435             (attrs = GetFileAttributes(pnew)) != INVALID_FILE_ATTRIBUTES) {
1436                 if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
1437                         errno = EISDIR;
1438                         return -1;
1439                 }
1440                 if ((attrs & FILE_ATTRIBUTE_READONLY) &&
1441                     SetFileAttributes(pnew, attrs & ~FILE_ATTRIBUTE_READONLY)) {
1442                         if (MoveFileEx(pold, pnew, MOVEFILE_REPLACE_EXISTING))
1443                                 return 0;
1444                         gle = GetLastError();
1445                         /* revert file attributes on failure */
1446                         SetFileAttributes(pnew, attrs);
1447                 }
1448         }
1449         if (tries < ARRAY_SIZE(delay) && gle == ERROR_ACCESS_DENIED) {
1450                 /*
1451                  * We assume that some other process had the source or
1452                  * destination file open at the wrong moment and retry.
1453                  * In order to give the other process a higher chance to
1454                  * complete its operation, we give up our time slice now.
1455                  * If we have to retry again, we do sleep a bit.
1456                  */
1457                 Sleep(delay[tries]);
1458                 tries++;
1459                 goto repeat;
1460         }
1461         if (gle == ERROR_ACCESS_DENIED &&
1462                ask_user_yes_no("Rename from '%s' to '%s' failed. "
1463                        "Should I try again?", pold, pnew))
1464                 goto repeat;
1465
1466         errno = EACCES;
1467         return -1;
1468 }
1469
1470 /*
1471  * Note that this doesn't return the actual pagesize, but
1472  * the allocation granularity. If future Windows specific git code
1473  * needs the real getpagesize function, we need to find another solution.
1474  */
1475 int mingw_getpagesize(void)
1476 {
1477         SYSTEM_INFO si;
1478         GetSystemInfo(&si);
1479         return si.dwAllocationGranularity;
1480 }
1481
1482 struct passwd *getpwuid(int uid)
1483 {
1484         static char user_name[100];
1485         static struct passwd p;
1486
1487         DWORD len = sizeof(user_name);
1488         if (!GetUserName(user_name, &len))
1489                 return NULL;
1490         p.pw_name = user_name;
1491         p.pw_gecos = "unknown";
1492         p.pw_dir = NULL;
1493         return &p;
1494 }
1495
1496 static HANDLE timer_event;
1497 static HANDLE timer_thread;
1498 static int timer_interval;
1499 static int one_shot;
1500 static sig_handler_t timer_fn = SIG_DFL;
1501
1502 /* The timer works like this:
1503  * The thread, ticktack(), is a trivial routine that most of the time
1504  * only waits to receive the signal to terminate. The main thread tells
1505  * the thread to terminate by setting the timer_event to the signalled
1506  * state.
1507  * But ticktack() interrupts the wait state after the timer's interval
1508  * length to call the signal handler.
1509  */
1510
1511 static unsigned __stdcall ticktack(void *dummy)
1512 {
1513         while (WaitForSingleObject(timer_event, timer_interval) == WAIT_TIMEOUT) {
1514                 if (timer_fn == SIG_DFL)
1515                         die("Alarm");
1516                 if (timer_fn != SIG_IGN)
1517                         timer_fn(SIGALRM);
1518                 if (one_shot)
1519                         break;
1520         }
1521         return 0;
1522 }
1523
1524 static int start_timer_thread(void)
1525 {
1526         timer_event = CreateEvent(NULL, FALSE, FALSE, NULL);
1527         if (timer_event) {
1528                 timer_thread = (HANDLE) _beginthreadex(NULL, 0, ticktack, NULL, 0, NULL);
1529                 if (!timer_thread )
1530                         return errno = ENOMEM,
1531                                 error("cannot start timer thread");
1532         } else
1533                 return errno = ENOMEM,
1534                         error("cannot allocate resources for timer");
1535         return 0;
1536 }
1537
1538 static void stop_timer_thread(void)
1539 {
1540         if (timer_event)
1541                 SetEvent(timer_event);  /* tell thread to terminate */
1542         if (timer_thread) {
1543                 int rc = WaitForSingleObject(timer_thread, 1000);
1544                 if (rc == WAIT_TIMEOUT)
1545                         error("timer thread did not terminate timely");
1546                 else if (rc != WAIT_OBJECT_0)
1547                         error("waiting for timer thread failed: %lu",
1548                               GetLastError());
1549                 CloseHandle(timer_thread);
1550         }
1551         if (timer_event)
1552                 CloseHandle(timer_event);
1553         timer_event = NULL;
1554         timer_thread = NULL;
1555 }
1556
1557 static inline int is_timeval_eq(const struct timeval *i1, const struct timeval *i2)
1558 {
1559         return i1->tv_sec == i2->tv_sec && i1->tv_usec == i2->tv_usec;
1560 }
1561
1562 int setitimer(int type, struct itimerval *in, struct itimerval *out)
1563 {
1564         static const struct timeval zero;
1565         static int atexit_done;
1566
1567         if (out != NULL)
1568                 return errno = EINVAL,
1569                         error("setitimer param 3 != NULL not implemented");
1570         if (!is_timeval_eq(&in->it_interval, &zero) &&
1571             !is_timeval_eq(&in->it_interval, &in->it_value))
1572                 return errno = EINVAL,
1573                         error("setitimer: it_interval must be zero or eq it_value");
1574
1575         if (timer_thread)
1576                 stop_timer_thread();
1577
1578         if (is_timeval_eq(&in->it_value, &zero) &&
1579             is_timeval_eq(&in->it_interval, &zero))
1580                 return 0;
1581
1582         timer_interval = in->it_value.tv_sec * 1000 + in->it_value.tv_usec / 1000;
1583         one_shot = is_timeval_eq(&in->it_interval, &zero);
1584         if (!atexit_done) {
1585                 atexit(stop_timer_thread);
1586                 atexit_done = 1;
1587         }
1588         return start_timer_thread();
1589 }
1590
1591 int sigaction(int sig, struct sigaction *in, struct sigaction *out)
1592 {
1593         if (sig != SIGALRM)
1594                 return errno = EINVAL,
1595                         error("sigaction only implemented for SIGALRM");
1596         if (out != NULL)
1597                 return errno = EINVAL,
1598                         error("sigaction: param 3 != NULL not implemented");
1599
1600         timer_fn = in->sa_handler;
1601         return 0;
1602 }
1603
1604 #undef signal
1605 sig_handler_t mingw_signal(int sig, sig_handler_t handler)
1606 {
1607         sig_handler_t old = timer_fn;
1608         if (sig != SIGALRM)
1609                 return signal(sig, handler);
1610         timer_fn = handler;
1611         return old;
1612 }
1613
1614 static const char *make_backslash_path(const char *path)
1615 {
1616         static char buf[PATH_MAX + 1];
1617         char *c;
1618
1619         if (strlcpy(buf, path, PATH_MAX) >= PATH_MAX)
1620                 die("Too long path: %.*s", 60, path);
1621
1622         for (c = buf; *c; c++) {
1623                 if (*c == '/')
1624                         *c = '\\';
1625         }
1626         return buf;
1627 }
1628
1629 void mingw_open_html(const char *unixpath)
1630 {
1631         const char *htmlpath = make_backslash_path(unixpath);
1632         typedef HINSTANCE (WINAPI *T)(HWND, const char *,
1633                         const char *, const char *, const char *, INT);
1634         T ShellExecute;
1635         HMODULE shell32;
1636         int r;
1637
1638         shell32 = LoadLibrary("shell32.dll");
1639         if (!shell32)
1640                 die("cannot load shell32.dll");
1641         ShellExecute = (T)GetProcAddress(shell32, "ShellExecuteA");
1642         if (!ShellExecute)
1643                 die("cannot run browser");
1644
1645         printf("Launching default browser to display HTML ...\n");
1646         r = (int)ShellExecute(NULL, "open", htmlpath, NULL, "\\", SW_SHOWNORMAL);
1647         FreeLibrary(shell32);
1648         /* see the MSDN documentation referring to the result codes here */
1649         if (r <= 32) {
1650                 die("failed to launch browser for %.*s", MAX_PATH, unixpath);
1651         }
1652 }
1653
1654 int link(const char *oldpath, const char *newpath)
1655 {
1656         typedef BOOL (WINAPI *T)(const char*, const char*, LPSECURITY_ATTRIBUTES);
1657         static T create_hard_link = NULL;
1658         if (!create_hard_link) {
1659                 create_hard_link = (T) GetProcAddress(
1660                         GetModuleHandle("kernel32.dll"), "CreateHardLinkA");
1661                 if (!create_hard_link)
1662                         create_hard_link = (T)-1;
1663         }
1664         if (create_hard_link == (T)-1) {
1665                 errno = ENOSYS;
1666                 return -1;
1667         }
1668         if (!create_hard_link(newpath, oldpath, NULL)) {
1669                 errno = err_win_to_posix(GetLastError());
1670                 return -1;
1671         }
1672         return 0;
1673 }
1674
1675 char *getpass(const char *prompt)
1676 {
1677         struct strbuf buf = STRBUF_INIT;
1678
1679         fputs(prompt, stderr);
1680         for (;;) {
1681                 char c = _getch();
1682                 if (c == '\r' || c == '\n')
1683                         break;
1684                 strbuf_addch(&buf, c);
1685         }
1686         fputs("\n", stderr);
1687         return strbuf_detach(&buf, NULL);
1688 }
1689
1690 pid_t waitpid(pid_t pid, int *status, unsigned options)
1691 {
1692         HANDLE h = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION,
1693             FALSE, pid);
1694         if (!h) {
1695                 errno = ECHILD;
1696                 return -1;
1697         }
1698
1699         if (pid > 0 && options & WNOHANG) {
1700                 if (WAIT_OBJECT_0 != WaitForSingleObject(h, 0)) {
1701                         CloseHandle(h);
1702                         return 0;
1703                 }
1704                 options &= ~WNOHANG;
1705         }
1706
1707         if (options == 0) {
1708                 struct pinfo_t **ppinfo;
1709                 if (WaitForSingleObject(h, INFINITE) != WAIT_OBJECT_0) {
1710                         CloseHandle(h);
1711                         return 0;
1712                 }
1713
1714                 if (status)
1715                         GetExitCodeProcess(h, (LPDWORD)status);
1716
1717                 EnterCriticalSection(&pinfo_cs);
1718
1719                 ppinfo = &pinfo;
1720                 while (*ppinfo) {
1721                         struct pinfo_t *info = *ppinfo;
1722                         if (info->pid == pid) {
1723                                 CloseHandle(info->proc);
1724                                 *ppinfo = info->next;
1725                                 free(info);
1726                                 break;
1727                         }
1728                         ppinfo = &info->next;
1729                 }
1730
1731                 LeaveCriticalSection(&pinfo_cs);
1732
1733                 CloseHandle(h);
1734                 return pid;
1735         }
1736         CloseHandle(h);
1737
1738         errno = EINVAL;
1739         return -1;
1740 }