warp.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1998-2012 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                 Eclipse Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*          http://www.eclipse.org/org/documents/epl-v10.html           *
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <[email protected]>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * Glenn Fowler
 * AT&T Research
 *
 * time related system call intercept
 * the env var WARP controls the seconds offset added to each time_t
 * and the time progression factor
 */

static const char id[] = "\n@(#)$Id: warp (AT&T Research) 2012-06-22 $\0\n";

#if defined(_SCO_C_DIALECT) || defined(_SCO_ELF) || defined(_SCO_XPG_VERS)
#define _NO_STATIC	1
#define _WARP_stat32	1
#endif

#if defined(__STDPP__directive) && defined(__STDPP__hide)
__STDPP__directive pragma pp:hide alarm _alarm __alarm clock_gettime _clock_gettime __clock_gettime gettimeofday _gettimeofday __gettimeofday getitimer _getitimer __getitimer poll _poll __poll select _select __select setitimer _setitimer __setitimer time times utime _utime __utime utimensat _utimensat __utimensat utimes _utimes __utimes utimets _utimets __utimets fstat64 lstat64
__STDPP__directive pragma pp:hide execlp _execlp __execlp execve _execve __execve execvp _execvp __execvp execvpe _execvpe __execvpe
#else
#define alarm		______alarm
#define _alarm		_______alarm
#define __alarm		________alarm
#define clock_gettime	______clock_gettime
#define _clock_gettime	_______clock_gettime
#define __clock_gettime	________clock_gettime
#define gettimeofday	______gettimeofday
#define _gettimeofday	_______gettimeofday
#define __gettimeofday	________gettimeofday
#define getitimer	______getitimer
#define _getitimer	_______getitimer
#define __getitimer	________getitimer
#define poll		______poll
#define _poll		_______poll
#define __poll		________poll
#define select		______select
#define _select		_______select
#define __select	________select
#define setitimer	______setitimer
#define _setitimer	_______setitimer
#define __setitimer	________setitimer
#define time		______time
#define times		______times
#define utime		______utime
#define _utime		_______utime
#define __utime		________utime
#define utimes		______utimes
#define _utimes		_______utimes
#define __utimes	________utimes
#define utimensat	______utimensat
#define _utimensat	_______utimensat
#define __utimensat	________utimensat
#define utimets		______utimets
#define _utimets	_______utimets
#define __utimets	________utimets
#define fstat64		______fstat64
#define lstat64		______lstat64
#define execlp		______execlp
#define _execlp		_______execlp
#define __execlp	________execlp
#define execve		______execve
#define _execve		_______execve
#define __execve	________execve
#define execvp		______execvp
#define _execvp		_______execvp
#define __execvp	________execvp
#define execvpe		______execvpe
#define _execvpe	_______execvpe
#define __execvpe	________execvpe
#endif

#ifdef __EXPORT__
#define extern	__EXPORT__
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#undef	extern
#endif

#include <ast.h>
#include <dlldefs.h>
#include <ls.h>
#include <times.h>

#include "FEATURE/lib"

#if _hdr_utime
#include <utime.h>
#else
struct utimbuf
{
	time_t		actime;
	time_t		modtime;
};
#endif

#if !_typ_struct_timespec
struct timespec
{
	time_t		tv_sec;
	time_t		tv_nsec;
};
#endif

#if defined(__STDPP__directive) && defined(__STDPP__hide)
__STDPP__directive pragma pp:nohide alarm _alarm __alarm clock_gettime _clock_gettime __clock_gettime gettimeofday _gettimeofday __gettimeofday getitimer _getitimer __getitimer poll _poll __poll select _select __select setitimer _setitimer __setitimer time times utime _utime __utime utimensat _utimensat __utimensat utimes _utimes __utimes utimets _utimets __utimets fstat64 lstat64
__STDPP__directive pragma pp:nohide execlp _execlp __execlp execve _execve __execve execvp _execvp __execvp execvpe _execvpe __execvpe
#else
#undef	alarm
#undef	_alarm
#undef	__alarm
#undef	clock_gettime
#undef	_clock_gettime
#undef	__clock_gettime
#undef	gettimeofday
#undef	_gettimeofday
#undef	__gettimeofday
#undef	getitimer
#undef	_getitimer
#undef	__getitimer
#undef	poll
#undef	_poll
#undef	__poll
#undef	select
#undef	_select
#undef	__select
#undef	setitimer
#undef	_setitimer
#undef	__setitimer
#undef	time
#undef	times
#undef	utime
#undef	_utime
#undef	__utime
#undef	utimensat
#undef	_utimensat
#undef	__utimensat
#undef	utimes
#undef	_utimes
#undef	__utimes
#undef	fstat64
#undef	lstat64
#undef	execlp
#undef	_execlp
#undef	__execlp
#undef	execve
#undef	_execve
#undef	__execve
#undef	execvp
#undef	_execvp
#undef	__execvp
#undef	execvpe
#undef	_execvpe
#undef	__execvpe
#endif

#ifdef __EXPORT__
#define extern	__EXPORT__
#endif

#if defined(LINUX_STAT_VERSION) && !defined(_STAT_VER)
#define _STAT_VER	LINUX_STAT_VERSION
#endif

#undef	fstat
#undef	lstat
#undef	stat

typedef void* (*Syscall_f)(void*);

typedef unsigned int (*Alarm_f)(unsigned int);
typedef int (*Gettimeofday_f)(struct timeval*, void*);
typedef int (*Poll_f)(void*, int, int);
typedef int (*Select_f)(int, void*, void*, void*, const struct timeval*);
typedef time_t (*Time_f)(time_t*);
typedef clock_t (*Times_f)(struct tms*);
typedef int (*Utime_f)(const char*, const struct utimbuf*);
typedef int (*Utimensat_f)(int, const char*, const struct timespec*, int);
typedef int (*Utimes_f)(const char*, const struct timeval*);
typedef int (*Utimets_f)(const char*, const struct timespec*);

typedef int (*Close_f)(int);
typedef int (*Execlp_f)(const char*, const char*, ...);
typedef int (*Execve_f)(const char*, char* const[], char* const[]);
typedef int (*Execvp_f)(const char*, char* const[]);
typedef int (*Execvpe_f)(const char*, char* const[], char* const[]);

#if defined(_STAT_VER)
typedef int (*Xstat_f)(int, const char*, struct stat*);
typedef int (*Fxstat_f)(const int, int, struct stat*);
typedef int (*Lxstat_f)(const int, const char*, struct stat*);
#if defined(_lib__xstat64) || defined(_lib___xstat64)
typedef int (*Xstat64_f)(int, const char*, struct stat64*);
typedef int (*Fxstat64_f)(const int, int, struct stat64*);
typedef int (*Lxstat64_f)(const int, const char*, struct stat64*);
#endif
#else
typedef int (*Fstat_f)(int, struct stat*);
typedef int (*Lstat_f)(const char*, struct stat*);
typedef int (*Stat_f)(const char*, struct stat*);
#endif

