@@ -23,6 +23,9 @@

  *	David Korn

  *

  */

+/*

+ * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.

+ */

 #include	<ast.h>

 #include	<sfio.h>

 extern int	sh_isdevfd(const char*);

 extern int	sh_source(Shell_t*, Sfio_t*, const char*);

+extern int	VALIDATE_FD(Shell_t *, int);

+

+#define	VALIDATE_FD(shp, fd) \

+	(((fd) >= (shp)->gd->lim.open_max) ? sh_iovalidfd(shp, fd) : 1)

+

+

 /* the following are readonly */

 extern const char	e_pexists[];

 extern const char	e_query[];

 extern const char	e_stdprompt[];

 extern const char	e_supprompt[];

 extern const char	e_ambiguous[];

+

 #endif /* KSHELL */

 		((struct checkpt*)shp->jmplist)->mode = SH_JMPERREXIT;

 		errormsg(SH_DICT,ERROR_system(1),e_toomany);

 	}

-	if(f2 >= shp->gd->lim.open_max)

-		sh_iovalidfd(shp,f2);

+

+	VALIDATE_FD(shp, fd);

+	VALIDATE_FD(shp, f2);

+

 	if(shp->fdptrs[fd]=shp->fdptrs[f2])

 	{

 		if(f2==job.fd)

  */

 int sh_iorenumber(Shell_t *shp, register int f1,register int f2)

 {

-	register Sfio_t *sp = shp->sftable[f2];

+	register Sfio_t *sp;

+

+	VALIDATE_FD(shp, f1);

+	VALIDATE_FD(shp, f2);

+

+	sp = shp->sftable[f2];

 	if(f1!=f2)

 	{

 		/* see whether file descriptor is in use */

 		if(f2<=2)

 			sfset(sp,SF_SHARE|SF_PUBLIC,1);

 	}

-	if(f2>=shp->gd->lim.open_max)

-		sh_iovalidfd(shp,f2);

+	VALIDATE_FD(shp, f2);

 	return(f2);

 }

 	register int r = 0;

 	if(fd<0)

 		return(-1);

-	if(fd >= shp->gd->lim.open_max)

-		sh_iovalidfd(shp,fd);

+

+	VALIDATE_FD(shp, fd);

+

 	if(!(sp=shp->sftable[fd]) || sfclose(sp) < 0)

 	{

 		mode = (IOREAD|IOWRITE);

 	else

 		mode = IOREAD;

+	VALIDATE_FD(shp, fd);

 	shp->fdstatus[fd] = mode;

 	return(fd);

 }

 	if(fdold<0 || fdold>2)

 		return(fdold);

 	fdnew = sh_iomovefd(dup(fdold));

+	VALIDATE_FD(shp, fdold);

+	VALIDATE_FD(shp, fdnew);

 	shp->fdstatus[fdnew] = (shp->fdstatus[fdold]&~IOCLEX);

 	close(fdold);

 	shp->fdstatus[fdold] = IOCLOSE;

 		sh_close(fd);

 	else

 		pv[out] = sh_iomovefd(fd);

+

+	VALIDATE_FD(shp, pv[out]);

+

 	if(fcntl(pv[out],F_SETFD,FD_CLOEXEC) >=0)

 		shp->fdstatus[pv[out]] |= IOCLEX;

 	shp->fdstatus[pv[out]] = (out?IOWRITE:IOREAD);

 		errormsg(SH_DICT,ERROR_system(1),e_pipe);

 	}

 	fcntl(pv[out],F_SETFD,FD_CLOEXEC);

+

+	VALIDATE_FD(shp, pv[out]);

