Andrew's git - gitweb.git/blob

7f89a6cb87e4457c8ff017b25d4736732455aaa1
   1#include "../git-compat-util.h"
   2
   3unsigned int _CRT_fmode = _O_BINARY;
   4
   5#undef open
   6int mingw_open (const char *filename, int oflags, ...)
   7{
   8        va_list args;
   9        unsigned mode;
  10        va_start(args, oflags);
  11        mode = va_arg(args, int);
  12        va_end(args);
  13
  14        if (!strcmp(filename, "/dev/null"))
  15                filename = "nul";
  16        int fd = open(filename, oflags, mode);
  17        if (fd < 0 && (oflags & O_CREAT) && errno == EACCES) {
  18                DWORD attrs = GetFileAttributes(filename);
  19                if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY))
  20                        errno = EISDIR;
  21        }
  22        return fd;
  23}
  24
  25unsigned int sleep (unsigned int seconds)
  26{
  27        Sleep(seconds*1000);
  28        return 0;
  29}
  30
  31int mkstemp(char *template)
  32{
  33        char *filename = mktemp(template);
  34        if (filename == NULL)
  35                return -1;
  36        return open(filename, O_RDWR | O_CREAT, 0600);
  37}
  38
  39int gettimeofday(struct timeval *tv, void *tz)
  40{
  41        SYSTEMTIME st;
  42        struct tm tm;
  43        GetSystemTime(&st);
  44        tm.tm_year = st.wYear-1900;
  45        tm.tm_mon = st.wMonth-1;
  46        tm.tm_mday = st.wDay;
  47        tm.tm_hour = st.wHour;
  48        tm.tm_min = st.wMinute;
  49        tm.tm_sec = st.wSecond;
  50        tv->tv_sec = tm_to_time_t(&tm);
  51        if (tv->tv_sec < 0)
  52                return -1;
  53        tv->tv_usec = st.wMilliseconds*1000;
  54        return 0;
  55}
  56
  57int pipe(int filedes[2])
  58{
  59        int fd;
  60        HANDLE h[2], parent;
  61
  62        if (_pipe(filedes, 8192, 0) < 0)
  63                return -1;
  64
  65        parent = GetCurrentProcess();
  66
  67        if (!DuplicateHandle (parent, (HANDLE)_get_osfhandle(filedes[0]),
  68                        parent, &h[0], 0, FALSE, DUPLICATE_SAME_ACCESS)) {
  69                close(filedes[0]);
  70                close(filedes[1]);
  71                return -1;
  72        }
  73        if (!DuplicateHandle (parent, (HANDLE)_get_osfhandle(filedes[1]),
  74                        parent, &h[1], 0, FALSE, DUPLICATE_SAME_ACCESS)) {
  75                close(filedes[0]);
  76                close(filedes[1]);
  77                CloseHandle(h[0]);
  78                return -1;
  79        }
  80        fd = _open_osfhandle((int)h[0], O_NOINHERIT);
  81        if (fd < 0) {
  82                close(filedes[0]);
  83                close(filedes[1]);
  84                CloseHandle(h[0]);
  85                CloseHandle(h[1]);
  86                return -1;
  87        }
  88        close(filedes[0]);
  89        filedes[0] = fd;
  90        fd = _open_osfhandle((int)h[1], O_NOINHERIT);
  91        if (fd < 0) {
  92                close(filedes[0]);
  93                close(filedes[1]);
  94                CloseHandle(h[1]);
  95                return -1;
  96        }
  97        close(filedes[1]);
  98        filedes[1] = fd;
  99        return 0;
 100}
 101
 102int poll(struct pollfd *ufds, unsigned int nfds, int timeout)
 103{
 104        return -1;
 105}
 106
 107struct tm *gmtime_r(const time_t *timep, struct tm *result)
 108{
 109        /* gmtime() in MSVCRT.DLL is thread-safe, but not reentrant */
 110        memcpy(result, gmtime(timep), sizeof(struct tm));
 111        return result;
 112}
 113
 114struct tm *localtime_r(const time_t *timep, struct tm *result)
 115{
 116        /* localtime() in MSVCRT.DLL is thread-safe, but not reentrant */
 117        memcpy(result, localtime(timep), sizeof(struct tm));
 118        return result;
 119}
 120
 121#undef getcwd
 122char *mingw_getcwd(char *pointer, int len)
 123{
 124        int i;
 125        char *ret = getcwd(pointer, len);
 126        if (!ret)
 127                return ret;
 128        for (i = 0; pointer[i]; i++)
 129                if (pointer[i] == '\\')
 130                        pointer[i] = '/';
 131        return ret;
 132}
 133
 134static const char *parse_interpreter(const char *cmd)
 135{
 136        static char buf[100];
 137        char *p, *opt;
 138        int n, fd;
 139
 140        /* don't even try a .exe */
 141        n = strlen(cmd);
 142        if (n >= 4 && !strcasecmp(cmd+n-4, ".exe"))
 143                return NULL;
 144
 145        fd = open(cmd, O_RDONLY);
 146        if (fd < 0)
 147                return NULL;
 148        n = read(fd, buf, sizeof(buf)-1);
 149        close(fd);
 150        if (n < 4)      /* at least '#!/x' and not error */
 151                return NULL;
 152
 153        if (buf[0] != '#' || buf[1] != '!')
 154                return NULL;
 155        buf[n] = '\0';
 156        p = strchr(buf, '\n');
 157        if (!p)
 158                return NULL;
 159
 160        *p = '\0';
 161        if (!(p = strrchr(buf+2, '/')) && !(p = strrchr(buf+2, '\\')))
 162                return NULL;
 163        /* strip options */
 164        if ((opt = strchr(p+1, ' ')))
 165                *opt = '\0';
 166        return p+1;
 167}
 168
 169/*
 170 * Splits the PATH into parts.
 171 */
 172static char **get_path_split(void)
 173{
 174        char *p, **path, *envpath = getenv("PATH");
 175        int i, n = 0;
 176
 177        if (!envpath || !*envpath)
 178                return NULL;
 179
 180        envpath = xstrdup(envpath);
 181        p = envpath;
 182        while (p) {
 183                char *dir = p;
 184                p = strchr(p, ';');
 185                if (p) *p++ = '\0';
 186                if (*dir) {     /* not earlier, catches series of ; */
 187                        ++n;
 188                }
 189        }
 190        if (!n)
 191                return NULL;
 192
 193        path = xmalloc((n+1)*sizeof(char*));
 194        p = envpath;
 195        i = 0;
 196        do {
 197                if (*p)
 198                        path[i++] = xstrdup(p);
 199                p = p+strlen(p)+1;
 200        } while (i < n);
 201        path[i] = NULL;
 202
 203        free(envpath);
 204
 205        return path;
 206}
 207
 208static void free_path_split(char **path)
 209{
 210        if (!path)
 211                return;
 212
 213        char **p = path;
 214        while (*p)
 215                free(*p++);
 216        free(path);
 217}
 218
 219/*
 220 * exe_only means that we only want to detect .exe files, but not scripts
 221 * (which do not have an extension)
 222 */
 223static char *lookup_prog(const char *dir, const char *cmd, int isexe, int exe_only)
 224{
 225        char path[MAX_PATH];
 226        snprintf(path, sizeof(path), "%s/%s.exe", dir, cmd);
 227
 228        if (!isexe && access(path, F_OK) == 0)
 229                return xstrdup(path);
 230        path[strlen(path)-4] = '\0';
 231        if ((!exe_only || isexe) && access(path, F_OK) == 0)
 232                return xstrdup(path);
 233        return NULL;
 234}
 235
 236/*
 237 * Determines the absolute path of cmd using the the split path in path.
 238 * If cmd contains a slash or backslash, no lookup is performed.
 239 */
 240static char *path_lookup(const char *cmd, char **path, int exe_only)
 241{
 242        char *prog = NULL;
 243        int len = strlen(cmd);
 244        int isexe = len >= 4 && !strcasecmp(cmd+len-4, ".exe");
 245
 246        if (strchr(cmd, '/') || strchr(cmd, '\\'))
 247                prog = xstrdup(cmd);
 248
 249        while (!prog && *path)
 250                prog = lookup_prog(*path++, cmd, isexe, exe_only);
 251
 252        return prog;
 253}
 254
 255static int try_shell_exec(const char *cmd, char *const *argv, char **env)
 256{
 257        const char *interpr = parse_interpreter(cmd);
 258        char **path;
 259        char *prog;
 260        int pid = 0;
 261
 262        if (!interpr)
 263                return 0;
 264        path = get_path_split();
 265        prog = path_lookup(interpr, path, 1);
 266        if (prog) {
 267                int argc = 0;
 268                const char **argv2;
 269                while (argv[argc]) argc++;
 270                argv2 = xmalloc(sizeof(*argv) * (argc+2));
 271                argv2[0] = (char *)interpr;
 272                argv2[1] = (char *)cmd; /* full path to the script file */
 273                memcpy(&argv2[2], &argv[1], sizeof(*argv) * argc);
 274                pid = spawnve(_P_NOWAIT, prog, argv2, (const char **)env);
 275                if (pid >= 0) {
 276                        int status;
 277                        if (waitpid(pid, &status, 0) < 0)
 278                                status = 255;
 279                        exit(status);
 280                }
 281                pid = 1;        /* indicate that we tried but failed */
 282                free(prog);
 283                free(argv2);
 284        }
 285        free_path_split(path);
 286        return pid;
 287}
 288
 289static void mingw_execve(const char *cmd, char *const *argv, char *const *env)
 290{
 291        /* check if git_command is a shell script */
 292        if (!try_shell_exec(cmd, argv, (char **)env)) {
 293                int pid, status;
 294
 295                pid = spawnve(_P_NOWAIT, cmd, (const char **)argv, (const char **)env);
 296                if (pid < 0)
 297                        return;
 298                if (waitpid(pid, &status, 0) < 0)
 299                        status = 255;
 300                exit(status);
 301        }
 302}
 303
 304void mingw_execvp(const char *cmd, char *const *argv)
 305{
 306        char **path = get_path_split();
 307        char *prog = path_lookup(cmd, path, 0);
 308
 309        if (prog) {
 310                mingw_execve(prog, argv, environ);
 311                free(prog);
 312        } else
 313                errno = ENOENT;
 314
 315        free_path_split(path);
 316}
 317
 318char **copy_environ()
 319{
 320        char **env;
 321        int i = 0;
 322        while (environ[i])
 323                i++;
 324        env = xmalloc((i+1)*sizeof(*env));
 325        for (i = 0; environ[i]; i++)
 326                env[i] = xstrdup(environ[i]);
 327        env[i] = NULL;
 328        return env;
 329}
 330
 331void free_environ(char **env)
 332{
 333        int i;
 334        for (i = 0; env[i]; i++)
 335                free(env[i]);
 336        free(env);
 337}
 338
 339static int lookup_env(char **env, const char *name, size_t nmln)
 340{
 341        int i;
 342
 343        for (i = 0; env[i]; i++) {
 344                if (0 == strncmp(env[i], name, nmln)
 345                    && '=' == env[i][nmln])
 346                        /* matches */
 347                        return i;
 348        }
 349        return -1;
 350}
 351
 352/*
 353 * If name contains '=', then sets the variable, otherwise it unsets it
 354 */
 355char **env_setenv(char **env, const char *name)
 356{
 357        char *eq = strchrnul(name, '=');
 358        int i = lookup_env(env, name, eq-name);
 359
 360        if (i < 0) {
 361                if (*eq) {
 362                        for (i = 0; env[i]; i++)
 363                                ;
 364                        env = xrealloc(env, (i+2)*sizeof(*env));
 365                        env[i] = xstrdup(name);
 366                        env[i+1] = NULL;
 367                }
 368        }
 369        else {
 370                free(env[i]);
 371                if (*eq)
 372                        env[i] = xstrdup(name);
 373                else
 374                        for (; env[i]; i++)
 375                                env[i] = env[i+1];
 376        }
 377        return env;
 378}
 379
 380#undef rename
 381int mingw_rename(const char *pold, const char *pnew)
 382{
 383        /*
 384         * Try native rename() first to get errno right.
 385         * It is based on MoveFile(), which cannot overwrite existing files.
 386         */
 387        if (!rename(pold, pnew))
 388                return 0;
 389        if (errno != EEXIST)
 390                return -1;
 391        if (MoveFileEx(pold, pnew, MOVEFILE_REPLACE_EXISTING))
 392                return 0;
 393        /* TODO: translate more errors */
 394        if (GetLastError() == ERROR_ACCESS_DENIED) {
 395                DWORD attrs = GetFileAttributes(pnew);
 396                if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY)) {
 397                        errno = EISDIR;
 398                        return -1;
 399                }
 400        }
 401        errno = EACCES;
 402        return -1;
 403}
 404
 405struct passwd *getpwuid(int uid)
 406{
 407        static char user_name[100];
 408        static struct passwd p;
 409
 410        DWORD len = sizeof(user_name);
 411        if (!GetUserName(user_name, &len))
 412                return NULL;
 413        p.pw_name = user_name;
 414        p.pw_gecos = "unknown";
 415        p.pw_dir = NULL;
 416        return &p;
 417}
 418
 419static HANDLE timer_event;
 420static HANDLE timer_thread;
 421static int timer_interval;
 422static int one_shot;
 423static sig_handler_t timer_fn = SIG_DFL;
 424
 425/* The timer works like this:
 426 * The thread, ticktack(), is a trivial routine that most of the time
 427 * only waits to receive the signal to terminate. The main thread tells
 428 * the thread to terminate by setting the timer_event to the signalled
 429 * state.
 430 * But ticktack() interrupts the wait state after the timer's interval
 431 * length to call the signal handler.
 432 */
 433
 434static __stdcall unsigned ticktack(void *dummy)
 435{
 436        while (WaitForSingleObject(timer_event, timer_interval) == WAIT_TIMEOUT) {
 437                if (timer_fn == SIG_DFL)
 438                        die("Alarm");
 439                if (timer_fn != SIG_IGN)
 440                        timer_fn(SIGALRM);
 441                if (one_shot)
 442                        break;
 443        }
 444        return 0;
 445}
 446
 447static int start_timer_thread(void)
 448{
 449        timer_event = CreateEvent(NULL, FALSE, FALSE, NULL);
 450        if (timer_event) {
 451                timer_thread = (HANDLE) _beginthreadex(NULL, 0, ticktack, NULL, 0, NULL);
 452                if (!timer_thread )
 453                        return errno = ENOMEM,
 454                                error("cannot start timer thread");
 455        } else
 456                return errno = ENOMEM,
 457                        error("cannot allocate resources for timer");
 458        return 0;
 459}
 460
 461static void stop_timer_thread(void)
 462{
 463        if (timer_event)
 464                SetEvent(timer_event);  /* tell thread to terminate */
 465        if (timer_thread) {
 466                int rc = WaitForSingleObject(timer_thread, 1000);
 467                if (rc == WAIT_TIMEOUT)
 468                        error("timer thread did not terminate timely");
 469                else if (rc != WAIT_OBJECT_0)
 470                        error("waiting for timer thread failed: %lu",
 471                              GetLastError());
 472                CloseHandle(timer_thread);
 473        }
 474        if (timer_event)
 475                CloseHandle(timer_event);
 476        timer_event = NULL;
 477        timer_thread = NULL;
 478}
 479
 480static inline int is_timeval_eq(const struct timeval *i1, const struct timeval *i2)
 481{
 482        return i1->tv_sec == i2->tv_sec && i1->tv_usec == i2->tv_usec;
 483}
 484
 485int setitimer(int type, struct itimerval *in, struct itimerval *out)
 486{
 487        static const struct timeval zero;
 488        static int atexit_done;
 489
 490        if (out != NULL)
 491                return errno = EINVAL,
 492                        error("setitimer param 3 != NULL not implemented");
 493        if (!is_timeval_eq(&in->it_interval, &zero) &&
 494            !is_timeval_eq(&in->it_interval, &in->it_value))
 495                return errno = EINVAL,
 496                        error("setitimer: it_interval must be zero or eq it_value");
 497
 498        if (timer_thread)
 499                stop_timer_thread();
 500
 501        if (is_timeval_eq(&in->it_value, &zero) &&
 502            is_timeval_eq(&in->it_interval, &zero))
 503                return 0;
 504
 505        timer_interval = in->it_value.tv_sec * 1000 + in->it_value.tv_usec / 1000;
 506        one_shot = is_timeval_eq(&in->it_interval, &zero);
 507        if (!atexit_done) {
 508                atexit(stop_timer_thread);
 509                atexit_done = 1;
 510        }
 511        return start_timer_thread();
 512}
 513
 514int sigaction(int sig, struct sigaction *in, struct sigaction *out)
 515{
 516        if (sig != SIGALRM)
 517                return errno = EINVAL,
 518                        error("sigaction only implemented for SIGALRM");
 519        if (out != NULL)
 520                return errno = EINVAL,
 521                        error("sigaction: param 3 != NULL not implemented");
 522
 523        timer_fn = in->sa_handler;
 524        return 0;
 525}
 526
 527#undef signal
 528sig_handler_t mingw_signal(int sig, sig_handler_t handler)
 529{
 530        if (sig != SIGALRM)
 531                return signal(sig, handler);
 532        sig_handler_t old = timer_fn;
 533        timer_fn = handler;
 534        return old;
 535}