#if defined(_lib_stat64)
typedef int (*Fstat64_f)(int, struct stat64*);
typedef int (*Lstat64_f)(const char*, struct stat64*);
typedef int (*Stat64_f)(const char*, struct stat64*);
#endif

#if _lib_clock_gettime
typedef int (*Clock_gettime_f)(int, struct timespec*);
#endif

#if _lib_getitimer
typedef int (*Getitimer_f)(int, struct itimerval*);
#endif

#if _lib_setitimer
typedef int (*Setitimer_f)(int, const struct itimerval*, struct itimerval*);
#endif

#define WARP_ABS(t)	((t)+=(t)?(state.warp+(state.factor?mix((t)-state.base):0)):0)
#define UNWARP_ABS(t)	((t)=(t)?(((t)-state.warp)/(state.factor+1)+state.base/(state.factor+1)*state.factor):0)

#define WARP_REL(t)	((t)=(t)?(state.factor?mix(t):(t)):0)
#define UNWARP_REL(t)	((t)=(t)?(state.factor?((t)/state.factor):(t)):0)

typedef struct
{
	const char*	name;
	const char*	mangled;
	Syscall_f	call;
	int		warped;
	unsigned long	level;
} Call_t;

static struct
{
	long		base;
	void*		dll;
	long		factor;
	unsigned long	level;
	unsigned long	mix;
	int		trace;
	long		warp;
	char*		env[32];
} state;

#ifndef environ
extern char**		environ;
#endif

/*
 * synthesize the low order seconds in s
 * under the influence of a warp factor
 */

static unsigned long
mix(unsigned long s)
{
	state.mix = state.mix * 0x63c63cd9L + 0x9c39c33dL;
	return s * state.factor + state.mix % state.factor;
}

/*
 * initialize the warp environment
 * and intercept call p
 */

static void
intercept(register Call_t* p)
{
	register int		c;
	register char*		s;
	register long		n;
	register int		v;
	char*			o;

	static const char	msg[] = "warp: panic: dllnext() failed\n";

	if (p->warped)
		return;
	if (!state.dll)
	{
#ifdef __EXPORT__
		o = getenv("WARP");
#else
		register char**	e;
		register char**	p;
		register char**	x;
		char*		t;

		e = environ;
if (!e) { s = "warp: AHA: no env\n"; write(2, s, strlen(s)); }
		p = state.env;
		x = &state.env[elementsof(state.env) - 1];
		o = 0;
		while (s = *e++)
		{
			switch (s[0])
			{
			case 'L':
				if (s[1] != 'D' || s[2] != '_' || s[3] != 'P' || s[4] != 'R' || s[5] != 'E' || s[6] != 'L' || s[7] != 'O' || s[8] != 'A' || s[9] != 'D' || s[10] != '=')
					continue;
				break;
			case 'W':
				if (s[1] != 'A' || s[2] != 'R' || s[3] != 'P' || s[4] != '=')
					continue;
				o = s + 5;
				break;
			case '_':
				if (s[1] != 'R' || s[2] != 'L' || s[3] != 'D' || s[4] != '_' && s[4] != 'N')
					continue;
				break;
			default:
				continue;
			}
			if (p >= x)
				break;
			if (!(t = malloc(strlen(s) + 1)))
			{
				s = "warp: out of space [env]\n";
				write(2, s, strlen(s));
				_exit(125);
			}
			*p++ = strcpy(t, s);
		}
#endif
		if (s = o)
		{
			v = 'w';
			for (;;)
			{
				switch (*s++)
				{
				case 0:
					break;
				case ' ':
				case '\t':
				case '-':
				case '+':
					v = 'w';
					continue;
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					s--;
					c = s > o && *(s - 1) == '-';
					n = 0;
					while (*s >= '0' && *s <= '9')
						n = n * 10 + *s++ - '0';
					if (n)
					{
						if (c)
							n = -n;
						switch (v)
						{
						case 'b':
							state.base = n;
							break;
						case 'f':
							state.factor = n;
							break;
						case 'w':
							state.warp = n;
							break;
						}
						v = 'w';
					}
					continue;
				case 't':
					state.trace = 1;
					continue;
				default:
					v = *(s - 1);
					continue;
				}
				break;
			}
			if (state.trace)
			{
				write(2, id + 10, strlen(id + 10));
				write(2, " ", 1);
				write(2, o, strlen(o));
				write(2, "\n", 1);
			}
		}
		if (state.factor == 1)
			state.factor = 0;
		state.mix = state.base;
		if (!(state.dll = dllnext(RTLD_LAZY)))
		{
			write(2, msg, sizeof(msg) - 1);
			exit(2);
		}
	}
	if (!p->call && !(p->call = (Syscall_f)dlsym(state.dll, p->mangled)))
	{
		write(2, "warp: ", 6);
		write(2, p->mangled, strlen(p->mangled));
		write(2, ": cannot intercept\n", 1);
		exit(2);
	}
	if (state.trace)
	{
		write(2, "warp: ", 6);
		write(2, p->mangled, strlen(p->mangled));
		write(2, "\n", 1);
	}
	p->level = ++state.level;
}

static unsigned int
warp_alarm(register Call_t* p, unsigned int s)
{
	unsigned int	r;

	intercept(p);
	if (p->warped || !state.factor)
		return (*(Alarm_f)p->call)(s);
	UNWARP_REL(s);
	r = (*(Alarm_f)p->call)(s);
	if (p->level != state.level)
		p->warped = 1;
	else
		WARP_REL(r);
	return r;
}

extern unsigned int
alarm(unsigned int sec)
{
	static Call_t	call = { "alarm", "alarm" };

	return warp_alarm(&call, sec);
}

#ifndef __EXPORT__

extern unsigned int
_alarm(unsigned int sec)
{
	static Call_t	call = { "alarm", "_alarm" };

	return warp_alarm(&call, sec);
}

extern unsigned int
__alarm(unsigned int sec)
{
	static Call_t	call = { "alarm", "__alarm" };

	return warp_alarm(&call, sec);
}

extern unsigned int
_libc_alarm(unsigned int sec)
{
	static Call_t	call = { "alarm", "_libc_alarm" };

	return warp_alarm(&call, sec);
}

extern unsigned int
__libc_alarm(unsigned int sec)
{
	static Call_t	call = { "alarm", "__libc_alarm" };

	return warp_alarm(&call, sec);
}

#endif

static int
warp_gettimeofday(register Call_t* p, struct timeval* tv, void* tz)
{
	int	r;

	intercept(p);
	if ((r = (*(Gettimeofday_f)p->call)(tv, tz)) != -1 && !p->warped)
	{
		if (p->level != state.level)
			p->warped = 1;
		else if (tv)
			WARP_ABS(tv->tv_sec);
	}
	return r;
}

