Andrew's git - gitweb.git/blob

89b29c55e5371c8ebeaa9d9003a24b3ac18a58de
   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 poll(struct pollfd *ufds, unsigned int nfds, int timeout)
  58{
  59        return -1;
  60}
  61
  62struct tm *gmtime_r(const time_t *timep, struct tm *result)
  63{
  64        /* gmtime() in MSVCRT.DLL is thread-safe, but not reentrant */
  65        memcpy(result, gmtime(timep), sizeof(struct tm));
  66        return result;
  67}
  68
  69struct tm *localtime_r(const time_t *timep, struct tm *result)
  70{
  71        /* localtime() in MSVCRT.DLL is thread-safe, but not reentrant */
  72        memcpy(result, localtime(timep), sizeof(struct tm));
  73        return result;
  74}
  75
  76#undef getcwd
  77char *mingw_getcwd(char *pointer, int len)
  78{
  79        int i;
  80        char *ret = getcwd(pointer, len);
  81        if (!ret)
  82                return ret;
  83        for (i = 0; pointer[i]; i++)
  84                if (pointer[i] == '\\')
  85                        pointer[i] = '/';
  86        return ret;
  87}
  88
  89static const char *parse_interpreter(const char *cmd)
  90{
  91        static char buf[100];
  92        char *p, *opt;
  93        int n, fd;
  94
  95        /* don't even try a .exe */
  96        n = strlen(cmd);
  97        if (n >= 4 && !strcasecmp(cmd+n-4, ".exe"))
  98                return NULL;
  99
 100        fd = open(cmd, O_RDONLY);
 101        if (fd < 0)
 102                return NULL;
 103        n = read(fd, buf, sizeof(buf)-1);
 104        close(fd);
 105        if (n < 4)      /* at least '#!/x' and not error */
 106                return NULL;
 107
 108        if (buf[0] != '#' || buf[1] != '!')
 109                return NULL;
 110        buf[n] = '\0';
 111        p = strchr(buf, '\n');
 112        if (!p)
 113                return NULL;
 114
 115        *p = '\0';
 116        if (!(p = strrchr(buf+2, '/')) && !(p = strrchr(buf+2, '\\')))
 117                return NULL;
 118        /* strip options */
 119        if ((opt = strchr(p+1, ' ')))
 120                *opt = '\0';
 121        return p+1;
 122}
 123
 124/*
 125 * Splits the PATH into parts.
 126 */
 127static char **get_path_split(void)
 128{
 129        char *p, **path, *envpath = getenv("PATH");
 130        int i, n = 0;
 131
 132        if (!envpath || !*envpath)
 133                return NULL;
 134
 135        envpath = xstrdup(envpath);
 136        p = envpath;
 137        while (p) {
 138                char *dir = p;
 139                p = strchr(p, ';');
 140                if (p) *p++ = '\0';
 141                if (*dir) {     /* not earlier, catches series of ; */
 142                        ++n;
 143                }
 144        }
 145        if (!n)
 146                return NULL;
 147
 148        path = xmalloc((n+1)*sizeof(char*));
 149        p = envpath;
 150        i = 0;
 151        do {
 152                if (*p)
 153                        path[i++] = xstrdup(p);
 154                p = p+strlen(p)+1;
 155        } while (i < n);
 156        path[i] = NULL;
 157
 158        free(envpath);
 159
 160        return path;
 161}
 162
 163static void free_path_split(char **path)
 164{
 165        if (!path)
 166                return;
 167
 168        char **p = path;
 169        while (*p)
 170                free(*p++);
 171        free(path);
 172}
 173
 174/*
 175 * exe_only means that we only want to detect .exe files, but not scripts
 176 * (which do not have an extension)
 177 */
 178static char *lookup_prog(const char *dir, const char *cmd, int isexe, int exe_only)
 179{
 180        char path[MAX_PATH];
 181        snprintf(path, sizeof(path), "%s/%s.exe", dir, cmd);
 182
 183        if (!isexe && access(path, F_OK) == 0)
 184                return xstrdup(path);
 185        path[strlen(path)-4] = '\0';
 186        if ((!exe_only || isexe) && access(path, F_OK) == 0)
 187                return xstrdup(path);
 188        return NULL;
 189}
 190
 191/*
 192 * Determines the absolute path of cmd using the the split path in path.
 193 * If cmd contains a slash or backslash, no lookup is performed.
 194 */
 195static char *path_lookup(const char *cmd, char **path, int exe_only)
 196{
 197        char *prog = NULL;
 198        int len = strlen(cmd);
 199        int isexe = len >= 4 && !strcasecmp(cmd+len-4, ".exe");
 200
 201        if (strchr(cmd, '/') || strchr(cmd, '\\'))
 202                prog = xstrdup(cmd);
 203
 204        while (!prog && *path)
 205                prog = lookup_prog(*path++, cmd, isexe, exe_only);
 206
 207        return prog;
 208}
 209
 210static int try_shell_exec(const char *cmd, char *const *argv, char **env)
 211{
 212        const char *interpr = parse_interpreter(cmd);
 213        char **path;
 214        char *prog;
 215        int pid = 0;
 216
 217        if (!interpr)
 218                return 0;
 219        path = get_path_split();
 220        prog = path_lookup(interpr, path, 1);
 221        if (prog) {
 222                int argc = 0;
 223                const char **argv2;
 224                while (argv[argc]) argc++;
 225                argv2 = xmalloc(sizeof(*argv) * (argc+2));
 226                argv2[0] = (char *)interpr;
 227                argv2[1] = (char *)cmd; /* full path to the script file */
 228                memcpy(&argv2[2], &argv[1], sizeof(*argv) * argc);
 229                pid = spawnve(_P_NOWAIT, prog, argv2, (const char **)env);
 230                if (pid >= 0) {
 231                        int status;
 232                        if (waitpid(pid, &status, 0) < 0)
 233                                status = 255;
 234                        exit(status);
 235                }
 236                pid = 1;        /* indicate that we tried but failed */
 237                free(prog);
 238                free(argv2);
 239        }
 240        free_path_split(path);
 241        return pid;
 242}
 243
 244static void mingw_execve(const char *cmd, char *const *argv, char *const *env)
 245{
 246        /* check if git_command is a shell script */
 247        if (!try_shell_exec(cmd, argv, (char **)env)) {
 248                int pid, status;
 249
 250                pid = spawnve(_P_NOWAIT, cmd, (const char **)argv, (const char **)env);
 251                if (pid < 0)
 252                        return;
 253                if (waitpid(pid, &status, 0) < 0)
 254                        status = 255;
 255                exit(status);
 256        }
 257}
 258
 259void mingw_execvp(const char *cmd, char *const *argv)
 260{
 261        char **path = get_path_split();
 262        char *prog = path_lookup(cmd, path, 0);
 263
 264        if (prog) {
 265                mingw_execve(prog, argv, environ);
 266                free(prog);
 267        } else
 268                errno = ENOENT;
 269
 270        free_path_split(path);
 271}
 272
 273#undef rename
 274int mingw_rename(const char *pold, const char *pnew)
 275{
 276        /*
 277         * Try native rename() first to get errno right.
 278         * It is based on MoveFile(), which cannot overwrite existing files.
 279         */
 280        if (!rename(pold, pnew))
 281                return 0;
 282        if (errno != EEXIST)
 283                return -1;
 284        if (MoveFileEx(pold, pnew, MOVEFILE_REPLACE_EXISTING))
 285                return 0;
 286        /* TODO: translate more errors */
 287        if (GetLastError() == ERROR_ACCESS_DENIED) {
 288                DWORD attrs = GetFileAttributes(pnew);
 289                if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY)) {
 290                        errno = EISDIR;
 291                        return -1;
 292                }
 293        }
 294        errno = EACCES;
 295        return -1;
 296}
 297
 298struct passwd *getpwuid(int uid)
 299{
 300        static char user_name[100];
 301        static struct passwd p;
 302
 303        DWORD len = sizeof(user_name);
 304        if (!GetUserName(user_name, &len))
 305                return NULL;
 306        p.pw_name = user_name;
 307        p.pw_gecos = "unknown";
 308        p.pw_dir = NULL;
 309        return &p;
 310}
 311
 312static HANDLE timer_event;
 313static HANDLE timer_thread;
 314static int timer_interval;
 315static int one_shot;
 316static sig_handler_t timer_fn = SIG_DFL;
 317
 318/* The timer works like this:
 319 * The thread, ticktack(), is a trivial routine that most of the time
 320 * only waits to receive the signal to terminate. The main thread tells
 321 * the thread to terminate by setting the timer_event to the signalled
 322 * state.
 323 * But ticktack() interrupts the wait state after the timer's interval
 324 * length to call the signal handler.
 325 */
 326
 327static __stdcall unsigned ticktack(void *dummy)
 328{
 329        while (WaitForSingleObject(timer_event, timer_interval) == WAIT_TIMEOUT) {
 330                if (timer_fn == SIG_DFL)
 331                        die("Alarm");
 332                if (timer_fn != SIG_IGN)
 333                        timer_fn(SIGALRM);
 334                if (one_shot)
 335                        break;
 336        }
 337        return 0;
 338}
 339
 340static int start_timer_thread(void)
 341{
 342        timer_event = CreateEvent(NULL, FALSE, FALSE, NULL);
 343        if (timer_event) {
 344                timer_thread = (HANDLE) _beginthreadex(NULL, 0, ticktack, NULL, 0, NULL);
 345                if (!timer_thread )
 346                        return errno = ENOMEM,
 347                                error("cannot start timer thread");
 348        } else
 349                return errno = ENOMEM,
 350                        error("cannot allocate resources for timer");
 351        return 0;
 352}
 353
 354static void stop_timer_thread(void)
 355{
 356        if (timer_event)
 357                SetEvent(timer_event);  /* tell thread to terminate */
 358        if (timer_thread) {
 359                int rc = WaitForSingleObject(timer_thread, 1000);
 360                if (rc == WAIT_TIMEOUT)
 361                        error("timer thread did not terminate timely");
 362                else if (rc != WAIT_OBJECT_0)
 363                        error("waiting for timer thread failed: %lu",
 364                              GetLastError());
 365                CloseHandle(timer_thread);
 366        }
 367        if (timer_event)
 368                CloseHandle(timer_event);
 369        timer_event = NULL;
 370        timer_thread = NULL;
 371}
 372
 373static inline int is_timeval_eq(const struct timeval *i1, const struct timeval *i2)
 374{
 375        return i1->tv_sec == i2->tv_sec && i1->tv_usec == i2->tv_usec;
 376}
 377
 378int setitimer(int type, struct itimerval *in, struct itimerval *out)
 379{
 380        static const struct timeval zero;
 381        static int atexit_done;
 382
 383        if (out != NULL)
 384                return errno = EINVAL,
 385                        error("setitimer param 3 != NULL not implemented");
 386        if (!is_timeval_eq(&in->it_interval, &zero) &&
 387            !is_timeval_eq(&in->it_interval, &in->it_value))
 388                return errno = EINVAL,
 389                        error("setitimer: it_interval must be zero or eq it_value");
 390
 391        if (timer_thread)
 392                stop_timer_thread();
 393
 394        if (is_timeval_eq(&in->it_value, &zero) &&
 395            is_timeval_eq(&in->it_interval, &zero))
 396                return 0;
 397
 398        timer_interval = in->it_value.tv_sec * 1000 + in->it_value.tv_usec / 1000;
 399        one_shot = is_timeval_eq(&in->it_interval, &zero);
 400        if (!atexit_done) {
 401                atexit(stop_timer_thread);
 402                atexit_done = 1;
 403        }
 404        return start_timer_thread();
 405}
 406
 407int sigaction(int sig, struct sigaction *in, struct sigaction *out)
 408{
 409        if (sig != SIGALRM)
 410                return errno = EINVAL,
 411                        error("sigaction only implemented for SIGALRM");
 412        if (out != NULL)
 413                return errno = EINVAL,
 414                        error("sigaction: param 3 != NULL not implemented");
 415
 416        timer_fn = in->sa_handler;
 417        return 0;
 418}
 419
 420#undef signal
 421sig_handler_t mingw_signal(int sig, sig_handler_t handler)
 422{
 423        if (sig != SIGALRM)
 424                return signal(sig, handler);
 425        sig_handler_t old = timer_fn;
 426        timer_fn = handler;
 427        return old;
 428}