Andrew's git - gitweb.git/blob

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