extern int
gettimeofday(struct timeval* tv, void* tz)
{
	static Call_t	call = { "gettimeofday", "gettimeofday" };

	return warp_gettimeofday(&call, tv, tz);
}

#ifndef __EXPORT__

extern int
_gettimeofday(struct timeval* tv, void* tz)
{
	static Call_t	call = { "gettimeofday", "_gettimeofday" };

	return warp_gettimeofday(&call, tv, tz);
}

extern int
__gettimeofday(struct timeval* tv, void* tz)
{
	static Call_t	call = { "gettimeofday", "__gettimeofday" };

	return warp_gettimeofday(&call, tv, tz);
}

extern int
_libc_gettimeofday(struct timeval* tv, void* tz)
{
	static Call_t	call = { "gettimeofday", "_libc_gettimeofday" };

	return warp_gettimeofday(&call, tv, tz);
}

extern int
__libc_gettimeofday(struct timeval* tv, void* tz)
{
	static Call_t	call = { "gettimeofday", "__libc_gettimeofday" };

	return warp_gettimeofday(&call, tv, tz);
}

#endif

static int
warp_poll(register Call_t* p, void* f, int n, int to)
{
	int	r;

	intercept(p);
	if (p->warped || !state.factor || to <= 1000)
		return (*(Poll_f)p->call)(f, n, to);
	to /= 1000;
	UNWARP_REL(to);
	to *= 1000;
	if ((r = (*(Poll_f)p->call)(f, n, to)) != -1 && !p->warped && p->level != state.level)
		p->warped = 1;
	return r;
}

static int
poll(void* f, int n, int to)
{
	static Call_t	call = { "poll", "poll" };

	return warp_poll(&call, f, n, to);
}

#ifndef __EXPORT__

static int
_poll(void* f, int n, int to)
{
	static Call_t	call = { "poll", "_poll" };

	return warp_poll(&call, f, n, to);
}

static int
__poll(void* f, int n, int to)
{
	static Call_t	call = { "poll", "__poll" };

	return warp_poll(&call, f, n, to);
}

static int
_libc_poll(void* f, int n, int to)
{
	static Call_t	call = { "poll", "_libc_poll" };

	return warp_poll(&call, f, n, to);
}

static int
__libc_poll(void* f, int n, int to)
{
	static Call_t	call = { "poll", "__libc_poll" };

	return warp_poll(&call, f, n, to);
}

#endif

static int
warp_select(register Call_t* p, int n, void* rp, void* wp, void* ep, register const struct timeval* tv)
{
	int		r;
	struct timeval	x;

	intercept(p);
	if (p->warped || !state.factor || !tv || !tv->tv_sec && !tv->tv_usec)
		return (*(Select_f)p->call)(n, rp, wp, ep, tv);
	x = *tv;
	if (x.tv_sec)
	{
		UNWARP_REL(x.tv_sec);
		if (x.tv_sec)
			x.tv_usec = 0;
		else if (!(x.tv_usec /= state.factor))
			x.tv_usec = 10;
	}
	if ((r = (*(Select_f)p->call)(n, rp, wp, ep, &x)) != -1 && !p->warped && p->level != state.level)
		p->warped = 1;
	return r;
}

static int
select(int n, void* rp, void* wp, void* ep, const struct timeval* tv)
{
	static Call_t	call = { "select", "select" };

	return warp_select(&call, n, rp, wp, ep, tv);
}

#ifndef __EXPORT__

static int
_select(int n, void* rp, void* wp, void* ep, const struct timeval* tv)
{
	static Call_t	call = { "select", "_select" };

	return warp_select(&call, n, rp, wp, ep, tv);
}

static int
__select(int n, void* rp, void* wp, void* ep, const struct timeval* tv)
{
	static Call_t	call = { "select", "__select" };

	return warp_select(&call, n, rp, wp, ep, tv);
}

static int
_libc_select(int n, void* rp, void* wp, void* ep, const struct timeval* tv)
{
	static Call_t	call = { "select", "_libc_select" };

	return warp_select(&call, n, rp, wp, ep, tv);
}

static int
__libc_select(int n, void* rp, void* wp, void* ep, const struct timeval* tv)
{
	static Call_t	call = { "select", "__libc_select" };

	return warp_select(&call, n, rp, wp, ep, tv);
}

#endif

static time_t
warp_time(register Call_t* p, time_t* clock)
{
	time_t	t;

	intercept(p);
	if ((t = (*(Time_f)p->call)(clock)) != (time_t)(-1) && !p->warped)
	{
		if (p->level != state.level)
			p->warped = 1;
		else
		{
			WARP_ABS(t);
			if (clock)
				WARP_ABS(*clock);
		}
	}
	return t;
}

extern time_t
time(time_t* clock)
{
	static Call_t	call = { "time", "time" };

	return warp_time(&call, clock);
}

#ifndef __EXPORT__

extern time_t
_time(time_t* clock)
{
	static Call_t	call = { "time", "_time" };

	return warp_time(&call, clock);
}

extern time_t
__time(time_t* clock)
{
	static Call_t	call = { "time", "__time" };

	return warp_time(&call, clock);
}

extern time_t
_libc_time(time_t* clock)
{
	static Call_t	call = { "time", "_libc_time" };

	return warp_time(&call, clock);
}

extern time_t
__libc_time(time_t* clock)
{
	static Call_t	call = { "time", "__libc_time" };

	return warp_time(&call, clock);
}

#endif

static clock_t
warp_times(register Call_t* p, struct tms* tv)
{
	clock_t	t;

	intercept(p);
	if ((t = (*(Times_f)p->call)(tv)) != (clock_t)(-1) && !p->warped)
	{
		if (p->level != state.level)
			p->warped = 1;
		else
			WARP_REL(t);
	}
	return t;
}

extern clock_t
times(struct tms* tv)
{
	static Call_t	call = { "times", "times" };

	return warp_times(&call, tv);
}

#ifndef __EXPORT__

extern clock_t
_times(struct tms* tv)
{
	static Call_t	call = { "times", "_times" };

	return warp_times(&call, tv);
}

extern clock_t
__times(struct tms* tv)
{
	static Call_t	call = { "times", "__times" };

	return warp_times(&call, tv);
}

extern clock_t
_libc_times(struct tms* tv)
{
	static Call_t	call = { "times", "_libc_times" };

	return warp_times(&call, tv);
}

extern clock_t
__libc_times(struct tms* tv)
{
	static Call_t	call = { "times", "__libc_times" };

	return warp_times(&call, tv);
}

#endif

static int
warp_utime(register Call_t* p, const char* path, const struct utimbuf* tv)
{
	int		r;
	struct utimbuf	tb;

	intercept(p);
	if (!tv || p->warped)
		return (*(Utime_f)p->call)(path, tv);
	tb = *tv;
	UNWARP_ABS(tb.actime);
	UNWARP_ABS(tb.modtime);
	r = (*(Utime_f)p->call)(path, &tb);
	if (p->level != state.level)
	{
		p->warped = 1;
		r = (*(Utime_f)p->call)(path, tv);
	}
	return r;
}

