/*	$OpenBSD: c_sh.c,v 1.59 2016/03/04 15:11:06 deraadt Exp $	*/

/*

 * built-in Bourne commands

 */

#include <sys/resource.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <ctype.h>

#include <errno.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "sh.h"

static void p_time(struct shf *, int, struct timeval *, int, char *, char *);

/* :, false and true */

int

c_label(char **wp)

}

int

c_shift(char **wp)

	int n;

	long val;

	char *arg;

	} else

	}

	}

}

int

c_umask(char **wp)

	int i;

	char *cp;

	mode_t old_umask;

	int optc;

		case 'S':

		case '?':

		}

			char buf[18];

			int j;

			}

		} else

	} else {

		mode_t new_umask;

			}

		} else {

			/* symbolic format */

			int positions, new_val;

			char op;

					case 'a':

					case 'u':

					case 'g':

					case 'o':

						break;

					}

						  break;

					case 's': /* ignored */

						  break;

					}

				case '-':

				case '=':

					    (new_umask & ~(positions * 07));

				case '+':

				}

			}

			}

		}

	}

}

int

c_dot(char **wp)

	char *file, *cp;

	char **argv;

	int argc;

	int i;

	int err;

	}

	/* Set positional parameters? */

			;

	} else {

	}

	}

}

int

c_wait(char **wp)

{

	int sig;

			;

	} else {

	}

}

int

c_read(char **wp)

	int expanding;

	char *cp;

	struct shf *shf;

	int optc;

	const char *emsg;

	XString cs, xs;

	struct tbl *vp;

		case 'p':

			}

			break;

		case 'r':

		case 's':

		case 'u':

			}

			break;

		case '?':

		}

	/* Since we can't necessarily seek backwards on non-regular files,

	 * don't buffer them so we can't read too much.

	 */

			/* at&t ksh says it prints prompt on fd if it's open

			 * for writing and is a tty, but it doesn't do it

			 * (it also doesn't check the interactive flag,

			 * as is indicated in the Kornshell book).

			 */

		}

	}

	/* If we are reading from the co-process for the first time,

	 * make sure the other side of the pipe is closed first.  This allows

	 * the detection of eof.

	 *

	 * This is not compatible with at&t ksh... the fd is kept so another

	 * coproc can be started with same output, however, this means eof

	 * can't be detected...  This is why it is closed here.

	 * If this call is removed, remove the eof check below, too.

	 * coproc_readw_close(fd);

	 */

			while (1) {

				    shf->errno_ == EINTR) {

					/* Was the offending signal one that

					 * would normally kill a process?

					 * If so, pretend the read was killed.

					 */

					/* non fatal (eg, CHLD), carry on */

					}

				}

				break;

			}

			}

						/* set prompt in case this is

						 * called from .profile or $ENV

						 */

					}

				continue;

			}

			}

			}

		}

		/* strip trailing IFS white space from last variable */

			    ctype(cp[-1], C_IFSWS))

		/* Must be done before setting export. */

		}

		}

	}

	}

	/* if this is the co-process fd, close the file descriptor

	 * (can get eof if and only if all processes are have died, ie,

	 * coproc.njobs is 0 and the pipe is closed).

	 */

}

int

c_eval(char **wp)

	struct source *s;

	int rv;

		/*

		 * Handle case where the command is empty due to failed

		 * command substitution, eg, eval "$(false)".

		 * In this case, shell() will not set/change exstat (because

		 * compiled tree is empty), so will use this value.

		 * subst_exstat is cleared in execute(), so should be 0 if

		 * there were no substitutions.

		 *

		 * A strict reading of POSIX says we don't do this (though

		 * it is traditionally done). [from 1003.2-1992]

		 *    3.9.1: Simple Commands

		 *	... If there is a command name, execution shall

		 *	continue as described in 3.9.1.1.  If there

		 *	is no command name, but the command contained a command

		 *	substitution, the command shall complete with the exit

		 *	status of the last command substitution

		 *    3.9.1.1: Command Search and Execution

		 *	...(1)...(a) If the command name matches the name of

		 *	a special built-in utility, that special built-in

		 *	utility shall be invoked.

		 * 3.14.5: Eval

		 *	... If there are no arguments, or only null arguments,

		 *	eval shall return an exit status of zero.

		 */

	}

}

int

c_trap(char **wp)

	int i;

	char *s;

	Trap *p;

			}

		}

	}

	/*

	 * Use case sensitive lookup for first arg so the

	 * command 'exit' isn't confused with the pseudo-signal

	 * 'EXIT'.

	 */

	/* set/clear traps */

		}

	}

}

int

c_exitreturn(char **wp)

	int n;

	char *arg;

		} else

	}

		struct env *ep;

		/* need to tell if this is exit or return so trap exit will

		 * work right (POSIX)

		 */

			}

	}

	}

	/* NOTREACHED */

	return 0;

}

