uclibc-ng/libc/unistd/exec.c

/*  Copyright (C) 2004     Manuel Novoa III
 *
 * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
 */

/* Jan 1, 2004
 *   Initial version of a SUSv3 compliant exec*() functions.
 * Feb 17, 2004
 *   Sigh... Fall back to alloca() if munmap() is broken on uClinux.
 */

/* NOTE: Strictly speaking, there could be problems from accessing
 * __environ in multithreaded programs.  The only way around this
 * that I see is to essentially lock __environ access (modifying
 * the setenv code), make a copy of the environment table (just the
 * pointers since the strings themselves are never freed), and then
 * unlock prior to the execve call.  If that fails, then we'd need
 * to free the storage allocated for the copy.  Better ideas anyone?
 */

#include <stdio.h>
#include <stdlib.h>
#include <paths.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>
#include <limits.h>
#include <unistd.h>
#include <sys/mman.h>



/**********************************************************************/
#define EXEC_FUNC_COMMON 0
#define EXEC_FUNC_EXECVP 1
#define EXEC_FUNC_EXECVPE 2

#if defined(__ARCH_USE_MMU__)

/* We have an MMU, so use alloca() to grab space for buffers and arg lists. */

# define EXEC_ALLOC_SIZE(VAR)      /* nothing to do */
# define EXEC_ALLOC(SIZE,VAR,FUNC) alloca((SIZE))
# define EXEC_FREE(PTR,VAR)        ((void)0)

#else

/* We do not have an MMU, so using alloca() is not an option (as this will
 * easily overflow the stack in most setups).  Less obviously, using malloc()
 * is not an option either since malloc()ed memory can leak in from a vfork()ed
 * child into the parent as no one is around after the child calls exec*() to
 * free() the memory.  Therefore, we must use mmap() and unmap() directly,
 * caching the result as we go.  This way we minimize the leak by reusing the
 * memory with every call to an exec*().
 *
 * To prevent recursive use of the same cached memory, we have to give execvp()
 * its own cache.  Here are the nested exec calls (a/-: alloc/no-alloc):
 *  execve(-) -> calls straight to kernel
 *  execl(a)  -> execve(-)
 *  execlp(a) -> execvp(a)	!! recursive usage !!
 *  execle(a) -> execve(-)
 *  execv(-)  -> execve(-)
 *  execvp(a) -> execve(-)
 *  execvpe(a) -> execve(-)
 */

# define EXEC_ALLOC_SIZE(VAR)      /* nothing to do */
# define EXEC_ALLOC(SIZE,VAR,FUNC) __exec_alloc((SIZE), FUNC)
# define EXEC_FREE(PTR,VAR)        ((void)0)

extern void *__exec_alloc(size_t size, int func) attribute_hidden;

# ifdef L___exec_alloc

void *__exec_alloc(size_t size, int func)
{
	static void *common_cache, *execvp_cache;
	static size_t common_size, execvp_size;

	void **cache = (func ? &execvp_cache : &common_cache);
	size_t *cache_size = (func ? &execvp_size : &common_size);

	if (*cache_size >= size)
		return *cache;
	else if (*cache)
		munmap(*cache, *cache_size);

	*cache_size = size;
	return *cache = mmap(0, size, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);

	/* We don't actually handle OOM in the exec funcs ...
	if (*cache != MAP_FAILED)
		return *cache;
	else
		return (*cache = NULL);
	*/
}

# endif

#endif
/**********************************************************************/
#ifdef L_execl

int execl(const char *path, const char *arg, ...)
{
	EXEC_ALLOC_SIZE(size)		/* Do NOT add a semicolon! */
	int n;
	char **argv;
	char **p;
	va_list args;

	n = 0;
	va_start(args, arg);
	do {
		++n;
	} while (va_arg(args, char *));
	va_end(args);

	p = argv = (char **) EXEC_ALLOC((n+1) * sizeof(char *), size, EXEC_FUNC_COMMON);

	p[0] = (char *)arg;

	va_start(args, arg);
	do {
		*++p = va_arg(args, char *);
	} while (--n);
	va_end(args);

	n = execve(path, (char *const *) argv, __environ);

	EXEC_FREE(argv, size);

	return n;
}
libc_hidden_def(execl)

#endif
/**********************************************************************/
#ifdef L_execv

int execv(const char *path, char *const argv[])
{
	return execve(path, argv, __environ);
}
libc_hidden_def(execv)

#endif
/**********************************************************************/
#ifdef L_execle

int execle(const char *path, const char *arg, ...)
{
	EXEC_ALLOC_SIZE(size)		/* Do NOT add a semicolon! */
	int n;
	char **argv;
	char **p;
	char *const *envp;
	va_list args;

	n = 0;
	va_start(args, arg);
	do {
		++n;
	} while (va_arg(args, char *));
	envp = va_arg(args, char *const *);	/* Varies from execl and execlp. */
	va_end(args);

	p = argv = (char **) EXEC_ALLOC((n+1) * sizeof(char *), size, EXEC_FUNC_COMMON);

	p[0] = (char *)arg;

	va_start(args, arg);
	do {
		*++p = va_arg(args, char *);
	} while (--n);
	va_end(args);

	n = execve(path, (char *const *) argv, envp);

	EXEC_FREE(argv, size);

	return n;
}
libc_hidden_def(execle)