extern int
utime(const char* path, const struct utimbuf* tv)
{
	static Call_t	call = { "utime", "utime" };

	return warp_utime(&call, path, tv);
}

#ifndef __EXPORT__

extern int
_utime(const char* path, const struct utimbuf* tv)
{
	static Call_t	call = { "utime", "_utime" };

	return warp_utime(&call, path, tv);
}

extern int
__utime(const char* path, const struct utimbuf* tv)
{
	static Call_t	call = { "utime", "__utime" };

	return warp_utime(&call, path, tv);
}

extern int
_libc_utime(const char* path, const struct utimbuf* tv)
{
	static Call_t	call = { "utime", "_libc_utime" };

	return warp_utime(&call, path, tv);
}

extern int
__libc_utime(const char* path, const struct utimbuf* tv)
{
	static Call_t	call = { "utime", "__libc_utime" };

	return warp_utime(&call, path, tv);
}

#endif

static int
warp_utimensat(int dirfd, register Call_t* p, const char* path, const struct timespec* tv, int flags)
{
	int		r;
	register int	i;
	struct timespec	tb[2];

	intercept(p);
	if (!tv || p->warped)
		return (*(Utimensat_f)p->call)(dirfd, path, tv, flags);
	for (i = 0; i < elementsof(tb); i++)
	{
		tb[i] = tv[i];
		UNWARP_ABS(tb[i].tv_sec);
	}
	r = (*(Utimensat_f)p->call)(dirfd, path, tb, flags);
	if (p->level != state.level)
	{
		p->warped = 1;
		r = (*(Utimensat_f)p->call)(dirfd, path, tv, flags);
	}
	return r;
}

extern int
utimensat(int dirfd, const char* path, const struct timespec* tv, int flags)
{
	static Call_t	call = { "utimensat", "utimensat" };

	return warp_utimensat(dirfd, &call, path, tv, flags);
}

#ifndef __EXPORT__

extern int
_utimensat(int dirfd, const char* path, const struct timespec* tv, int flags)
{
	static Call_t	call = { "utimensat", "_utimensat" };

	return warp_utimensat(dirfd, &call, path, tv, flags);
}

extern int
__utimensat(int dirfd, const char* path, const struct timespec* tv, int flags)
{
	static Call_t	call = { "utimensat", "__utimensat" };

	return warp_utimensat(dirfd, &call, path, tv, flags);
}

extern int
_libc_utimensat(int dirfd, const char* path, const struct timespec* tv, int flags)
{
	static Call_t	call = { "utimensat", "_libc_utimensat" };

	return warp_utimensat(dirfd, &call, path, tv, flags);
}

extern int
__libc_utimensat(int dirfd, const char* path, const struct timespec* tv, int flags)
{
	static Call_t	call = { "utimensat", "__libc_utimensat" };

	return warp_utimensat(dirfd, &call, path, tv, flags);
}

#endif

static int
warp_utimes(register Call_t* p, const char* path, const struct timeval* tv)
{
	int		r;
	register int	i;
	struct timeval	tb[2];

	intercept(p);
	if (!tv || p->warped)
		return (*(Utimes_f)p->call)(path, tv);
	for (i = 0; i < elementsof(tb); i++)
	{
		tb[i] = tv[i];
		UNWARP_ABS(tb[i].tv_sec);
	}
	r = (*(Utimes_f)p->call)(path, tb);
	if (p->level != state.level)
	{
		p->warped = 1;
		r = (*(Utimes_f)p->call)(path, tv);
	}
	return r;
}

extern int
utimes(const char* path, const struct timeval* tv)
{
	static Call_t	call = { "utimes", "utimes" };

	return warp_utimes(&call, path, tv);
}

#ifndef __EXPORT__

extern int
_utimes(const char* path, const struct timeval* tv)
{
	static Call_t	call = { "utimes", "_utimes" };

	return warp_utimes(&call, path, tv);
}

extern int
__utimes(const char* path, const struct timeval* tv)
{
	static Call_t	call = { "utimes", "__utimes" };

	return warp_utimes(&call, path, tv);
}

extern int
_libc_utimes(const char* path, const struct timeval* tv)
{
	static Call_t	call = { "utimes", "_libc_utimes" };

	return warp_utimes(&call, path, tv);
}

extern int
__libc_utimes(const char* path, const struct timeval* tv)
{
	static Call_t	call = { "utimes", "__libc_utimes" };

	return warp_utimes(&call, path, tv);
}

#endif

static int
warp_utimets(register Call_t* p, const char* path, const struct timespec* tv)
{
	int		r;
	register int	i;
	struct timespec	tb[2];

	intercept(p);
	if (!tv || p->warped)
		return (*(Utimets_f)p->call)(path, tv);
	for (i = 0; i < elementsof(tb); i++)
	{
		tb[i] = tv[i];
		UNWARP_ABS(tb[i].tv_sec);
	}
	r = (*(Utimets_f)p->call)(path, tb);
	if (p->level != state.level)
	{
		p->warped = 1;
		r = (*(Utimets_f)p->call)(path, tv);
	}
	return r;
}

extern int
utimets(const char* path, const struct timespec* tv)
{
	static Call_t	call = { "utimets", "utimets" };

	return warp_utimets(&call, path, tv);
}

#ifndef __EXPORT__

extern int
_utimets(const char* path, const struct timespec* tv)
{
	static Call_t	call = { "utimets", "_utimets" };

	return warp_utimets(&call, path, tv);
}

extern int
__utimets(const char* path, const struct timespec* tv)
{
	static Call_t	call = { "utimets", "__utimets" };

	return warp_utimets(&call, path, tv);
}

extern int
_libc_utimets(const char* path, const struct timespec* tv)
{
	static Call_t	call = { "utimets", "_libc_utimets" };

	return warp_utimets(&call, path, tv);
}

extern int
__libc_utimets(const char* path, const struct timespec* tv)
{
	static Call_t	call = { "utimets", "__libc_utimets" };

	return warp_utimets(&call, path, tv);
}

#endif

#if defined(_STAT_VER)

static void
warp_xst(register Call_t* p, const int ver, register struct stat* st)
{
	static const char	msg[] = "warp: _STAT_VER\n";

	if (!p->warped)
	{
		if (p->level != state.level)
			p->warped = 1;
#if defined(_STAT64_VER)
		else if (ver >= _STAT64_VER)
		{
			register struct stat64*	st64 = (struct stat64*)st;
			static const char	msg64[] = "warp: _STAT64_VER\n";

			if (state.trace)
				write(2, msg64, sizeof(msg64) - 1);
			WARP_ABS(st64->st_atime);
			WARP_ABS(st64->st_ctime);
			WARP_ABS(st64->st_mtime);
		}
#endif
		else if (ver == _STAT_VER)
		{
			if (state.trace)
				write(2, msg, sizeof(msg) - 1);
			WARP_ABS(st->st_atime);
			WARP_ABS(st->st_ctime);
			WARP_ABS(st->st_mtime);
		}
		else if (state.trace)
		{
			static char	msg[] = "warp: stat version 0\n";

			msg[19] = '0' + ver;
			write(2, msg, sizeof(msg) - 1);
		}
	}
}

