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