/***********************************************************************

*                                                                      *

*               This software is part of the ast package               *

*          Copyright (c) 1982-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                            *

*                                                                      *

*                  David Korn <dgk@research.att.com>                   *

*                                                                      *

***********************************************************************/

#pragma prototyped

/*

 * David Korn

 * AT&T Labs

 *

 */

#include	"defs.h"

#include	<fcin.h>

#include	<ls.h>

#include	<nval.h>

#include	"variables.h"

#include	"path.h"

#include	"io.h"

#include	"jobs.h"

#include	"history.h"

#include	"test.h"

#include	"FEATURE/dynamic"

#include	"FEATURE/externs"

#if SHOPT_PFSH 

#   ifdef _hdr_exec_attr

#	include	<exec_attr.h>

#   endif

#   if     _lib_vfork

#	include     <ast_vfork.h>

#   else

#	define vfork()      fork()

#   endif

#endif

#define RW_ALL	(S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR|S_IWGRP|S_IWOTH)

#define LIBCMD	"cmd"

static int		canexecute(Shell_t*,char*,int);

static void		funload(Shell_t*,int,const char*);

static void		exscript(Shell_t*,char*, char*[], char**);

static int		path_chkpaths(Shell_t*,Pathcomp_t*,Pathcomp_t*,Pathcomp_t*,int);

static void		path_checkdup(Shell_t *shp,register Pathcomp_t*);

static const char	*std_path;

static int onstdpath(const char *name)

{

	register const char *cp = std_path, *sp;

	if(cp)

		while(*cp)

		{

			for(sp=name; *sp && (*cp == *sp); sp++,cp++);

			if(*sp==0 && (*cp==0 || *cp==':'))

				return(1);

			while(*cp && *cp++!=':');

		}

	return(0);

}

#if SHOPT_PFSH 

int path_xattr(Shell_t *shp, const char *path, char *rpath)

{

	char  resolvedpath[PATH_MAX + 1];

	if (shp->gd->user && *shp->gd->user)

	{

		execattr_t *pf;

		if(!rpath)

			rpath = resolvedpath;

		if (!realpath(path, resolvedpath))

			return -1;

		if(pf=getexecuser(shp->gd->user, KV_COMMAND, resolvedpath, GET_ONE))

		{

			if (!pf->attr || pf->attr->length == 0)

			{

				free_execattr(pf);

				return(0);

			}

			free_execattr(pf);

			return(1);

		}

	}

	errno = ENOENT;

	return(-1);

}

#endif /* SHOPT_PFSH */

static pid_t path_pfexecve(Shell_t *shp,const char *path, char *argv[],char *const envp[],int spawn)

{

#if SHOPT_PFSH 

	char  resolvedpath[PATH_MAX + 1];

	pid_t	pid;

	if(spawn)

	{

		while((pid = vfork()) < 0)

			_sh_fork(shp,pid, 0, (int*)0);

		if(pid)

			return(pid);

	}

	if(!sh_isoption(SH_PFSH))

		return(execve(path, argv, envp));

	/* Solaris implements realpath(3C) using the resolvepath(2) */

	/* system call so we can save us to call access(2) first */

	/* we can exec the command directly instead of via pfexec(1) if */

	/* there is a matching entry without attributes in exec_attr(4) */

	if(!path_xattr(shp,path,resolvedpath))

		return(execve(path, argv, envp));

	--argv;

	argv[0] = argv[1];

	argv[1] = resolvedpath;

	return(execve("/usr/bin/pfexec", argv, envp));

#else

	return(execve(path, argv, envp));

#endif

}

static pid_t _spawnveg(Shell_t *shp,const char *path, char* const argv[], char* const envp[], pid_t pgid)

{

	pid_t pid;

	while(1)

	{

		sh_stats(STAT_SPAWN);

		pid = spawnveg(path,argv,envp,pgid);

		if(pid>=0 || errno!=EAGAIN)

			break;

	}

	return(pid);

}