extern int
_fxstat(const int ver, int fd, struct stat* st)
{
	int		r;

	static Call_t	call = { "_fxstat", "_fxstat" };

	intercept(&call);
	if ((r = (*(Fxstat_f)call.call)(ver, fd, st)) != -1)
		warp_xst(&call, ver, st);
	return r;
}

extern int
__fxstat(const int ver, int fd, struct stat* st)
{
	int		r;

	static Call_t	call = { "_fxstat", "__fxstat" };

	intercept(&call);
	if ((r = (*(Fxstat_f)call.call)(ver, fd, st)) != -1)
		warp_xst(&call, ver, st);
	return r;
}

extern int
_lxstat(const int ver, const char* path, struct stat* st)
{
	int		r;

	static Call_t	call = { "_lxstat", "_lxstat" };

	intercept(&call);
	if ((r = (*(Lxstat_f)call.call)(ver, path, st)) != -1)
		warp_xst(&call, ver, st);
	return r;
}

extern int
__lxstat(const int ver, const char* path, struct stat* st)
{
	int		r;

	static Call_t	call = { "_lxstat", "__lxstat" };

	intercept(&call);
	if ((r = (*(Lxstat_f)call.call)(ver, path, st)) != -1)
		warp_xst(&call, ver, st);
	return r;
}

extern int
_xstat(const int ver, const char* path, struct stat* st)
{
	int		r;

	static Call_t	call = { "_xstat", "_xstat" };

	intercept(&call);
	if ((r = (*(Xstat_f)call.call)(ver, path, st)) != -1)
		warp_xst(&call, ver, st);
	return r;
}

extern int
__xstat(const int ver, const char* path, struct stat* st)
{
	int		r;

	static Call_t	call = { "_xstat", "__xstat" };

	intercept(&call);
	if ((r = (*(Xstat_f)call.call)(ver, path, st)) != -1)
		warp_xst(&call, ver, st);
	return r;
}

#if defined(_lib__xstat64) || defined(_lib___xstat64)

static void
warp_xst64(register Call_t* p, const int ver, register struct stat64* st)
{
	static const char	msg[] = "warp: _STAT_VER\n";

	if (!p->warped)
	{
		if (p->level != state.level)
			p->warped = 1;
#if defined(_STAT64_VER)
		else if (ver >= _STAT64_VER)
		{
			register struct stat64*	st64 = (struct stat64*)st;
			static const char	msg64[] = "warp: _STAT64_VER\n";

			if (state.trace)
				write(2, msg64, sizeof(msg64) - 1);
			WARP_ABS(st64->st_atime);
			WARP_ABS(st64->st_ctime);
			WARP_ABS(st64->st_mtime);
		}
#endif
		else if (ver == _STAT_VER)
		{
			if (state.trace)
				write(2, msg, sizeof(msg) - 1);
			WARP_ABS(st->st_atime);
			WARP_ABS(st->st_ctime);
			WARP_ABS(st->st_mtime);
		}
		else if (state.trace)
		{
			static char	msg[] = "warp: stat version 0\n";

			msg[19] = '0' + ver;
			write(2, msg, sizeof(msg) - 1);
		}
	}
}

extern int
_fxstat64(const int ver, int fd, struct stat64* st)
{
	int		r;

	static Call_t	call = { "_fxstat64", "_fxstat64" };

	intercept(&call);
	if ((r = (*(Fxstat64_f)call.call)(ver, fd, st)) != -1)
		warp_xst64(&call, ver, st);
	return r;
}

extern int
__fxstat64(const int ver, int fd, struct stat64* st)
{
	int		r;

	static Call_t	call = { "_fxstat64", "__fxstat64" };

	intercept(&call);
	if ((r = (*(Fxstat64_f)call.call)(ver, fd, st)) != -1)
		warp_xst64(&call, ver, st);
	return r;
}

extern int
_lxstat64(const int ver, const char* path, struct stat64* st)
{
	int		r;

	static Call_t	call = { "_lxstat64", "_lxstat64" };

	intercept(&call);
	if ((r = (*(Lxstat64_f)call.call)(ver, path, st)) != -1)
		warp_xst64(&call, ver, st);
	return r;
}

extern int
__lxstat64(const int ver, const char* path, struct stat64* st)
{
	int		r;

	static Call_t	call = { "_lxstat64", "__lxstat64" };

	intercept(&call);
	if ((r = (*(Lxstat64_f)call.call)(ver, path, st)) != -1)
		warp_xst64(&call, ver, st);
	return r;
}

extern int
_xstat64(const int ver, const char* path, struct stat64* st)
{
	int		r;

	static Call_t	call = { "_xstat64", "_xstat64" };

	intercept(&call);
	if ((r = (*(Xstat64_f)call.call)(ver, path, st)) != -1)
		warp_xst64(&call, ver, st);
	return r;
}

extern int
__xstat64(const int ver, const char* path, struct stat64* st)
{
	int		r;

	static Call_t	call = { "_xstat64", "__xstat64" };

	intercept(&call);
	if ((r = (*(Xstat64_f)call.call)(ver, path, st)) != -1)
		warp_xst64(&call, ver, st);
	return r;
}

#endif
#else

static void
warp_st(register Call_t* p, register struct stat* st)
{
	if (!p->warped)
	{
		if (p->level != state.level)
			p->warped = 1;
		else
		{
			WARP_ABS(st->st_atime);
			WARP_ABS(st->st_ctime);
			WARP_ABS(st->st_mtime);
		}
	}
}

static int
warp_fstat(register Call_t* p, int fd, struct stat* st)
{
	int	r;

	intercept(p);
	if ((r = (*(Fstat_f)p->call)(fd, st)) != -1)
		warp_st(p, st);
	return r;
}

extern int
fstat(int fd, struct stat* st)
{
	static Call_t	call = { "fstat", "fstat" };

	return warp_fstat(&call, fd, st);
}

#ifndef __EXPORT__

extern int
_fstat(int fd, struct stat* st)
{
	static Call_t	call = { "fstat", "_fstat" };

	return warp_fstat(&call, fd, st);
}

extern int
__fstat(int fd, struct stat* st)
{
	static Call_t	call = { "fstat", "__fstat" };

	return warp_fstat(&call, fd, st);
}

extern int
_libc_fstat(int fd, struct stat* st)
{
	static Call_t	call = { "fstat", "_libc_fstat" };

	return warp_fstat(&call, fd, st);
}

