[thirdparty/git.git] / compat / mingw.c

#include "../git-compat-util.h"

unsigned int _CRT_fmode = _O_BINARY;

#undef open
int mingw_open (const char *filename, int oflags, ...)
{
	va_list args;
	unsigned mode;
	va_start(args, oflags);
	mode = va_arg(args, int);
	va_end(args);

	if (!strcmp(filename, "/dev/null"))
		filename = "nul";
	int fd = open(filename, oflags, mode);
	if (fd < 0 && (oflags & O_CREAT) && errno == EACCES) {
		DWORD attrs = GetFileAttributes(filename);
		if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY))
			errno = EISDIR;
	}
	return fd;
}

unsigned int sleep (unsigned int seconds)
{
	Sleep(seconds*1000);
	return 0;
}

int mkstemp(char *template)
{
	char *filename = mktemp(template);
	if (filename == NULL)
		return -1;
	return open(filename, O_RDWR | O_CREAT, 0600);
}

int gettimeofday(struct timeval *tv, void *tz)
{
	SYSTEMTIME st;
	struct tm tm;
	GetSystemTime(&st);
	tm.tm_year = st.wYear-1900;
	tm.tm_mon = st.wMonth-1;
	tm.tm_mday = st.wDay;
	tm.tm_hour = st.wHour;
	tm.tm_min = st.wMinute;
	tm.tm_sec = st.wSecond;
	tv->tv_sec = tm_to_time_t(&tm);
	if (tv->tv_sec < 0)
		return -1;
	tv->tv_usec = st.wMilliseconds*1000;
	return 0;
}

int pipe(int filedes[2])
{
	int fd;
	HANDLE h[2], parent;

	if (_pipe(filedes, 8192, 0) < 0)
		return -1;

	parent = GetCurrentProcess();

	if (!DuplicateHandle (parent, (HANDLE)_get_osfhandle(filedes[0]),
			parent, &h[0], 0, FALSE, DUPLICATE_SAME_ACCESS)) {
		close(filedes[0]);
		close(filedes[1]);
		return -1;
	}
	if (!DuplicateHandle (parent, (HANDLE)_get_osfhandle(filedes[1]),
			parent, &h[1], 0, FALSE, DUPLICATE_SAME_ACCESS)) {
		close(filedes[0]);
		close(filedes[1]);
		CloseHandle(h[0]);
		return -1;
	}
	fd = _open_osfhandle((int)h[0], O_NOINHERIT);
	if (fd < 0) {
		close(filedes[0]);
		close(filedes[1]);
		CloseHandle(h[0]);
		CloseHandle(h[1]);
		return -1;
	}
	close(filedes[0]);
	filedes[0] = fd;
	fd = _open_osfhandle((int)h[1], O_NOINHERIT);
	if (fd < 0) {
		close(filedes[0]);
		close(filedes[1]);
		CloseHandle(h[1]);
		return -1;
	}
	close(filedes[1]);
	filedes[1] = fd;
	return 0;
}

int poll(struct pollfd *ufds, unsigned int nfds, int timeout)
{
	int i, pending;

	if (timeout != -1)
		return errno = EINVAL, error("poll timeout not supported");

	/* When there is only one fd to wait for, then we pretend that
	 * input is available and let the actual wait happen when the
	 * caller invokes read().
	 */
	if (nfds == 1) {
		if (!(ufds[0].events & POLLIN))
			return errno = EINVAL, error("POLLIN not set");
		ufds[0].revents = POLLIN;
		return 0;
	}

repeat:
	pending = 0;
	for (i = 0; i < nfds; i++) {
		DWORD avail = 0;
		HANDLE h = (HANDLE) _get_osfhandle(ufds[i].fd);
		if (h == INVALID_HANDLE_VALUE)
			return -1;	/* errno was set */

		if (!(ufds[i].events & POLLIN))
			return errno = EINVAL, error("POLLIN not set");

		/* this emulation works only for pipes */
		if (!PeekNamedPipe(h, NULL, 0, NULL, &avail, NULL)) {
			int err = GetLastError();
			if (err == ERROR_BROKEN_PIPE) {
				ufds[i].revents = POLLHUP;
				pending++;
			} else {
				errno = EINVAL;
				return error("PeekNamedPipe failed,"
					" GetLastError: %u", err);
			}
		} else if (avail) {
			ufds[i].revents = POLLIN;
			pending++;
		} else
			ufds[i].revents = 0;
	}
	if (!pending) {
		/* The only times that we spin here is when the process
		 * that is connected through the pipes is waiting for
		 * its own input data to become available. But since
		 * the process (pack-objects) is itself CPU intensive,
		 * it will happily pick up the time slice that we are
		 * relinguishing here.
		 */
		Sleep(0);
		goto repeat;
	}
	return 0;
}

