[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 poll(struct pollfd *ufds, unsigned int nfds, int timeout)
{
	return -1;
}

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);
}

#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	}
	56
	57	int poll(struct pollfd *ufds, unsigned int nfds, int timeout)
	58	{
	59	return -1;
	60	}
	61
	62	struct 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
	69	struct 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
25fe217b JS	76	#undef getcwd
	77	char 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
f1a4dfb8 JS	89	static 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	*/
	127	static 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
163	static 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	*/
178	static 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	*/
195	static 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
210	static 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
244	static 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
259	void 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
ea9e98c3 JS	273	#undef rename
	274	int 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
f4626df5 JS	298	struct passwd *getpwuid(int uid)
f4626df5 JS	299	{
f7597aca	300	static char user_name[100];
f4626df5	301	static struct passwd p;
f7597aca JS	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;
f4626df5 JS	309	return &p;
	310	}
	311
6072fc31 JS	312	static HANDLE timer_event;
	313	static HANDLE timer_thread;
	314	static int timer_interval;
	315	static int one_shot;
	316	static 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
	327	static __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
	340	static 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
	354	static 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
	373	static 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
f4626df5 JS	378	int setitimer(int type, struct itimerval in, struct itimerval out)
f4626df5 JS	379	{
6072fc31 JS	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();
f4626df5 JS	405	}
	406
	407	int sigaction(int sig, struct sigaction in, struct sigaction out)
	408	{
6072fc31 JS	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
	421	sig_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;
f4626df5	428	}