Subversion Repositories HelenOS

/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * Redistributions of source code must retain the above copyright notice, this

 * list of conditions and the following disclaimer.

 *

 * Redistributions in binary form must reproduce the above copyright notice,

 * this list of conditions and the following disclaimer in the documentation

 * and/or other materials provided with the distribution.

 *

 * Neither the name of the original program's authors nor the names of its

 * contributors may be used to endorse or promote products derived from this

 * software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

/* The VERY basics of execute in place support. These are buggy, leaky

 * and not nearly done. Only here for beta testing!! You were warned!!

 * TODO:

 * Hash command lookups to save time

 * Create a running pointer to **path and advance/rewind it as we go */

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <fcntl.h>

#ifndef HELENOS

#include <linux/limits.h>

#include <sys/errno.h>

#include <sys/wait.h>

#endif

#include "config.h"

#include "util.h"

#include "exec.h"

#include "errors.h"

/* Easiest way to handle a shared + allocated string, a structure with

 * one member is sort of silly :) */

char *found;

/* work-around for access() */

unsigned int try_access(const char *f)

{

	int fd;

	fd = open(f, O_RDONLY);

	if (fd > 0) {

		close(fd);

		return 1;

	} else

		return 0;

}

/* Returns the full path of "cmd" if cmd is found, else just hand back

 * cmd as it was presented */

char *find_command(char *cmd)

{

	char *path_orig, *path_tok;

	char *path[PATH_MAX];

	int rc, n = 0, i = 0;

	size_t x = strlen(cmd) + 2;

	found = (char *)malloc(PATH_MAX);

	/* The user has specified the full path, just give it back. Don't test it,

	 * they seem to know what they're doing. */

	if (cmd[0] == '/' || cmd [0] == '.')

		return (char *)cmd;

#ifdef HELENOS

	path_orig = PATH;

#else

	path_orig = getenv("PATH");

	if (NULL == path_orig)

		path_orig = PATH;

#endif

	path_tok = cli_strdup(path_orig);

	/* Extract the PATH env to a path[] array */

	path[n] = cli_strtok(path_tok, PATH_DELIM);

	while (NULL != path[n]) {

		if ((strlen(path[n]) + x ) > PATH_MAX) {

			cli_error(CL_ENOTSUP,

				"Segment %d of path is too large, search ends at segment %d",

				n, n-1);

			break;

		}

		path[++n] = cli_strtok(NULL, PATH_DELIM);

	}

	/* We now have n places to look for the command */

	for (i=0; path[i]; i++) {

		memset(found, 0, sizeof(found));

		snprintf(found, PATH_MAX, "%s/%s", path[i], cmd);

#ifdef HELENOS

		rc = try_access(found);

#else

		rc = access(found, F_OK);

#endif

		if (rc >= 0) {

			/* We found it */

			free(path_tok);

			return (char *) found;

		}

	}

	/* We didn't find it, just give it back as-is. Could be an alias

	 * set in the parent shell */

	free(path_tok);

	return (char *) cmd;

}

#ifdef HELENOS

task_id_t try_exec(char *cmd, char **argv)

{

	task_id_t tid;

	char *tmp;

	tmp = cli_strdup(find_command(cmd));

	free(found);

	tid = task_spawn((const char *)tmp, (const char **)argv);

	free(tmp);

	if (tid == 0)

		/* HelenOS does not set errno, so all we can do is report

		 * a task ID of 0 as a generic failure. */

		cli_error(CL_EEXEC, "Can not spawn %s", cmd);

	return tid;

}

#else

int try_exec(char *cmd, char **argv)

{

	char *tmp;

	pid_t pid;

	int status;

	/* Copy the result of allocated 'found' */

	tmp = cli_strdup(find_command(cmd));

	/* free the pointer, no longer needed */

	free(found);

	if (-1 == (access(tmp, F_OK))) {

		cli_error(CL_EFAIL,

			"%s : No such external, modular or builtin command", tmp);

		free(tmp);

		return CL_EFAIL;

	}

	/* Create a child to run the program */

	pid = fork();

	if (pid == 0) {

		execv(tmp, argv);

		exit(errno);

	} else if (pid > 0) {

		/* Block until we get a PID (and result) */

		wait(&status);

		status = status / 256;

	} else {

		/* Could not fork, ulimit or out of memory */

		cli_error(CL_ENOMEM, "Could not fork");

		free(tmp);

		return CL_ENOMEM;

	}

	free(tmp);

	/* No need to go any further if status == 0 */

	/*

	if (status == 0)

		return status;

	*/

	/* Decode any errors from execv() (these explain themselves) */

	switch (status) {

	case ENOTDIR:

		cli_error(CL_EFAIL, "%s : No such file or directory", tmp);

		status = CL_EFAIL;

		break;

	case EISDIR:

		cli_error(CL_EFAIL, "%s : Command is a directory", tmp);

		status = CL_EFAIL;

		break;

	case EACCES:

		cli_error(CL_EPERM, "%s :", tmp);

		status = CL_EFAIL;

		break;

	case ENOMEM:

		cli_error(CL_ENOMEM, "%s :", tmp);

		status = CL_EFAIL;

		break;

	case ENAMETOOLONG:

		cli_error(CL_EFAIL, "Argument list too long");

		status = CL_EFAIL;

		break;

	case EFAULT:

		cli_error(CL_EFAIL, "Invalid argument pointer\n(please report "

			"this to %s)", PACKAGE_BUGREPORT);

		status = CL_EFAIL;

		break;

	}

	return status;

}

#endif /* HELENOS */