extern int
__libc_fstat(int fd, struct stat* st)
{
	static Call_t	call = { "fstat", "__libc_fstat" };

	return warp_fstat(&call, fd, st);
}

#if _WARP_stat32

extern int
__fstat32(int fd, struct stat* st)
{
	static Call_t	call = { "__fstat32", "__fstat32" };

	return warp_fstat(&call, fd, st);
}

#endif

#endif

static int
warp_lstat(register Call_t* p, const char* path, struct stat* st)
{
	int	r;

	intercept(p);
	if ((r = (*(Lstat_f)p->call)(path, st)) != -1)
		warp_st(p, st);
	return r;
}

extern int
lstat(const char* path, struct stat* st)
{
	static Call_t	call = { "lstat", "lstat" };

	return warp_lstat(&call, path, st);
}

#ifndef __EXPORT__

extern int
_lstat(const char* path, struct stat* st)
{
	static Call_t	call = { "lstat", "_lstat" };

	return warp_lstat(&call, path, st);
}

extern int
__lstat(const char* path, struct stat* st)
{
	static Call_t	call = { "lstat", "__lstat" };

	return warp_lstat(&call, path, st);
}

extern int
_libc_lstat(const char* path, struct stat* st)
{
	static Call_t	call = { "lstat", "_libc_lstat" };

	return warp_lstat(&call, path, st);
}

extern int
__libc_lstat(const char* path, struct stat* st)
{
	static Call_t	call = { "lstat", "__libc_lstat" };

	return warp_lstat(&call, path, st);
}

#if _WARP_stat32

extern int
__lstat32(const char* path, struct stat* st)
{
	static Call_t	call = { "__lstat32", "__lstat32" };

	return warp_lstat(&call, path, st);
}

extern int
__statlstat32(const char* path, struct stat* st)
{
	static Call_t	call = { "__statlstat32", "__statlstat32" };

	return warp_lstat(&call, path, st);
}

#endif

#endif

static int
warp_stat(register Call_t* p, const char* path, struct stat* st)
{
	int	r;

	intercept(p);
	if ((r = (*(Lstat_f)p->call)(path, st)) != -1)
		warp_st(p, st);
	return r;
}

extern int
stat(const char* path, struct stat* st)
{
	static Call_t	call = { "stat", "stat" };

	return warp_stat(&call, path, st);
}

#ifndef __EXPORT__

extern int
_stat(const char* path, struct stat* st)
{
	static Call_t	call = { "stat", "_stat" };

	return warp_stat(&call, path, st);
}

extern int
__stat(const char* path, struct stat* st)
{
	static Call_t	call = { "stat", "__stat" };

	return warp_stat(&call, path, st);
}

extern int
_libc_stat(const char* path, struct stat* st)
{
	static Call_t	call = { "stat", "_libc_stat" };

	return warp_stat(&call, path, st);
}

extern int
__libc_stat(const char* path, struct stat* st)
{
	static Call_t	call = { "stat", "__libc_stat" };

	return warp_stat(&call, path, st);
}

#if _WARP_stat32

extern int
__stat32(const char* path, struct stat* st)
{
	static Call_t	call = { "__stat32", "__stat32" };

	return warp_stat(&call, path, st);
}

#endif

#endif

#endif

#if defined(_lib_stat64)

static void
warp_st64(register Call_t* p, register struct stat64* st)
{
	if (!p->warped)
	{
		if (p->level != state.level)
			p->warped = 1;
		else
		{
			WARP_ABS(st->st_atime);
			WARP_ABS(st->st_ctime);
			WARP_ABS(st->st_mtime);
		}
	}
}

static int
warp_fstat64(register Call_t* p, int fd, struct stat64* st)
{
	int	r;

	intercept(p);
	if ((r = (*(Fstat64_f)p->call)(fd, st)) != -1)
		warp_st64(p, st);
	return r;
}

extern int
fstat64(int fd, struct stat64* st)
{
	static Call_t	call = { "fstat64", "fstat64" };

	return warp_fstat64(&call, fd, st);
}

#ifndef __EXPORT__

extern int
_fstat64(int fd, struct stat64* st)
{
	static Call_t	call = { "fstat64", "_fstat64" };

	return warp_fstat64(&call, fd, st);
}

extern int
__fstat64(int fd, struct stat64* st)
{
	static Call_t	call = { "fstat64", "__fstat64" };

	return warp_fstat64(&call, fd, st);
}

extern int
_libc_fstat64(int fd, struct stat64* st)
{
	static Call_t	call = { "fstat64", "_libc_fstat64" };

	return warp_fstat64(&call, fd, st);
}

extern int
__libc_fstat64(int fd, struct stat64* st)
{
	static Call_t	call = { "fstat64", "__libc_fstat64" };

	return warp_fstat64(&call, fd, st);
}

#endif

static int
warp_lstat64(register Call_t* p, const char* path, struct stat64* st)
{
	int	r;

	intercept(p);
	if ((r = (*(Lstat64_f)p->call)(path, st)) != -1)
		warp_st64(p, st);
	return r;
}

extern int
lstat64(const char* path, struct stat64* st)
{
	static Call_t	call = { "lstat64", "lstat64" };

	return warp_lstat64(&call, path, st);
}

#ifndef __EXPORT__

extern int
_lstat64(const char* path, struct stat64* st)
{
	static Call_t	call = { "lstat64", "_lstat64" };

	return warp_lstat64(&call, path, st);
}

extern int
__lstat64(const char* path, struct stat64* st)
{
	static Call_t	call = { "lstat64", "__lstat64" };

	return warp_lstat64(&call, path, st);
}

extern int
_libc_lstat64(const char* path, struct stat64* st)
{
	static Call_t	call = { "lstat64", "_libc_lstat64" };

	return warp_lstat64(&call, path, st);
}

extern int
__libc_lstat64(const char* path, struct stat64* st)
{
	static Call_t	call = { "lstat64", "__libc_lstat64" };

	return warp_lstat64(&call, path, st);
}

#endif

static int
warp_stat64(register Call_t* p, const char* path, struct stat64* st)
{
	int	r;

	intercept(p);
	if ((r = (*(Stat64_f)p->call)(path, st)) != -1)
		warp_st64(p, st);
	return r;
}

extern int
stat64(const char* path, struct stat64* st)
{
	static Call_t	call = { "stat64", "stat64" };

	return warp_stat64(&call, path, st);
}

#ifndef __EXPORT__

extern int
_stat64(const char* path, struct stat64* st)
{
	static Call_t	call = { "stat64", "_stat64" };

	return warp_stat64(&call, path, st);
}

extern int
__stat64(const char* path, struct stat64* st)
{
	static Call_t	call = { "stat64", "__stat64" };

	return warp_stat64(&call, path, st);
}

extern int
_libc_stat64(const char* path, struct stat64* st)
{
	static Call_t	call = { "stat64", "_libc_stat64" };

	return warp_stat64(&call, path, st);
}

