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