#endif
/**********************************************************************/
#ifdef L_execlp

int execlp(const char *file, const char *arg, ...)
{
	EXEC_ALLOC_SIZE(size)		/* Do NOT add a semicolon! */
	int n;
	char **argv;
	char **p;
	va_list args;

	n = 0;
	va_start(args, arg);
	do {
		++n;
	} while (va_arg(args, char *));
	va_end(args);

	p = argv = (char **) EXEC_ALLOC((n+1) * sizeof(char *), size, EXEC_FUNC_COMMON);

	p[0] = (char *)arg;

	va_start(args, arg);
	do {
		*++p = va_arg(args, char *);
	} while (--n);
	va_end(args);

	n = execvp(file, (char *const *) argv);

	EXEC_FREE(argv, size);

	return n;
}
libc_hidden_def(execlp)

#endif
/**********************************************************************/
#if defined (L_execvp) || defined(L_execvpe)


/* Use a default path that matches glibc behavior, since SUSv3 says
 * this is implementation-defined.  The default is current working dir,
 * /bin, and then /usr/bin. */
static const char default_path[] = ":/bin:/usr/bin";
#if defined (L_execvp)
int execvp(const char *path, char *const argv[])
#elif defined (L_execvpe)
int execvpe(const char *path, char *const argv[], char *const envp[])
#endif
{
	char *buf = NULL;
	char *p;
	char *e;
	char *s0;
	char *s;
	EXEC_ALLOC_SIZE(size = 0)	/* Do NOT add a semicolon! */
	size_t len;
	size_t plen;

	if (!path || !*path) {		/* Comply with SUSv3. */
	BAD:
		__set_errno(ENOENT);
		return -1;
	}

	if (strchr(path, '/')) {
#if defined (L_execvp)
		execve(path, argv, __environ);
#elif defined (L_execvpe)
		execve(path, argv, envp);
#endif
		if (errno == ENOEXEC) {
			char **nargv;
			EXEC_ALLOC_SIZE(size2) /* Do NOT add a semicolon! */
			size_t n;
	RUN_BIN_SH:
			/* Need the dimension - 1.  We omit counting the trailing
			 * NULL but we actually omit the first entry. */
			for (n=0 ; argv[n] ; n++) {}
#if defined (L_execvp)
			nargv = (char **) EXEC_ALLOC((n+2) * sizeof(char *), size2, EXEC_FUNC_EXECVP);
#elif defined (L_execvpe)
			nargv = (char **) EXEC_ALLOC((n+2) * sizeof(char *), size2, EXEC_FUNC_EXECVPE);
#endif
			nargv[0] = argv[0];
			nargv[1] = (char *)path;
			memcpy(nargv+2, argv+1, n*sizeof(char *));
#if defined (L_execvp)
			execve(_PATH_BSHELL, nargv, __environ);
#elif defined (L_execvpe)
			execve(_PATH_BSHELL, nargv, envp);
#endif
			EXEC_FREE(nargv, size2);
		}
	} else {
		if ((p = getenv("PATH")) != NULL) {
			if (!*p) {
				goto BAD;
			}
		} else {
			p = (char *) default_path;
		}

		plen = strlen(path);
		if (plen > (FILENAME_MAX - 1)) {
		ALL_TOO_LONG:
			__set_errno(ENAMETOOLONG);
			return -1;
		}
		len = (FILENAME_MAX - 1) - plen;
#if defined (L_execvp)
		buf = EXEC_ALLOC(FILENAME_MAX, size, EXEC_FUNC_EXECVP);
#elif defined (L_execvpe)
		buf = EXEC_ALLOC(FILENAME_MAX, size, EXEC_FUNC_EXECVPE);
#endif
		{
			int seen_small = 0;
			s0 = buf + len;
			memcpy(s0, path, plen+1);

			do {
				s = s0;
				e = strchrnul(p, ':');
				if (e > p) {
					plen = e - p;
					if (e[-1] != '/') {
						++plen;
					}
					if (plen > len) {
						goto NEXT;
					}
					s -= plen;
					memcpy(s, p, plen);
					s[plen-1] = '/';
				}

#if defined (L_execvp)
				execve(s, argv, __environ);
#elif defined (L_execvpe)
				execve(s, argv, envp);
#endif
				seen_small = 1;

				if (errno == ENOEXEC) {
					path = s;
					goto RUN_BIN_SH;
				}

			NEXT:
				if (!*e) {
					if (!seen_small) {
						goto ALL_TOO_LONG;
					}
					break;
				}
				p = e + 1;
			} while (1);
		}
	}

	EXEC_FREE(buf, size);

	return -1;
}
#if defined (L_execvp)
libc_hidden_def(execvp)
#elif defined (L_execvpe)
libc_hidden_def(execvpe)
#endif

#endif /* #if defined (L_execvp) || defined(L_execvpe) */
/**********************************************************************/