struct tm *gmtime_r(const time_t *timep, struct tm *result)
{
	/* gmtime() in MSVCRT.DLL is thread-safe, but not reentrant */
	memcpy(result, gmtime(timep), sizeof(struct tm));
	return result;
}

struct tm *localtime_r(const time_t *timep, struct tm *result)
{
	/* localtime() in MSVCRT.DLL is thread-safe, but not reentrant */
	memcpy(result, localtime(timep), sizeof(struct tm));
	return result;
}

#undef getcwd
char *mingw_getcwd(char *pointer, int len)
{
	int i;
	char *ret = getcwd(pointer, len);
	if (!ret)
		return ret;
	for (i = 0; pointer[i]; i++)
		if (pointer[i] == '\\')
			pointer[i] = '/';
	return ret;
}

static const char *parse_interpreter(const char *cmd)
{
	static char buf[100];
	char *p, *opt;
	int n, fd;

	/* don't even try a .exe */
	n = strlen(cmd);
	if (n >= 4 && !strcasecmp(cmd+n-4, ".exe"))
		return NULL;

	fd = open(cmd, O_RDONLY);
	if (fd < 0)
		return NULL;
	n = read(fd, buf, sizeof(buf)-1);
	close(fd);
	if (n < 4)	/* at least '#!/x' and not error */
		return NULL;

	if (buf[0] != '#' || buf[1] != '!')
		return NULL;
	buf[n] = '\0';
	p = strchr(buf, '\n');
	if (!p)
		return NULL;

	*p = '\0';
	if (!(p = strrchr(buf+2, '/')) && !(p = strrchr(buf+2, '\\')))
		return NULL;
	/* strip options */
	if ((opt = strchr(p+1, ' ')))
		*opt = '\0';
	return p+1;
}

/*
 * Splits the PATH into parts.
 */
static char **get_path_split(void)
{
	char *p, **path, *envpath = getenv("PATH");
	int i, n = 0;

	if (!envpath || !*envpath)
		return NULL;

	envpath = xstrdup(envpath);
	p = envpath;
	while (p) {
		char *dir = p;
		p = strchr(p, ';');
		if (p) *p++ = '\0';
		if (*dir) {	/* not earlier, catches series of ; */
			++n;
		}
	}
	if (!n)
		return NULL;

	path = xmalloc((n+1)*sizeof(char*));
	p = envpath;
	i = 0;
	do {
		if (*p)
			path[i++] = xstrdup(p);
		p = p+strlen(p)+1;
	} while (i < n);
	path[i] = NULL;

	free(envpath);

	return path;
}

static void free_path_split(char **path)
{
	if (!path)
		return;

	char **p = path;
	while (*p)
		free(*p++);
	free(path);
}

/*
 * exe_only means that we only want to detect .exe files, but not scripts
 * (which do not have an extension)
 */
static char *lookup_prog(const char *dir, const char *cmd, int isexe, int exe_only)
{
	char path[MAX_PATH];
	snprintf(path, sizeof(path), "%s/%s.exe", dir, cmd);

	if (!isexe && access(path, F_OK) == 0)
		return xstrdup(path);
	path[strlen(path)-4] = '\0';
	if ((!exe_only || isexe) && access(path, F_OK) == 0)
		return xstrdup(path);
	return NULL;
}

/*
 * Determines the absolute path of cmd using the the split path in path.
 * If cmd contains a slash or backslash, no lookup is performed.
 */