+

 	shp->fdstatus[pv[out]] |= IOCLEX;

 	pv[1-out] = -1;

 	pv[2] = port;

 static int io_patseek(Shell_t *shp, regex_t *rp, Sfio_t* sp, int flags)

 {

 	char	*cp, *match;

-	int	r, fd=sffileno(sp), close_exec = shp->fdstatus[fd]&IOCLEX;

+	int	r, fd, close_exec;

 	int	was_share,s=(PIPE_BUF>SF_BUFSIZE?SF_BUFSIZE:PIPE_BUF);

 	size_t	n,m;

+

+	fd = sffileno(sp);

+	VALIDATE_FD(shp, fd);

+	close_exec = shp->fdstatus[fd]&IOCLEX;

 	shp->fdstatus[sffileno(sp)] |= IOCLEX;

 	if(fd==0)

 		was_share = sfset(sp,SF_SHARE,1);

 static Sfoff_t	file_offset(Shell_t *shp, int fn, char *fname)

 {

-	Sfio_t		*sp = shp->sftable[fn];

+	Sfio_t		*sp;

 	char		*cp;

 	Sfoff_t		off;

 	struct Eof	endf;

 	Namval_t	*mp = nv_open("EOF",shp->var_tree,0);

 	Namval_t	*pp = nv_open("CUR",shp->var_tree,0);

+

+	VALIDATE_FD(shp, fn);

+

+	sp = shp->sftable[fn];

+

 	memset(&endf,0,sizeof(struct Eof));

 	endf.fd = fn;

 	endf.hdr.disc = &EOF_disc;

 			if((iof&IOLSEEK) || ((iof&IOMOV) && *fname=='-'))

 				fn = nv_getnum(np);

 		}

-		if(fn>=shp->gd->lim.open_max && !sh_iovalidfd(shp,fn))

+		if (!VALIDATE_FD(shp, fn))

 			errormsg(SH_DICT,ERROR_system(1),e_file+4);

 		if(iof&IOLSEEK)

 		{

 						message = e_file;

 						goto fail;

 					}

+					VALIDATE_FD(shp, dupfd);

 					if(shp->subshell && dupfd==1)

 					{

 						if(sfset(sfstdout,0,0)&SF_STRING)

 					goto traceit;

 				if((fd=sh_fcntl(dupfd,F_DUPFD,3))<0)

 					goto fail;

-				if(fd>= shp->gd->lim.open_max)

-					sh_iovalidfd(shp,fd);

+				VALIDATE_FD(shp, fd);

 				sh_iocheckfd(shp,dupfd);

 				shp->fdstatus[fd] = (shp->fdstatus[dupfd]&~IOCLEX);

 				if(toclose<0 && shp->fdstatus[fd]&IOREAD)

 			}

 			if(iof&IOLSEEK)

 			{

-				Sfio_t *sp = shp->sftable[fn];

+				Sfio_t *sp;

+

+				VALIDATE_FD(shp, fn);

+

+				sp = shp->sftable[fn];

 				r = shp->fdstatus[fn];

 				if(!(r&(IOSEEK|IONOSEEK)))

 					r = sh_iocheckfd(shp,fn);

 			}

 			if(fd<0)

 			{

+				VALIDATE_FD(shp, fn);

 				if(sh_inuse(shp,fn) || (fn && fn==shp->infd))

 				{

 					if(fn>9 || !(shp->inuse_bits&(1<<fn)))

 					{

 						if((fn=fcntl(fd,F_DUPFD,10)) < 0)

 							goto fail;

-						if(fn>=shp->gd->lim.open_max && !sh_iovalidfd(shp,fn))

+						if (!VALIDATE_FD(shp, fn))

 							goto fail;

 	filemap[shp->topfd++].save_fd = savefd;

 	if(savefd >=0)

 	{

-		register Sfio_t* sp = shp->sftable[origfd];

+		register Sfio_t* sp;

+

+		VALIDATE_FD(shp, origfd);

+		VALIDATE_FD(shp, savefd);

+

+		sp = shp->sftable[origfd];

 		/* make saved file close-on-exec */

 		sh_fcntl(savefd,F_SETFD,FD_CLOEXEC);

 		if(origfd==job.fd)

 			filemap[newfd++] = filemap[fd];

 		else

 		{

+			VALIDATE_FD(shp, savefd);

 			shp->sftable[savefd] = 0;

 			sh_close(savefd);

 		}

 		{

 			if ((savefd = filemap[fd].save_fd) >= 0)

 			{

+				VALIDATE_FD(shp, savefd);

 				shp->sftable[savefd] = 0;

 				sh_close(savefd);

 			}

 			continue;

 		}

 		origfd = filemap[fd].orig_fd;

+		VALIDATE_FD(shp, origfd);

 		if(origfd<0)

 		{

 			/* this should never happen */

 			savefd = filemap[fd].save_fd;

+			VALIDATE_FD(shp, savefd);

 			shp->sftable[savefd] = 0;

 			sh_close(savefd);

 			return;

 		sh_close(origfd);

 		if ((savefd = filemap[fd].save_fd) >= 0)

 		{

+			VALIDATE_FD(shp, savefd);

 			sh_fcntl(savefd, F_DUPFD, origfd);

 			if(savefd==job.fd)

 				job.fd=origfd;

 int sh_iocheckfd(Shell_t *shp, register int fd)

 {

 	register int flags, n;

+

+	VALIDATE_FD(shp, fd);

+

 	if((n=shp->fdstatus[fd])&IOCLOSE)

 		return(n);

 	if(!(n&(IOREAD|IOWRITE)))

 		return;

 	}

 #endif

 		return;

 	if(sh_isstate(SH_NOTRACK))

 		return;

 {

 	Shell_t *shp = sh_getinterp();

 	register Sfio_t *sp;

+

+	VALIDATE_FD(shp, fd);

 	if(sp=shp->sftable[fd])

 		return(sfread(sp,buff,n));

 	else

 {

 	Shell_t *shp = sh_getinterp();

 	register Sfio_t *sp;

+

+	VALIDATE_FD(shp, fd);

 	if(sp=shp->sftable[fd])

 		return(sfwrite(sp,buff,n));

 	else

 {

 	Shell_t *shp = sh_getinterp();

 	register Sfio_t *sp;

+

+	VALIDATE_FD(shp, fd);

 	if((sp=shp->sftable[fd]) && (sfset(sp,0,0)&(SF_READ|SF_WRITE)))

 		return(sfseek(sp,offset,whence));

 	else

 {

 	Shell_t *shp = sh_getinterp();

 	register int fd = dup(old);

+

+	VALIDATE_FD(shp, old);

+	VALIDATE_FD(shp, fd);

 	if(fd>=0)

 	{

 		if(shp->fdstatus[old] == IOCLOSE)

 	arg =  va_arg(ap, int) ;

 	va_end(ap);

 	newfd = fcntl(fd,op,arg);

+

+	VALIDATE_FD(shp, fd);

+	VALIDATE_FD(shp, newfd);

+

 	if(newfd>=0) switch(op)

 	{

 	    case F_DUPFD:

 		if(shp->fdstatus[fd] == IOCLOSE)

 			shp->fdstatus[fd] = 0;

-		if(newfd>=shp->gd->lim.open_max)

-			sh_iovalidfd(shp,newfd);

 		shp->fdstatus[newfd] = (shp->fdstatus[fd]&~IOCLEX);

 		if(fdnotify)

 			(*fdnotify)(fd,newfd);

 		return(iop);

 	if(mode==SF_READ && !(n&IOREAD))

 		return(iop);

+	VALIDATE_FD(shp, fd);

 	if(!(iop = shp->sftable[fd]))

 		iop=sh_iostream(shp,fd);

 	return(iop);

 {

 	Shell_t	*shp = sh_getinterp();

 	register int status;

-	Sfio_t *sp = shp->sftable[fd];

+	Sfio_t *sp;

+

+	VALIDATE_FD(shp, fd);

+	sp = shp->sftable[fd];

 	if(!sp  && (status = sh_iocheckfd(shp,fd))!=IOCLOSE)

 	{

 		register int flags=0;

@@ -25,6 +25,9 @@

  * AT&T Labs

  *

  */

+/*

+ * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.

+ */

 #include	<ast.h>

 #include	<stak.h>

 	else

 		lp->lastline = shp->inlineno;

 	tokstr = fmttoken(lp,tok,tokbuf);

+	VALIDATE_FD(shp, shp->infd);

 	if((sp=fcfile()) || (shp->infd>=0 && (sp=shp->sftable[shp->infd])))

 	{

 		/* clear out any pending input */

 			sh_popcontext(mp->shp,&buff);

 			if(r==0 && ip && (ip->iofile&IOLSEEK))

 			{

+				VALIDATE_FD(mp->shp, fd);

 				if(sp=mp->shp->sftable[fd])

 					num = sftell(sp);

 				else

@@ -26,6 +26,9 @@

  * AT&T Labs

  *

  */

+/*

+ * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.

+ */

 #include	<ast.h>

 #include	<sfio.h>

 		if(fno > 0)

 		{

 			int r;

+			VALIDATE_FD(shp, fno);

 			if(fno < 10 && ((r=sh_fcntl(fno,F_DUPFD,10))>=10))

 			{

+				VALIDATE_FD(shp, r);

 				shp->fdstatus[r] = shp->fdstatus[fno];

 				sh_close(fno);

 				fno = r;

@@ -23,6 +23,9 @@

  * AT&T Labs

  *

  */

+/*

+ * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.

+ */

 #include	"defs.h"

 #include	<fcin.h>

 	if(sp=fcfile())

 		while(sfstack(sp,SF_POPSTACK));

 	job_clear();

+	VALIDATE_FD(shp, shp->infd);

 	if(shp->infd>0 && (shp->fdstatus[shp->infd]&IOCLEX))

 		sh_close(shp->infd);

 	sh_setstate(sh_state(SH_FORKED));

 		if((sp->tmpfd = fd = fcntl(1,F_DUPFD,10)) >= 0)

 		{

 			fcntl(fd,F_SETFD,FD_CLOEXEC);

+			VALIDATE_FD(shp, fd);

 			shp->fdstatus[fd] = shp->fdstatus[1]|IOCLEX;

 			close(1);

 		}

 		}

 		else

 		{

+			VALIDATE_FD(shp, fd);

 			shp->fdstatus[fd] = IOREAD|IOWRITE;

 			sfsync(sfstdout);

 			if(fd==1)

 					((struct checkpt*)shp->jmplist)->mode = SH_JMPERREXIT;

 					errormsg(SH_DICT,ERROR_system(1),e_toomany);

 				}

+				VALIDATE_FD(shp, fd);

 				shp->sftable[fd] = iop;

 				fcntl(fd,F_SETFD,FD_CLOEXEC);

 				shp->fdstatus[fd] = (shp->fdstatus[1]|IOCLEX);

 	usepipe++;

 	fcntl(subpipe[0],F_SETFD,FD_CLOEXEC);

 	subpipe[2] = fcntl(1,F_DUPFD,10);

+	VALIDATE_FD(shp, subpipe[1]);

 	shp->fdstatus[subpipe[2]] = shp->fdstatus[1];

 	close(1);

 	close(1);

 	fcntl(subpipe[2], F_DUPFD, 1);

+	VALIDATE_FD(shp, subpipe[2]);

 	shp->fdstatus[1] = shp->fdstatus[subpipe[2]];

 	if(subdup) for(n=0; n < 10; n++)

 			if(filt > 2)

 			{

 				shp->coutpipe = shp->inpipe[1];

+				VALIDATE_FD(shp, shp->coutpipe);

 				shp->fdptrs[shp->coutpipe] = &shp->coutpipe;

 			}

 		}

 						if(shp->cpipe[0]<0 || shp->cpipe[1] < 0)

 						{

 							sh_copipe(shp,shp->outpipe=shp->cpipe,0);

+							VALIDATE_FD(shp, shp->cpipe[0]);

 							shp->fdptrs[shp->cpipe[0]] = shp->cpipe;

 						}

 						sh_copipe(shp,shp->inpipe=pipes,0);

 		if((outfd=shp->cpipe[1]) < 10) 

 		{

 		        int fd=fcntl(shp->cpipe[1],F_DUPFD,10);

+			VALIDATE_FD(shp, outfd);

+			VALIDATE_FD(shp, fd);

 			if(fd>=10)

 			{

 			        shp->fdstatus[fd] = (shp->fdstatus[outfd]&~IOCLEX);

 				shp->cpipe[1] = fd;

 			}

 		}

+		VALIDATE_FD(shp, shp->cpipe[0]);

+		VALIDATE_FD(shp, shp->cpipe[1]);

+

 		if(fcntl(*shp->cpipe,F_SETFD,FD_CLOEXEC)>=0)