extern int
__libc_stat64(const char* path, struct stat64* st)
{
	static Call_t	call = { "stat64", "__libc_stat64" };

	return warp_stat64(&call, path, st);
}

#endif

#endif /* defined(_lib_stat64) */

#if _lib_clock_gettime && defined(CLOCK_REALTIME)

static int
warp_clock_gettime(register Call_t* p, int clock, struct timespec* tv)
{
	int	r;

	intercept(p);
	if ((r = (*(Clock_gettime_f)p->call)(clock, tv)) != -1 && !p->warped)
	{
		if (p->level != state.level)
			p->warped = 1;
		else if (tv)
			WARP_ABS(tv->tv_sec);
	}
	return r;
}

extern int
clock_gettime(int i, struct timespec* v)
{
	static Call_t	call = { "clock_gettime", "clock_gettime" };

	return warp_clock_gettime(&call, i, v);
}

#ifndef __EXPORT__

extern int
_clock_gettime(int i, struct timespec* v)
{
	static Call_t	call = { "clock_gettime", "_clock_gettime" };

	return warp_clock_gettime(&call, i, v);
}

extern int
__clock_gettime(int i, struct timespec* v)
{
	static Call_t	call = { "clock_gettime", "__clock_gettime" };

	return warp_clock_gettime(&call, i, v);
}

extern int
_libc_clock_gettime(int i, struct timespec* v)
{
	static Call_t	call = { "clock_gettime", "_libc_clock_gettime" };

	return warp_clock_gettime(&call, i, v);
}

extern int
__libc_clock_gettime(int i, struct timespec* v)
{
	static Call_t	call = { "clock_gettime", "__libc_clock_gettime" };

	return warp_clock_gettime(&call, i, v);
}

#endif

#endif /* _lib_clock_gettime */

#if _lib_getitimer

static int
warp_getitimer(register Call_t* p, int i, struct itimerval* v)
{
	int	r;

	intercept(p);
	if ((r = (*(Getitimer_f)p->call)(i, v)) != -1 && !p->warped && state.factor)
	{
		if (p->level != state.level)
			p->warped = 1;
		else
		{
			WARP_REL(v->it_interval.tv_sec);
			WARP_REL(v->it_value.tv_sec);
		}
	}
	return r;
}

extern int
getitimer(int i, struct itimerval* v)
{
	static Call_t	call = { "getitimer", "getitimer" };

	return warp_getitimer(&call, i, v);
}

#ifndef __EXPORT__

extern int
_getitimer(int i, struct itimerval* v)
{
	static Call_t	call = { "getitimer", "_getitimer" };

	return warp_getitimer(&call, i, v);
}

extern int
__getitimer(int i, struct itimerval* v)
{
	static Call_t	call = { "getitimer", "__getitimer" };

	return warp_getitimer(&call, i, v);
}

extern int
_libc_getitimer(int i, struct itimerval* v)
{
	static Call_t	call = { "getitimer", "_libc_getitimer" };

	return warp_getitimer(&call, i, v);
}

extern int
__libc_getitimer(int i, struct itimerval* v)
{
	static Call_t	call = { "getitimer", "__libc_getitimer" };

	return warp_getitimer(&call, i, v);
}

#endif

#endif /* _lib_getitimer */

#if _lib_setitimer

static int
warp_setitimer(register Call_t* p, int i, const struct itimerval* v, struct itimerval* o)
{
	int			r;
	struct itimerval	x;

	intercept(p);
	if (p->warped || !state.factor)
		return (*(Setitimer_f)p->call)(i, v, o);
	x = *v;
	if (x.it_interval.tv_sec)
	{
		UNWARP_REL(x.it_interval.tv_sec);
		if (x.it_interval.tv_sec)
			x.it_interval.tv_usec = 0;
		else if (!(x.it_interval.tv_usec /= state.factor))
			x.it_interval.tv_usec = 10;
	}
	if (x.it_value.tv_sec)
	{
		UNWARP_REL(x.it_value.tv_sec);
		if (x.it_value.tv_sec)
			x.it_value.tv_usec = 0;
		else if (!(x.it_value.tv_usec /= state.factor))
			x.it_value.tv_usec = 10;
	}
	if ((r = (*(Setitimer_f)p->call)(i, &x, o)) != -1 && !p->warped)
	{
		if (p->level != state.level)
			p->warped = 1;
		else if (o)
		{
			WARP_REL(o->it_interval.tv_sec);
			WARP_REL(o->it_value.tv_sec);
		}
	}
	return r;
}

extern int
setitimer(int i, const struct itimerval* v, struct itimerval* o)
{
	static Call_t	call = { "setitimer", "setitimer" };

	return warp_setitimer(&call, i, v, o);
}

#ifndef __EXPORT__

extern int
_setitimer(int i, const struct itimerval* v, struct itimerval* o)
{
	static Call_t	call = { "setitimer", "_setitimer" };

	return warp_setitimer(&call, i, v, o);
}

extern int
__setitimer(int i, const struct itimerval* v, struct itimerval* o)
{
	static Call_t	call = { "setitimer", "__setitimer" };

	return warp_setitimer(&call, i, v, o);
}

extern int
_libc_setitimer(int i, const struct itimerval* v, struct itimerval* o)
{
	static Call_t	call = { "setitimer", "_libc_setitimer" };

	return warp_setitimer(&call, i, v, o);
}

extern int
__libc_setitimer(int i, const struct itimerval* v, struct itimerval* o)
{
	static Call_t	call = { "setitimer", "__libc_setitimer" };

	return warp_setitimer(&call, i, v, o);
}

#endif

#endif /* _lib_setitimer */

#ifndef __EXPORT__

static char**
warp_env(char* const arge[])
{
	register char**	e;
	register char**	x;
	register char*	s;
	register char*	t;
	register char*	u;
	char**		z;
	char**		env;
	int		n;

	env = (char**)arge;
	if (*state.env)
	{
		if (e = env)
		{
			while (s = *e++)
			{
				x = state.env;
				while (t = *x++)
				{
					u = s;
					while (*t++ == *u++)
						if (!*t)
							goto found;
				}
				goto missing;
			found:
				;
			}
		}
		else
			s = *state.env;
	missing:
		if (s)
		{
			if (state.trace)
			{
				s = "warp: execve env missing\n";
				write(2, s, strlen(s));
			}
			if (e = env)
			{
				while (*e++);
				n = e - env;
			}
			else
				n = 1;
			e = state.env;
			while (*e++);
			n += (e - state.env) - 1;
			if (!(z = (char**)malloc(n * sizeof(char**))))
			{
				s = "warp: execve env malloc error\n";
				write(2, s, strlen(s));
				_exit(125);
			}
			e = env;
			env = z;
			x = state.env;
			while (*z = *x++)
				z++;
			if (e)
				while (*z++ = *e++);
			if (state.trace)
			{
				z = env;
				while (t = *z++)
				{
					s = "warp: execve new env ";
					write(2, s, strlen(s));
					write(2, t, strlen(t));
					write(2, "\n", 1);
				}
			}
		}
		else if (state.trace)
		{
			s = "warp: execve env ok\n";
			write(2, s, strlen(s));
		}
	}
	else if (state.trace)
	{
		s = "warp: execve skip check\n";
		write(2, s, strlen(s));
	}
	return env;
}