static char *path_lookup(const char *cmd, char **path, int exe_only)
{
	char *prog = NULL;
	int len = strlen(cmd);
	int isexe = len >= 4 && !strcasecmp(cmd+len-4, ".exe");

	if (strchr(cmd, '/') || strchr(cmd, '\\'))
		prog = xstrdup(cmd);

	while (!prog && *path)
		prog = lookup_prog(*path++, cmd, isexe, exe_only);

	return prog;
}

static int try_shell_exec(const char *cmd, char *const *argv, char **env)
{
	const char *interpr = parse_interpreter(cmd);
	char **path;
	char *prog;
	int pid = 0;

	if (!interpr)
		return 0;
	path = get_path_split();
	prog = path_lookup(interpr, path, 1);
	if (prog) {
		int argc = 0;
		const char **argv2;
		while (argv[argc]) argc++;
		argv2 = xmalloc(sizeof(*argv) * (argc+2));
		argv2[0] = (char *)interpr;
		argv2[1] = (char *)cmd;	/* full path to the script file */
		memcpy(&argv2[2], &argv[1], sizeof(*argv) * argc);
		pid = spawnve(_P_NOWAIT, prog, argv2, (const char **)env);
		if (pid >= 0) {
			int status;
			if (waitpid(pid, &status, 0) < 0)
				status = 255;
			exit(status);
		}
		pid = 1;	/* indicate that we tried but failed */
		free(prog);
		free(argv2);
	}
	free_path_split(path);
	return pid;
}

static void mingw_execve(const char *cmd, char *const *argv, char *const *env)
{
	/* check if git_command is a shell script */
	if (!try_shell_exec(cmd, argv, (char **)env)) {
		int pid, status;

		pid = spawnve(_P_NOWAIT, cmd, (const char **)argv, (const char **)env);
		if (pid < 0)
			return;
		if (waitpid(pid, &status, 0) < 0)
			status = 255;
		exit(status);
	}
}

void mingw_execvp(const char *cmd, char *const *argv)
{
	char **path = get_path_split();
	char *prog = path_lookup(cmd, path, 0);

	if (prog) {
		mingw_execve(prog, argv, environ);
		free(prog);
	} else
		errno = ENOENT;

	free_path_split(path);
}

char **copy_environ()
{
	char **env;
	int i = 0;
	while (environ[i])
		i++;
	env = xmalloc((i+1)*sizeof(*env));
	for (i = 0; environ[i]; i++)
		env[i] = xstrdup(environ[i]);
	env[i] = NULL;
	return env;
}

void free_environ(char **env)
{
	int i;
	for (i = 0; env[i]; i++)
		free(env[i]);
	free(env);
}

static int lookup_env(char **env, const char *name, size_t nmln)
{
	int i;

	for (i = 0; env[i]; i++) {
		if (0 == strncmp(env[i], name, nmln)
		    && '=' == env[i][nmln])
			/* matches */
			return i;
	}
	return -1;
}

/*
 * If name contains '=', then sets the variable, otherwise it unsets it
 */
char **env_setenv(char **env, const char *name)
{
	char *eq = strchrnul(name, '=');
	int i = lookup_env(env, name, eq-name);

	if (i < 0) {
		if (*eq) {
			for (i = 0; env[i]; i++)
				;
			env = xrealloc(env, (i+2)*sizeof(*env));
			env[i] = xstrdup(name);
			env[i+1] = NULL;
		}
	}
	else {
		free(env[i]);
		if (*eq)
			env[i] = xstrdup(name);
		else
			for (; env[i]; i++)
				env[i] = env[i+1];
	}
	return env;
}

#undef rename
int mingw_rename(const char *pold, const char *pnew)
{
	/*
	 * Try native rename() first to get errno right.
	 * It is based on MoveFile(), which cannot overwrite existing files.
	 */
	if (!rename(pold, pnew))
		return 0;
	if (errno != EEXIST)
		return -1;
	if (MoveFileEx(pold, pnew, MOVEFILE_REPLACE_EXISTING))
		return 0;
	/* TODO: translate more errors */
	if (GetLastError() == ERROR_ACCESS_DENIED) {
		DWORD attrs = GetFileAttributes(pnew);
		if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY)) {
			errno = EISDIR;
			return -1;
		}
	}
	errno = EACCES;
	return -1;
}