/*

 * used with command -x to run the command in multiple passes

 * spawn is non-zero when invoked via spawn

 * the exitval is set to the maximum for each execution

 */

static pid_t path_xargs(Shell_t *shp,const char *path, char *argv[],char *const envp[], int spawn)

{

	register char *cp, **av, **xv;

	char **avlast= &argv[shp->xargmax], **saveargs=0;

	char *const *ev;

	long size, left;

	int nlast=1,n,exitval=0;

	pid_t pid;

	if(shp->xargmin < 0)

		return((pid_t)-1);

	size = shp->gd->lim.arg_max-1024;

	for(ev=envp; cp= *ev; ev++)

		size -= strlen(cp)-1;

	for(av=argv; (cp= *av) && av< &argv[shp->xargmin]; av++)  

		size -= strlen(cp)-1;

	for(av=avlast; cp= *av; av++,nlast++)  

		size -= strlen(cp)-1;

	av =  &argv[shp->xargmin];

	if(!spawn)

		job_clear();

	shp->exitval = 0;

	while(av

	{

		for(xv=av,left=size; left>0 && av

			left -= strlen(*av++)+1;

		/* leave at least two for last */

		if(left<0 && (avlast-av)<2)

			av--;

		if(xv==&argv[shp->xargmin])

		{

			n = nlast*sizeof(char*);

			saveargs = (char**)malloc(n);

			memcpy((void*)saveargs, (void*)av, n);

			memcpy((void*)av,(void*)avlast,n);

		}

		else

		{

			for(n=shp->xargmin; xv < av; xv++)

				argv[n++] = *xv;

			for(xv=avlast; cp=  *xv; xv++)

				argv[n++] = cp;

			argv[n] = 0;

		}

		if(saveargs || av

		{

			if((pid=_spawnveg(shp,path,argv,envp,0)) < 0)

				return(-1);

			job_post(shp,pid,0);

			job_wait(pid);

			if(shp->exitval>exitval)

				exitval = shp->exitval;

			if(saveargs)

			{

				memcpy((void*)av,saveargs,n);

				free((void*)saveargs);

				saveargs = 0;

			}

		}

		else if(spawn && !sh_isoption(SH_PFSH))

		{

			shp->xargexit = exitval;

			if(saveargs)

				free((void*)saveargs);

			return(_spawnveg(shp,path,argv,envp,spawn>>1));

		}

		else

		{

			if(saveargs)

				free((void*)saveargs);

			return(path_pfexecve(shp,path,argv,envp,spawn));

		}

	}

	if(!spawn)

		exit(exitval);

	return((pid_t)-1);

}

/*

 * make sure PWD is set up correctly

 * Return the present working directory

 * Invokes getcwd() if necessary

 * Sets the PWD variable to this value

 */

char *path_pwd(Shell_t *shp,int flag)

{

	register char *cp;

	register int count = 0;

	if(shp->pwd)

		return((char*)shp->pwd);

	while(1) 

	{

		/* try from lowest to highest */

		switch(count++)

		{

			case 0:

				cp = nv_getval(PWDNOD);

				break;

			case 1:

				cp = nv_getval(HOME);

				break;

			case 2:

				cp = "/";

				break;

			case 3:

			{

				if(cp=getcwd(NIL(char*),0))

				{  

					nv_offattr(PWDNOD,NV_NOFREE);

					_nv_unset(PWDNOD,0);

					PWDNOD->nvalue.cp = cp;

					goto skip;

				}

				break;

			}

			case 4:

				return((char*)e_dot);

		}

		if(cp && *cp=='/' && test_inode(cp,e_dot))

			break;

	}

	if(count>1)

	{

		nv_offattr(PWDNOD,NV_NOFREE);

		nv_putval(PWDNOD,cp,NV_RDONLY);

	}

skip:

	nv_onattr(PWDNOD,NV_NOFREE|NV_EXPORT);

	shp->pwd = (char*)(PWDNOD->nvalue.cp);

	return(cp);

}

/*

 * delete current Pathcomp_t structure

 */

void  path_delete(Pathcomp_t *first)

{

	register Pathcomp_t *pp=first, *old=0, *ppnext;

	while(pp)

	{

		ppnext = pp->next;

		if(--pp->refcount<=0)

		{

			if(pp->lib)

				free((void*)pp->lib);

			if(pp->bbuf)

				free((void*)pp->bbuf);

			free((void*)pp);

			if(old)

				old->next = ppnext;

		}

		else

			old = pp;

		pp = ppnext; 

	}

}

/*

 * returns library variable from .paths

 * The value might be returned on the stack overwriting path

 */

static char *path_lib(Shell_t *shp,Pathcomp_t *pp, char *path)

{

	register char *last = strrchr(path,'/');

	register int r;

	struct stat statb;

	if(last)

		*last = 0;

	else

		path = ".";

	r = stat(path,&statb);

	if(last)

		*last = '/';

	if(r>=0)

	{

		Pathcomp_t pcomp;

		char save[8];

		for( ;pp; pp=pp->next)

		{

			path_checkdup(shp,pp);

			if(pp->ino==statb.st_ino && pp->dev==statb.st_dev && pp->mtime==statb.st_mtime)

				return(pp->lib);

		}

		pcomp.len = 0;

		if(last)

			pcomp.len = last-path;

		memcpy((void*)save, (void*)stakptr(PATH_OFFSET+pcomp.len),sizeof(save));

		if(path_chkpaths(shp,(Pathcomp_t*)0,(Pathcomp_t*)0,&pcomp,PATH_OFFSET))

			return(stakfreeze(1));

		memcpy((void*)stakptr(PATH_OFFSET+pcomp.len),(void*)save,sizeof(save));

	}

	return(0);

}

#if 0

void path_dump(register Pathcomp_t *pp)

{

	sfprintf(sfstderr,"dump\n");

	while(pp)

	{

		sfprintf(sfstderr,"pp=%x dev=%d ino=%d len=%d flags=%o name=%.*s\n",

			pp,pp->dev,pp->ino,pp->len,pp->flags,pp->len,pp->name);

		pp = pp->next;

	}

}

#endif

/*

 * check for duplicate directories on PATH

 */

static void path_checkdup(Shell_t *shp,register Pathcomp_t *pp)

{

	register char		*name = pp->name;

	register Pathcomp_t	*oldpp,*first;

	register int		flag=0;

	struct stat 		statb;

	if(stat(name,&statb)<0 || !S_ISDIR(statb.st_mode))

	{

		pp->flags |= PATH_SKIP;

		pp->dev = *name=='/';

		return;

	}

	pp->mtime = statb.st_mtime;

	pp->ino = statb.st_ino;

	pp->dev = statb.st_dev;

	if(*name=='/' && onstdpath(name))

		flag = PATH_STD_DIR;

	first = (pp->flags&PATH_CDPATH)?(Pathcomp_t*)shp->cdpathlist:path_get(shp,"");

	for(oldpp=first; oldpp && oldpp!=pp; oldpp=oldpp->next)

	{

		if(pp->ino==oldpp->ino && pp->dev==oldpp->dev && pp->mtime==oldpp->mtime)

		{

			flag |= PATH_SKIP;

			break;

		}

	}

	pp->flags |= flag;

	if(((pp->flags&(PATH_PATH|PATH_SKIP))==PATH_PATH))

	{

		int offset = staktell();

		stakputs(name);

		path_chkpaths(shp,first,0,pp,offset);

		stakseek(offset);

	}

}

/*

 * write the next path to search on the current stack

 * if last is given, all paths that come before <last> are skipped

 * the next pathcomp is returned.

 */

Pathcomp_t *path_nextcomp(Shell_t *shp,register Pathcomp_t *pp, const char *name, Pathcomp_t *last)

{

	Pathcomp_t	*ppnext;

	stakseek(PATH_OFFSET);

	if(*name=='/')

		pp = 0;

	else

	{

		for(;pp && pp!=last;pp=ppnext)

		{

			ppnext = pp->next;

			if(!pp->dev && !pp->ino)

				path_checkdup(shp,pp);

			if(pp->flags&PATH_SKIP)

				return(ppnext);

			if(!last || *pp->name!='/')

				break;

		}

		if(!pp)		/* this should not happen */

			pp = last;

	}

	if(pp && (pp->name[0]!='.' || pp->name[1]))

	{

		if(*pp->name!='/')

		{

			stakputs(path_pwd(shp,1));

			if(*stakptr(staktell()-1)!='/')

				stakputc('/');

		}

		stakwrite(pp->name,pp->len);

		if(pp->name[pp->len-1]!='/')

			stakputc('/');

	}

	stakputs(name);

	stakputc(0);

	while(pp && pp!=last && (pp=pp->next))

	{

		if(!(pp->flags&PATH_SKIP))

			return(pp);

	}

	return((Pathcomp_t*)0);

}

static Pathcomp_t* defpath_init(Shell_t *shp)

{

	Pathcomp_t *pp = (void*)path_addpath(shp,(Pathcomp_t*)0,(std_path),PATH_PATH);

	return(pp);

}

static void path_init(Shell_t *shp)

{

	const char *val;

	Pathcomp_t *pp;

	if(!std_path && !(std_path=astconf("PATH",NIL(char*),NIL(char*))))

		std_path = e_defpath;

	if(val=sh_scoped(shp,(PATHNOD))->nvalue.cp)

	{

		shp->pathlist = pp = (void*)path_addpath(shp,(Pathcomp_t*)shp->pathlist,val,PATH_PATH);

	}

	else

	{

		if(!(pp=(Pathcomp_t*)shp->defpathlist))

			pp = defpath_init(shp);

		shp->pathlist = (void*)path_dup(pp);

	}

	if(val=sh_scoped(shp,(FPATHNOD))->nvalue.cp)

	{

		pp = (void*)path_addpath(shp,(Pathcomp_t*)shp->pathlist,val,PATH_FPATH);

	}

}

/*

 * returns that pathlist to search

 */

Pathcomp_t *path_get(register Shell_t *shp,register const char *name)

{

	register Pathcomp_t *pp=0;

	if(*name && strchr(name,'/'))

		return(0);

	if(!sh_isstate(SH_DEFPATH))

	{

		if(!shp->pathlist)

			path_init(shp);

		pp = (Pathcomp_t*)shp->pathlist;

	}

	if(!pp && (!(sh_scoped(shp,PATHNOD)->nvalue.cp)) || sh_isstate(SH_DEFPATH))

	{

		if(!(pp=(Pathcomp_t*)shp->defpathlist))

			pp = defpath_init(shp);

	}

	return(pp);

}

/*

 * open file corresponding to name using path give by <pp>

 */

static int	path_opentype(Shell_t *shp,const char *name, register Pathcomp_t *pp, int fun)

{

	register int fd= -1;

	struct stat statb;

	Pathcomp_t *oldpp;

	if(!pp && !shp->pathlist)

		path_init(shp);

	if(!fun && strchr(name,'/'))

	{

		if(sh_isoption(SH_RESTRICTED))

			errormsg(SH_DICT,ERROR_exit(1),e_restricted,name);

	}

	do

	{

		pp = path_nextcomp(shp,oldpp=pp,name,0);

		while(oldpp && (oldpp->flags&PATH_SKIP))

			oldpp = oldpp->next;

		if(fun && (!oldpp || !(oldpp->flags&PATH_FPATH)))

			continue;

		if((fd = sh_open(path_relative(shp,stakptr(PATH_OFFSET)),O_RDONLY,0)) >= 0)

		{

			if(fstat(fd,&statb)<0 || S_ISDIR(statb.st_mode))

			{

				errno = EISDIR;

				sh_close(fd);

				fd = -1;

			}

		}

	}

	while( fd<0 && pp);

	if(fd>=0 && (fd = sh_iomovefd(fd)) > 0)

	{

		fcntl(fd,F_SETFD,FD_CLOEXEC);

		shp->fdstatus[fd] |= IOCLEX;

	}

	return(fd);

}

/*

 * open file corresponding to name using path give by <pp>

 */

int	path_open(Shell_t *shp,const char *name, register Pathcomp_t *pp)

{

	return(path_opentype(shp,name,pp,0));

}

/*

 * given a pathname return the base name

 */

char	*path_basename(register const char *name)

{

	register const char *start = name;

	while (*name)

		if ((*name++ == '/') && *name)	/* don't trim trailing / */

			start = name;

	return ((char*)start);

}

char *path_fullname(Shell_t *shp,const char *name)

{

	int len=strlen(name)+1,dirlen=0;

	char *path,*pwd;

	if(*name!='/')

	{

		pwd = path_pwd(shp,1);

		dirlen = strlen(pwd)+1;

	}

	path = (char*)malloc(len+dirlen);

	if(dirlen)

	{

		memcpy((void*)path,(void*)pwd,dirlen);

		path[dirlen-1] = '/';

	}

	memcpy((void*)&path[dirlen],(void*)name,len);

	pathcanon(path,0);

	return(path);

}

/*

 * load functions from file <fno>

 */

static void funload(Shell_t *shp,int fno, const char *name)

{

	char		*pname,*oldname=shp->st.filename, buff[IOBSIZE+1];

	Namval_t	*np;

	struct Ufunction *rp,*rpfirst;

	int		 savestates = sh_getstate(), oldload=shp->funload;

	pname = path_fullname(shp,stakptr(PATH_OFFSET));

	if(shp->fpathdict && (rp = dtmatch(shp->fpathdict,(void*)pname)))

	{

		Dt_t	*funtree = sh_subfuntree(1);

		while(1)

		{

			rpfirst = dtprev(shp->fpathdict,rp);

			if(!rpfirst || strcmp(pname,rpfirst->fname))

				break;

			rp = rpfirst;

		}

		do

		{

			if((np = dtsearch(funtree,rp->np)) && is_afunction(np))

			{

				if(np->nvalue.rp)

					np->nvalue.rp->fdict = 0;

				nv_delete(np,funtree,NV_NOFREE);

			}

			dtinsert(funtree,rp->np);

			rp->fdict = funtree;

		}

		while((rp=dtnext(shp->fpathdict,rp)) && strcmp(pname,rp->fname)==0);

		sh_close(fno);

		free((void*)pname);

		return;

	}

	sh_onstate(SH_NOLOG);

	sh_onstate(SH_NOALIAS);

	shp->readscript = (char*)name;

	shp->st.filename = pname;

	shp->funload = 1;

	error_info.line = 0;

	sh_eval(sfnew(NIL(Sfio_t*),buff,IOBSIZE,fno,SF_READ),SH_FUNEVAL);

	sh_close(fno);

	shp->readscript = 0;

#if SHOPT_NAMESPACE

	if(shp->namespace)

		np = sh_fsearch(shp,name,0);

	else

#endif /* SHOPT_NAMESPACE */

		np = nv_search(name,shp->fun_tree,0);

	if(!np || !np->nvalue.ip)

		pname = stakcopy(shp->st.filename);

	else

		pname = 0;

	free((void*)shp->st.filename);

	shp->funload = oldload;

	shp->st.filename = oldname;

	sh_setstate(savestates);

	if(pname)

		errormsg(SH_DICT,ERROR_exit(ERROR_NOEXEC),e_funload,name,pname);

}

/*

 * do a path search and track alias if requested

 * if flag is 0, or if name not found, then try autoloading function

 * if flag==2 or 3, returns 1 if name found on FPATH

 * if flag==3 no tracked alias will be set

 * returns 1, if function was autoloaded.

 * If oldpp is not NULL, it will contain a pointer to the path component

 *    where it was found.

 */

int	path_search(Shell_t *shp,register const char *name,Pathcomp_t **oldpp, int flag)

{

	register Namval_t *np;

	register int fno;

	Pathcomp_t *pp=0;

	if(name && strchr(name,'/'))

	{

		stakseek(PATH_OFFSET);

		stakputs(name);

		if(canexecute(shp,stakptr(PATH_OFFSET),0)<0)

		{

			*stakptr(PATH_OFFSET) = 0;

			return(0);

		}

		if(*name=='/')

			return(1);

		stakseek(PATH_OFFSET);

		stakputs(path_pwd(shp,1));

		stakputc('/');

		stakputs(name);

		stakputc(0);

		return(0);

	}

	if(sh_isstate(SH_DEFPATH))

	{

		if(!shp->defpathlist)

			defpath_init(shp);

	}

	else if(!shp->pathlist)

		path_init(shp);

	if(flag)

	{

		if(!(flag&1) && (np=nv_search(name,shp->track_tree,0)) && !nv_isattr(np,NV_NOALIAS) && (pp=(Pathcomp_t*)np->nvalue.cp))

		{

			stakseek(PATH_OFFSET);

			path_nextcomp(shp,pp,name,pp);

			if(oldpp)

				*oldpp = pp;

			stakputc(0);

			return(0);

		}

		pp = path_absolute(shp,name,oldpp?*oldpp:NIL(Pathcomp_t*));

		if(oldpp)

			*oldpp = pp;

		if(!pp && (np=nv_search(name,shp->fun_tree,0))&&np->nvalue.ip)

			return(1);

		if(!pp)

			*stakptr(PATH_OFFSET) = 0;

	}

	if(flag==0 || !pp || (pp->flags&PATH_FPATH))

	{

		if(!pp)

			pp=sh_isstate(SH_DEFPATH)?shp->defpathlist:shp->pathlist;

		if(pp && strmatch(name,e_alphanum)  && (fno=path_opentype(shp,name,pp,1))>=0)

		{

			if(flag==2)

			{

				sh_close(fno);

				return(1);

			}

			funload(shp,fno,name);

			return(1);

		}

		*stakptr(PATH_OFFSET) = 0;

		return(0);

	}

	else if(pp && !sh_isstate(SH_DEFPATH) && *name!='/' && flag<3)

	{

		if(np=nv_search(name,shp->track_tree,NV_ADD))

			path_alias(np,pp);

	}

	return(0);

}

/*

 * do a path search and find the full pathname of file name

 */

Pathcomp_t *path_absolute(Shell_t *shp,register const char *name, Pathcomp_t *pp)

{

	register int	f,isfun;

	int		noexec=0;

	Pathcomp_t	*oldpp;

	Namval_t	*np;

	char		*cp;

	char		*bp;

	shp->path_err = ENOENT;

	if(!pp && !(pp=path_get(shp,"")))

		return(0);

	shp->path_err = 0;

	while(1)

	{

		sh_sigcheck(shp);

		shp->bltin_dir = 0;

		while(oldpp=pp)

		{

			pp = path_nextcomp(shp,pp,name,0);

			if(!(oldpp->flags&PATH_SKIP))

				break;

		}

		if(!oldpp)

		{

			shp->path_err = ENOENT;

			return(0);

		}

		isfun = (oldpp->flags&PATH_FPATH);

		if(!isfun && !sh_isoption(SH_RESTRICTED))

		{

#if SHOPT_DYNAMIC

			Shbltin_f addr;

			int n;

#endif

			if(*stakptr(PATH_OFFSET)=='/' && nv_search(stakptr(PATH_OFFSET),shp->bltin_tree,0))

				return(oldpp);

#if SHOPT_DYNAMIC

			n = staktell();

			stakputs("b_");

			stakputs(name);

			stakputc(0);

			if((addr = sh_getlib(shp, stakptr(n), oldpp)) &&

			   (np = sh_addbuiltin(stakptr(PATH_OFFSET),addr,NiL)) &&

			   nv_isattr(np,NV_BLTINOPT))

			{

				shp->bltin_dir = 0;

				return(oldpp);

			}

			stakseek(n);

			while(bp = oldpp->blib)

			{

				char *fp;

				void *dll;

				int m;

				if(fp = strchr(bp, ':'))

				{

					*fp++ = 0;

					oldpp->blib = fp;

					fp = 0;

				}

				else

				{

					fp = oldpp->bbuf;

					oldpp->blib = oldpp->bbuf = 0;

				}

				n = staktell();

				stakputs("b_");

				stakputs(name);

				stakputc(0);

				m = staktell();

				shp->bltin_dir = oldpp->name;

				if(*bp!='/')

				{

					stakputs(oldpp->name);

					stakputc('/');

				}

				stakputs(bp);

				stakputc(0);

				if(cp = strrchr(stakptr(m),'/'))

					cp++;

				else

					cp = stakptr(m);

				if(!strcmp(cp,LIBCMD) &&

				   (addr=(Shbltin_f)dlllook((void*)0,stakptr(n))) &&

				   (np = sh_addbuiltin(stakptr(PATH_OFFSET),addr,NiL)) &&

				   nv_isattr(np,NV_BLTINOPT))

				{

				found:

					if(fp)

						free(fp);

					shp->bltin_dir = 0;

					return(oldpp);

				}

#ifdef SH_PLUGIN_VERSION

				if (dll = dllplugin(SH_ID, stakptr(m), NiL, SH_PLUGIN_VERSION, NiL, RTLD_LAZY, NiL, 0))

					sh_addlib(shp,dll,stakptr(m),oldpp);

#else

#if (_AST_VERSION>=20040404)

				if (dll = dllplug(SH_ID, stakptr(m), NiL, RTLD_LAZY, NiL, 0))

#else

				if (dll = dllfind(stakptr(m), NiL, RTLD_LAZY, NiL, 0))

#endif

				{

					/*

					 * this detects the 2007-05-11 builtin context change and also

					 * the 2008-03-30 opt_info.num change that hit libcmd::b_head

					 */

					if (libcmd && !dlllook(dll, "b_pids"))

					{

						dlclose(dll);

						dll = 0;

					}

					else

						sh_addlib(shp,dll,stakptr(m),oldpp);

				}

#endif

				if(dll &&

				   (addr=(Shbltin_f)dlllook(dll,stakptr(n))) &&

				   (!(np = sh_addbuiltin(stakptr(PATH_OFFSET),NiL,NiL)) || np->nvalue.bfp!=(Nambfp_f)addr) &&

				   (np = sh_addbuiltin(stakptr(PATH_OFFSET),addr,NiL)))

				{

					np->nvenv = dll;

					goto found;

				}

				if(*stakptr(PATH_OFFSET)=='/' && nv_search(stakptr(PATH_OFFSET),shp->bltin_tree,0))

					goto found;

				if(fp)

					free(fp);

				stakseek(n);

			}

#endif /* SHOPT_DYNAMIC */

		}

		shp->bltin_dir = 0;

		sh_stats(STAT_PATHS);

		f = canexecute(shp,stakptr(PATH_OFFSET),isfun);

		if(isfun && f>=0 && (cp = strrchr(name,'.')))

		{

			*cp = 0;

			if(nv_open(name,sh_subfuntree(1),NV_NOARRAY|NV_IDENT|NV_NOSCOPE))

				f = -1;

			*cp = '.';

		}

		if(isfun && f>=0)

		{

			nv_onattr(nv_open(name,sh_subfuntree(1),NV_NOARRAY|NV_IDENT|NV_NOSCOPE),NV_LTOU|NV_FUNCTION);

			funload(shp,f,name);

			close(f);

			f = -1;

			return(0);

		}

		else if(f>=0 && (oldpp->flags & PATH_STD_DIR))

		{