int

c_brkcont(char **wp)

	int n, quit;

	char *arg;

		/* at&t ksh does this for non-interactive shells only - weird */

	}

	/* Stop at E_NONE, E_PARSE, E_FUNC, or E_INCL */

		}

		/* at&t ksh doesn't print a message - just does what it

		 * can.  We print a message 'cause it helps in debugging

		 * scripts, but don't generate an error (ie, keep going).

		 */

		}

		/* POSIX says if n is too big, the last enclosing loop

		 * shall be used.  Doesn't say to print an error but we

		 * do anyway 'cause the user messed up.

		 */

		    wp[0], wp[0], n - quit);

	}

	/* NOTREACHED */

}

int

c_set(char **wp)

	int argi, setargs;

		static const char *const args [] = { "set", "-", NULL };

	}

	/* set $# and $* */

			;

	}

	/* POSIX says set exit status is 0, but old scripts that use

	 * getopt(1), use the construct: set -- `getopt ab:c "$@"`

	 * which assumes the exit value set will be that of the ``

	 * (subst_exstat is cleared in execute() so that it will be 0

	 * if there are no command substitutions).

	 */

}

int

c_unset(char **wp)

	char *id;

		case 'f':

		case 'v':

		case '?':

		}

			}

		} else {		/* unset function */

		}

}

static void

p_time(struct shf *shf, int posix, struct timeval *tv, int width, char *prefix,

    char *suffix)

		    width, (long long)tv->tv_sec, tv->tv_usec / 10000, suffix);

	else

		    width, (long long)tv->tv_sec / 60,

		    (long long)tv->tv_sec % 60,

		    tv->tv_usec / 10000, suffix);

int

c_times(char **wp)

{

	struct rusage usage;

}

/*

 * time pipeline (really a statement, not a built-in command)

 */

int

timex(struct op *t, int f, volatile int *xerrok)

#define TF_NOARGS	BIT(0)

#define TF_NOREAL	BIT(1)		/* don't report real time */

#define TF_POSIX	BIT(2)		/* report in posix format */

	struct rusage ru0, ru1, cru0, cru1;

	struct timeval usrtime, systime, tv0, tv1;

	extern struct timeval j_usrtime, j_systime; /* computed by j_wait */

		/*

		 * Two ways of getting cpu usage of a command: just use t0

		 * and t1 (which will get cpu usage from other jobs that

		 * finish while we are executing t->left), or get the

		 * cpu usage of t->left. at&t ksh does the former, while

		 * pdksh tries to do the later (the j_usrtime hack doesn't

		 * really work as it only counts the last job).

		 */

	} else

	} else {

	}

		else

	}

	else

	else

}

void

timex_hook(struct op *t, char **volatile *app)

	int optc;

	int i, j;

	Getopt opt;

		case 'p':

		case '?':

		case ':':

			    opt.optarg);

		}

	/* Copy command words down over options. */

			;

	}

/* exec with no args - args case is taken care of in comexec() */

int

c_exec(char **wp)

	int i;

	/* make sure redirects stay in place */

			/*

			 * For ksh keep anything > 2 private,

			 * for sh, let them be (POSIX says what

			 * happens is unspecified and the bourne shell

			 * keeps them open).

			 */

		}

	}

}

static int

c_suspend(char **wp)

{

	}

		/* Can't suspend an orphaned process group. */

		    getsid(parent) != getsid(0)) {

		}

	}

}

/* dummy function, special case in comexec() */

int

c_builtin(char **wp)

{

}

extern	int c_test(char **wp);			/* in c_test.c */

extern	int c_ulimit(char **wp);		/* in c_ulimit.c */

/* A leading = means assignments before command are kept;

 * a leading * means a POSIX special builtin;

 * a leading + means a POSIX regular builtin

 * (* and + should not be combined).

 */

const struct builtin shbuiltins [] = {

	{"*=.", c_dot},

	{"*=:", c_label},

	{"[", c_test},

	{"*=break", c_brkcont},

	{"=builtin", c_builtin},

	{"*=continue", c_brkcont},

	{"*=eval", c_eval},

	{"*=exec", c_exec},

	{"*=exit", c_exitreturn},

	{"+false", c_label},

	{"*=return", c_exitreturn},

	{"*=set", c_set},

	{"*=shift", c_shift},

	{"*=times", c_times},

	{"*=trap", c_trap},

	{"+=wait", c_wait},

	{"+read", c_read},

	{"test", c_test},

	{"+true", c_label},

	{"ulimit", c_ulimit},

	{"+umask", c_umask},

	{"*=unset", c_unset},

	{"suspend", c_suspend},

	{NULL, NULL}

};