struct passwd *getpwuid(int uid)
{
	static char user_name[100];
	static struct passwd p;

	DWORD len = sizeof(user_name);
	if (!GetUserName(user_name, &len))
		return NULL;
	p.pw_name = user_name;
	p.pw_gecos = "unknown";
	p.pw_dir = NULL;
	return &p;
}

static HANDLE timer_event;
static HANDLE timer_thread;
static int timer_interval;
static int one_shot;
static sig_handler_t timer_fn = SIG_DFL;

/* The timer works like this:
 * The thread, ticktack(), is a trivial routine that most of the time
 * only waits to receive the signal to terminate. The main thread tells
 * the thread to terminate by setting the timer_event to the signalled
 * state.
 * But ticktack() interrupts the wait state after the timer's interval
 * length to call the signal handler.
 */

static __stdcall unsigned ticktack(void *dummy)
{
	while (WaitForSingleObject(timer_event, timer_interval) == WAIT_TIMEOUT) {
		if (timer_fn == SIG_DFL)
			die("Alarm");
		if (timer_fn != SIG_IGN)
			timer_fn(SIGALRM);
		if (one_shot)
			break;
	}
	return 0;
}

static int start_timer_thread(void)
{
	timer_event = CreateEvent(NULL, FALSE, FALSE, NULL);
	if (timer_event) {
		timer_thread = (HANDLE) _beginthreadex(NULL, 0, ticktack, NULL, 0, NULL);
		if (!timer_thread )
			return errno = ENOMEM,
				error("cannot start timer thread");
	} else
		return errno = ENOMEM,
			error("cannot allocate resources for timer");
	return 0;
}

static void stop_timer_thread(void)
{
	if (timer_event)
		SetEvent(timer_event);	/* tell thread to terminate */
	if (timer_thread) {
		int rc = WaitForSingleObject(timer_thread, 1000);
		if (rc == WAIT_TIMEOUT)
			error("timer thread did not terminate timely");
		else if (rc != WAIT_OBJECT_0)
			error("waiting for timer thread failed: %lu",
			      GetLastError());
		CloseHandle(timer_thread);
	}
	if (timer_event)
		CloseHandle(timer_event);
	timer_event = NULL;
	timer_thread = NULL;
}

static inline int is_timeval_eq(const struct timeval *i1, const struct timeval *i2)
{
	return i1->tv_sec == i2->tv_sec && i1->tv_usec == i2->tv_usec;
}

int setitimer(int type, struct itimerval *in, struct itimerval *out)
{
	static const struct timeval zero;
	static int atexit_done;

	if (out != NULL)
		return errno = EINVAL,
			error("setitimer param 3 != NULL not implemented");
	if (!is_timeval_eq(&in->it_interval, &zero) &&
	    !is_timeval_eq(&in->it_interval, &in->it_value))
		return errno = EINVAL,
			error("setitimer: it_interval must be zero or eq it_value");

	if (timer_thread)
		stop_timer_thread();

	if (is_timeval_eq(&in->it_value, &zero) &&
	    is_timeval_eq(&in->it_interval, &zero))
		return 0;

	timer_interval = in->it_value.tv_sec * 1000 + in->it_value.tv_usec / 1000;
	one_shot = is_timeval_eq(&in->it_interval, &zero);
	if (!atexit_done) {
		atexit(stop_timer_thread);
		atexit_done = 1;
	}
	return start_timer_thread();
}

int sigaction(int sig, struct sigaction *in, struct sigaction *out)
{
	if (sig != SIGALRM)
		return errno = EINVAL,
			error("sigaction only implemented for SIGALRM");
	if (out != NULL)
		return errno = EINVAL,
			error("sigaction: param 3 != NULL not implemented");

	timer_fn = in->sa_handler;
	return 0;
}

#undef signal
sig_handler_t mingw_signal(int sig, sig_handler_t handler)
{
	if (sig != SIGALRM)
		return signal(sig, handler);
	sig_handler_t old = timer_fn;
	timer_fn = handler;
	return old;
}
Commit	Line	Data
f4626df5 JS	1	#include "../git-compat-util.h"
	2
	3	unsigned int _CRT_fmode = _O_BINARY;
	4
3e4a1ba0 JS	5	#undef open
	6	int 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