static int
warp_execve(register Call_t* p, const char* path, char* const argv[], char* const arge[])
{
	int		n;
	char**		env;

	static int	level;

	intercept(p);
	env = (!p->warped && !level) ? warp_env(arge) : (char**)arge;
	p->warped++;
	level++;
	n = (*(Execve_f)p->call)(path, argv, env);
	level--;
	p->warped--;
	return n;
}

static int
warp_execvpe(register Call_t* p, const char* path, char* const argv[], char* const arge[])
{
	int		n;
	char**		env;

	static int	level;

	intercept(p);
	env = (!p->warped && !level) ? warp_env(arge) : (char**)arge;
	p->warped++;
	level++;
	n = (*(Execvpe_f)p->call)(path, argv, env);
	level--;
	p->warped--;
	return n;
}

extern int
execve(const char* path, char* const argv[], char* const arge[])
{
	static Call_t	call = { "execve", "execve" };

	return warp_execve(&call, path, argv, arge);
}

extern int
_execve(const char* path, char* const argv[], char* const arge[])
{
	static Call_t	call = { "execve", "_execve" };

	return warp_execve(&call, path, argv, arge);
}

extern int
__execve(const char* path, char* const argv[], char* const arge[])
{
	static Call_t	call = { "execve", "__execve" };

	return warp_execve(&call, path, argv, arge);
}

extern int
_libc_execve(const char* path, char* const argv[], char* const arge[])
{
	static Call_t	call = { "execve", "_libc_execve" };

	return warp_execve(&call, path, argv, arge);
}

extern int
__libc_execve(const char* path, char* const argv[], char* const arge[])
{
	static Call_t	call = { "execve", "__libc_execve" };

	return warp_execve(&call, path, argv, arge);
}

extern int
execv(const char* path, char* const argv[])
{
	static Call_t	call = { "execv", "execv" };

	return warp_execve(&call, path, argv, environ);
}

extern int
_execv(const char* path, char* const argv[])
{
	static Call_t	call = { "execv", "_execv" };

	return warp_execve(&call, path, argv, environ);
}

extern int
__execv(const char* path, char* const argv[])
{
	static Call_t	call = { "execv", "__execv" };

	return warp_execve(&call, path, argv, environ);
}

extern int
_libc_execv(const char* path, char* const argv[])
{
	static Call_t	call = { "execv", "_libc_execv" };

	return warp_execve(&call, path, argv, environ);
}

extern int
__libc_execv(const char* path, char* const argv[])
{
	static Call_t	call = { "execv", "__libc_execv" };

	return warp_execve(&call, path, argv, environ);
}

extern int
execvp(const char* path, char* const argv[])
{
	static Call_t	call = { "execvp", "execvp" };

	return warp_execvpe(&call, path, argv, environ);
}

extern int
_execvp(const char* path, char* const argv[])
{
	static Call_t	call = { "execvp", "_execvp" };

	return warp_execvpe(&call, path, argv, environ);
}

extern int
__execvp(const char* path, char* const argv[])
{
	static Call_t	call = { "execvp", "__execvp" };

	return warp_execvpe(&call, path, argv, environ);
}

extern int
_libc_execvp(const char* path, char* const argv[])
{
	static Call_t	call = { "execvp", "_libc_execvp" };

	return warp_execvpe(&call, path, argv, environ);
}

extern int
__libc_execvp(const char* path, char* const argv[])
{
	static Call_t	call = { "execvp", "__libc_execvp" };

	return warp_execvpe(&call, path, argv, environ);
}

extern int
execvpe(const char* path, char* const argv[], char* const arge[])
{
	static Call_t	call = { "execvpe", "execvpe" };

	return warp_execvpe(&call, path, argv, arge);
}

extern int
_execvpe(const char* path, char* const argv[], char* const arge[])
{
	static Call_t	call = { "execvpe", "_execvpe" };

	return warp_execvpe(&call, path, argv, arge);
}

extern int
__execvpe(const char* path, char* const argv[], char* const arge[])
{
	static Call_t	call = { "execvpe", "__execvpe" };

	return warp_execvpe(&call, path, argv, arge);
}

extern int
_libc_execvpe(const char* path, char* const argv[], char* const arge[])
{
	static Call_t	call = { "execvpe", "_libc_execvpe" };

	return warp_execvpe(&call, path, argv, arge);
}

extern int
__libc_execvpe(const char* path, char* const argv[], char* const arge[])
{
	static Call_t	call = { "execvpe", "__libc_execvpe" };

	return warp_execvpe(&call, path, argv, arge);
}

extern int
execl(const char* path, const char* arg, ...)
{
	static Call_t	call = { "execl", "execl" };

	return warp_execve(&call, path, (char* const*)&arg, environ);
}

extern int
_execl(const char* path, const char* arg, ...)
{
	static Call_t	call = { "execl", "_execl" };

	return warp_execve(&call, path, (char* const*)&arg, environ);
}

extern int
__execl(const char* path, const char* arg, ...)
{
	static Call_t	call = { "execl", "__execl" };

	return warp_execve(&call, path, (char* const*)&arg, environ);
}

extern int
_libc_execl(const char* path, const char* arg, ...)
{
	static Call_t	call = { "execl", "_libc_execl" };

	return warp_execve(&call, path, (char* const*)&arg, environ);
}

extern int
__libc_execl(const char* path, const char* arg, ...)
{
	static Call_t	call = { "execl", "__libc_execl" };

	return warp_execve(&call, path, (char* const*)&arg, environ);
}

extern int
execlp(const char* path, const char* arg, ...)
{
	static Call_t	call = { "execlp", "execlp" };

	return warp_execvpe(&call, path, (char* const*)&arg, environ);
}

extern int
_execlp(const char* path, const char* arg, ...)
{
	static Call_t	call = { "execlp", "_execlp" };

	return warp_execvpe(&call, path, (char* const*)&arg, environ);
}

extern int
__execlp(const char* path, const char* arg, ...)
{
	static Call_t	call = { "execlp", "__execlp" };

	return warp_execvpe(&call, path, (char* const*)&arg, environ);
}

extern int
_libc_execlp(const char* path, const char* arg, ...)
{
	static Call_t	call = { "execlp", "_libc_execlp" };

	return warp_execvpe(&call, path, (char* const*)&arg, environ);
}

extern int
__libc_execlp(const char* path, const char* arg, ...)
{
	static Call_t	call = { "execlp", "__libc_execlp" };

	return warp_execvpe(&call, path, (char* const*)&arg, environ);
}

#endif