f4626df5 JS	25	unsigned int sleep (unsigned int seconds)
	26	{
	27	Sleep(seconds*1000);
	28	return 0;
	29	}
	30
	31	int 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
	39	int gettimeofday(struct timeval tv, void tz)
	40	{
a42a0c2e JS	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;
f4626df5 JS	55	}
f4626df5 JS	56
897bb8cb JS	57	int 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
f4626df5 JS	102	int poll(struct pollfd *ufds, unsigned int nfds, int timeout)
f4626df5 JS	103	{
6ed807f8 JS	104	int i, pending;
	105
	106	if (timeout != -1)
	107	return errno = EINVAL, error("poll timeout not supported");
	108
	109	/* When there is only one fd to wait for, then we pretend that
	110	* input is available and let the actual wait happen when the
	111	* caller invokes read().
	112	*/
	113	if (nfds == 1) {
	114	if (!(ufds[0].events & POLLIN))
	115	return errno = EINVAL, error("POLLIN not set");
	116	ufds[0].revents = POLLIN;
	117	return 0;
	118	}
	119
	120	repeat:
	121	pending = 0;
	122	for (i = 0; i < nfds; i++) {
	123	DWORD avail = 0;
	124	HANDLE h = (HANDLE) _get_osfhandle(ufds[i].fd);
	125	if (h == INVALID_HANDLE_VALUE)
	126	return -1; /* errno was set */
	127
	128	if (!(ufds[i].events & POLLIN))
	129	return errno = EINVAL, error("POLLIN not set");
	130
	131	/* this emulation works only for pipes */
	132	if (!PeekNamedPipe(h, NULL, 0, NULL, &avail, NULL)) {
	133	int err = GetLastError();
	134	if (err == ERROR_BROKEN_PIPE) {
	135	ufds[i].revents = POLLHUP;
	136	pending++;
	137	} else {
	138	errno = EINVAL;
	139	return error("PeekNamedPipe failed,"
	140	" GetLastError: %u", err);
	141	}
	142	} else if (avail) {
	143	ufds[i].revents = POLLIN;
	144	pending++;
	145	} else
	146	ufds[i].revents = 0;
	147	}
	148	if (!pending) {
	149	/* The only times that we spin here is when the process
	150	* that is connected through the pipes is waiting for
	151	* its own input data to become available. But since
	152	* the process (pack-objects) is itself CPU intensive,
	153	* it will happily pick up the time slice that we are
	154	* relinguishing here.
	155	*/
	156	Sleep(0);
	157	goto repeat;
	158	}
	159	return 0;
f4626df5 JS	160	}
	161
	162	struct tm gmtime_r(const time_t timep, struct tm *result)
	163	{
	164	/* gmtime() in MSVCRT.DLL is thread-safe, but not reentrant */
	165	memcpy(result, gmtime(timep), sizeof(struct tm));
	166	return result;
	167	}
	168
	169	struct tm localtime_r(const time_t timep, struct tm *result)
	170	{
	171	/* localtime() in MSVCRT.DLL is thread-safe, but not reentrant */
	172	memcpy(result, localtime(timep), sizeof(struct tm));
	173	return result;
	174	}
	175
25fe217b JS	176	#undef getcwd
	177	char mingw_getcwd(char pointer, int len)
	178	{
	179	int i;
	180	char *ret = getcwd(pointer, len);
	181	if (!ret)
	182	return ret;
	183	for (i = 0; pointer[i]; i++)
	184	if (pointer[i] == '\\')
	185	pointer[i] = '/';
	186	return ret;
	187	}
	188
f1a4dfb8 JS	189	static const char parse_interpreter(const char cmd)
	190	{
	191	static char buf[100];
	192	char p, opt;
	193	int n, fd;
	194
	195	/* don't even try a .exe */
	196	n = strlen(cmd);
	197	if (n >= 4 && !strcasecmp(cmd+n-4, ".exe"))
	198	return NULL;
	199
	200	fd = open(cmd, O_RDONLY);
	201	if (fd < 0)
	202	return NULL;
	203	n = read(fd, buf, sizeof(buf)-1);
	204	close(fd);
	205	if (n < 4) /* at least '#!/x' and not error */
	206	return NULL;
	207
	208	if (buf[0] != '#' \|\| buf[1] != '!')
	209	return NULL;
	210	buf[n] = '\0';
	211	p = strchr(buf, '\n');
	212	if (!p)
	213	return NULL;
	214
	215	*p = '\0';
	216	if (!(p = strrchr(buf+2, '/')) && !(p = strrchr(buf+2, '\\')))
	217	return NULL;
	218	/* strip options */
	219	if ((opt = strchr(p+1, ' ')))
	220	*opt = '\0';
	221	return p+1;
	222	}
	223
	224	/*
	225	* Splits the PATH into parts.
	226	*/
	227	static char **get_path_split(void)
	228	{
	229	char p, path, envpath = getenv("PATH");
	230	int i, n = 0;
	231
	232	if (!envpath \|\| !*envpath)
	233	return NULL;
	234
	235	envpath = xstrdup(envpath);
	236	p = envpath;
	237	while (p) {
	238	char *dir = p;
	239	p = strchr(p, ';');
	240	if (p) *p++ = '\0';
	241	if (dir) { / not earlier, catches series of ; */
	242	++n;
	243	}
	244	}
	245	if (!n)
	246	return NULL;
	247
	248	path = xmalloc((n+1)sizeof(char));
	249	p = envpath;
	250	i = 0;
	251	do {
	252	if (*p)
253	path[i++] = xstrdup(p);
254	p = p+strlen(p)+1;
255	} while (i < n);
256	path[i] = NULL;
257
258	free(envpath);
259
260	return path;
261	}
262
263	static void free_path_split(char **path)
264	{
265	if (!path)
266	return;
267
268	char **p = path;
269	while (*p)
270	free(*p++);
271	free(path);
272	}
273
274	/*
275	* exe_only means that we only want to detect .exe files, but not scripts
276	* (which do not have an extension)
277	*/
278	static char lookup_prog(const char dir, const char *cmd, int isexe, int exe_only)
279	{
280	char path[MAX_PATH];
281	snprintf(path, sizeof(path), "%s/%s.exe", dir, cmd);
282
283	if (!isexe && access(path, F_OK) == 0)
284	return xstrdup(path);
285	path[strlen(path)-4] = '\0';
286	if ((!exe_only \|\| isexe) && access(path, F_OK) == 0)
287	return xstrdup(path);
288	return NULL;
289	}
290
291	/*
292	* Determines the absolute path of cmd using the the split path in path.
293	* If cmd contains a slash or backslash, no lookup is performed.
294	*/
295	static char path_lookup(const char cmd, char **path, int exe_only)
296	{
297	char *prog = NULL;
298	int len = strlen(cmd);
299	int isexe = len >= 4 && !strcasecmp(cmd+len-4, ".exe");
300
301	if (strchr(cmd, '/') \|\| strchr(cmd, '\\'))
302	prog = xstrdup(cmd);
303
304	while (!prog && *path)
305	prog = lookup_prog(*path++, cmd, isexe, exe_only);
306
307	return prog;
308	}
309
310	static int try_shell_exec(const char cmd, char const argv, char *env)
311	{
312	const char *interpr = parse_interpreter(cmd);
313	char **path;
314	char *prog;
315	int pid = 0;
316
317	if (!interpr)
318	return 0;
319	path = get_path_split();
320	prog = path_lookup(interpr, path, 1);
321	if (prog) {
322	int argc = 0;
323	const char **argv2;
324	while (argv[argc]) argc++;
325	argv2 = xmalloc(sizeof(argv) (argc+2));
326	argv2[0] = (char *)interpr;
327	argv2[1] = (char )cmd; / full path to the script file */
328	memcpy(&argv2[2], &argv[1], sizeof(argv) argc);
329	pid = spawnve(_P_NOWAIT, prog, argv2, (const char **)env);
330	if (pid >= 0) {
331	int status;
332	if (waitpid(pid, &status, 0) < 0)
333	status = 255;
334	exit(status);
335	}
336	pid = 1; /* indicate that we tried but failed */
337	free(prog);
338	free(argv2);
339	}
340	free_path_split(path);
341	return pid;
342	}
343
344	static void mingw_execve(const char cmd, char const argv, char const *env)
345	{
346	/* check if git_command is a shell script */
347	if (!try_shell_exec(cmd, argv, (char **)env)) {
348	int pid, status;
349
350	pid = spawnve(_P_NOWAIT, cmd, (const char )argv, (const char )env);
351	if (pid < 0)
352	return;
353	if (waitpid(pid, &status, 0) < 0)
354	status = 255;
355	exit(status);
356	}
357	}
358
359	void mingw_execvp(const char cmd, char const *argv)
360	{
361	char **path = get_path_split();
362	char *prog = path_lookup(cmd, path, 0);
363
364	if (prog) {
365	mingw_execve(prog, argv, environ);
366	free(prog);
367	} else
368	errno = ENOENT;
369
370	free_path_split(path);
371	}
372
ba26f296 JS	373	char **copy_environ()
	374	{
	375	char **env;
	376	int i = 0;
	377	while (environ[i])
	378	i++;
	379	env = xmalloc((i+1)sizeof(env));
	380	for (i = 0; environ[i]; i++)
	381	env[i] = xstrdup(environ[i]);
	382	env[i] = NULL;
	383	return env;
	384	}
	385
	386	void free_environ(char **env)
	387	{
	388	int i;
	389	for (i = 0; env[i]; i++)
	390	free(env[i]);
	391	free(env);
	392	}
	393
	394	static int lookup_env(char *env, const char name, size_t nmln)
	395	{
	396	int i;
	397
	398	for (i = 0; env[i]; i++) {
	399	if (0 == strncmp(env[i], name, nmln)
	400	&& '=' == env[i][nmln])
	401	/* matches */
	402	return i;
	403	}
	404	return -1;
	405	}
	406
	407	/*
	408	* If name contains '=', then sets the variable, otherwise it unsets it
	409	*/
	410	char env_setenv(char env, const char *name)
	411	{
	412	char *eq = strchrnul(name, '=');
	413	int i = lookup_env(env, name, eq-name);
	414
	415	if (i < 0) {
	416	if (*eq) {
	417	for (i = 0; env[i]; i++)
	418	;
	419	env = xrealloc(env, (i+2)sizeof(env));
	420	env[i] = xstrdup(name);
	421	env[i+1] = NULL;
	422	}
	423	}
	424	else {
	425	free(env[i]);
	426	if (*eq)
	427	env[i] = xstrdup(name);
	428	else
	429	for (; env[i]; i++)
	430	env[i] = env[i+1];
	431	}
	432	return env;
	433	}
	434
ea9e98c3 JS	435	#undef rename
	436	int mingw_rename(const char pold, const char pnew)
	437	{
	438	/*
	439	* Try native rename() first to get errno right.
	440	* It is based on MoveFile(), which cannot overwrite existing files.
	441	*/
	442	if (!rename(pold, pnew))
	443	return 0;
	444	if (errno != EEXIST)
	445	return -1;
	446	if (MoveFileEx(pold, pnew, MOVEFILE_REPLACE_EXISTING))
	447	return 0;
	448	/* TODO: translate more errors */
	449	if (GetLastError() == ERROR_ACCESS_DENIED) {
	450	DWORD attrs = GetFileAttributes(pnew);
	451	if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY)) {
	452	errno = EISDIR;
	453	return -1;
	454	}
	455	}
	456	errno = EACCES;
	457	return -1;
	458	}
	459
f4626df5 JS	460	struct passwd *getpwuid(int uid)
f4626df5 JS	461	{
f7597aca	462	static char user_name[100];
f4626df5	463	static struct passwd p;
f7597aca JS	464
	465	DWORD len = sizeof(user_name);
	466	if (!GetUserName(user_name, &len))
	467	return NULL;
	468	p.pw_name = user_name;
	469	p.pw_gecos = "unknown";
	470	p.pw_dir = NULL;
f4626df5 JS	471	return &p;
	472	}
	473
6072fc31 JS	474	static HANDLE timer_event;
	475	static HANDLE timer_thread;
	476	static int timer_interval;
	477	static int one_shot;
	478	static sig_handler_t timer_fn = SIG_DFL;
	479
	480	/* The timer works like this:
	481	* The thread, ticktack(), is a trivial routine that most of the time
	482	* only waits to receive the signal to terminate. The main thread tells
	483	* the thread to terminate by setting the timer_event to the signalled
	484	* state.
	485	* But ticktack() interrupts the wait state after the timer's interval
	486	* length to call the signal handler.
	487	*/
	488
	489	static __stdcall unsigned ticktack(void *dummy)
	490	{
	491	while (WaitForSingleObject(timer_event, timer_interval) == WAIT_TIMEOUT) {
	492	if (timer_fn == SIG_DFL)
	493	die("Alarm");
	494	if (timer_fn != SIG_IGN)
	495	timer_fn(SIGALRM);
	496	if (one_shot)
	497	break;
	498	}
	499	return 0;
	500	}
	501
	502	static int start_timer_thread(void)
	503	{
	504	timer_event = CreateEvent(NULL, FALSE, FALSE, NULL);
	505	if (timer_event) {
	506	timer_thread = (HANDLE) _beginthreadex(NULL, 0, ticktack, NULL, 0, NULL);
	507	if (!timer_thread )
	508	return errno = ENOMEM,
	509	error("cannot start timer thread");
	510	} else
	511	return errno = ENOMEM,
	512	error("cannot allocate resources for timer");
	513	return 0;
	514	}
	515
	516	static void stop_timer_thread(void)
	517	{
	518	if (timer_event)
	519	SetEvent(timer_event); /* tell thread to terminate */
	520	if (timer_thread) {
	521	int rc = WaitForSingleObject(timer_thread, 1000);
	522	if (rc == WAIT_TIMEOUT)
	523	error("timer thread did not terminate timely");
	524	else if (rc != WAIT_OBJECT_0)
	525	error("waiting for timer thread failed: %lu",
	526	GetLastError());
	527	CloseHandle(timer_thread);
	528	}
	529	if (timer_event)
	530	CloseHandle(timer_event);
	531	timer_event = NULL;
	532	timer_thread = NULL;
	533	}
	534
	535	static inline int is_timeval_eq(const struct timeval i1, const struct timeval i2)
	536	{
	537	return i1->tv_sec == i2->tv_sec && i1->tv_usec == i2->tv_usec;
538	}
539
f4626df5 JS	540	int setitimer(int type, struct itimerval in, struct itimerval out)
f4626df5 JS	541	{
6072fc31 JS	542	static const struct timeval zero;
	543	static int atexit_done;
	544
	545	if (out != NULL)
	546	return errno = EINVAL,
	547	error("setitimer param 3 != NULL not implemented");
	548	if (!is_timeval_eq(&in->it_interval, &zero) &&
	549	!is_timeval_eq(&in->it_interval, &in->it_value))
	550	return errno = EINVAL,
	551	error("setitimer: it_interval must be zero or eq it_value");
	552
	553	if (timer_thread)
	554	stop_timer_thread();
	555
	556	if (is_timeval_eq(&in->it_value, &zero) &&
	557	is_timeval_eq(&in->it_interval, &zero))
	558	return 0;
	559
	560	timer_interval = in->it_value.tv_sec * 1000 + in->it_value.tv_usec / 1000;
	561	one_shot = is_timeval_eq(&in->it_interval, &zero);
	562	if (!atexit_done) {
	563	atexit(stop_timer_thread);
	564	atexit_done = 1;
	565	}
	566	return start_timer_thread();
f4626df5 JS	567	}
	568
	569	int sigaction(int sig, struct sigaction in, struct sigaction out)
	570	{
6072fc31 JS	571	if (sig != SIGALRM)
	572	return errno = EINVAL,
	573	error("sigaction only implemented for SIGALRM");
	574	if (out != NULL)
	575	return errno = EINVAL,
	576	error("sigaction: param 3 != NULL not implemented");
	577
	578	timer_fn = in->sa_handler;
	579	return 0;
	580	}
	581
	582	#undef signal
	583	sig_handler_t mingw_signal(int sig, sig_handler_t handler)
	584	{
	585	if (sig != SIGALRM)
	586	return signal(sig, handler);
	587	sig_handler_t old = timer_fn;
	588	timer_fn = handler;
	589	return old;
f4626df5	590	}