/*	$OpenBSD: c_ksh.c,v 1.37 2015/09/10 22:48:58 nicm Exp $	*/

/*	$OpenBSD: c_sh.c,v 1.46 2015/07/20 20:46:24 guenther Exp $	*/

/*	$OpenBSD: c_test.c,v 1.18 2009/03/01 20:11:06 otto Exp $	*/

/*	$OpenBSD: c_ulimit.c,v 1.19 2013/11/28 10:33:37 sobrado Exp $	*/

/*-

 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,

 *		 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017

 *	mirabilos <m@mirbsd.org>

 *

 * Provided that these terms and disclaimer and all copyright notices

 * are retained or reproduced in an accompanying document, permission

 * is granted to deal in this work without restriction, including un-

 * limited rights to use, publicly perform, distribute, sell, modify,

 * merge, give away, or sublicence.

 *

 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to

 * the utmost extent permitted by applicable law, neither express nor

 * implied; without malicious intent or gross negligence. In no event

 * may a licensor, author or contributor be held liable for indirect,

 * direct, other damage, loss, or other issues arising in any way out

 * of dealing in the work, even if advised of the possibility of such

 * damage or existence of a defect, except proven that it results out

 * of said person's immediate fault when using the work as intended.

 */

#include "sh.h"

#if HAVE_SELECT

#if HAVE_SYS_BSDTYPES_H

#include <sys/bsdtypes.h>

#endif

#if HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#if HAVE_BSTRING_H

#include <bstring.h>

#endif

#endif

__RCSID("$MirOS: src/bin/mksh/funcs.c,v 1.353 2018/01/14 01:26:49 tg Exp $");

#if HAVE_KILLPG

/*

 * use killpg if < -1 since -1 does special things

 * for some non-killpg-endowed kills

 */

#define mksh_kill(p,s)	((p) < -1 ? killpg(-(p), (s)) : kill((p), (s)))

#else

/* cross fingers and hope kill is killpg-endowed */

#define mksh_kill	kill

#endif

/* XXX conditions correct? */

#if !defined(RLIM_INFINITY) && !defined(MKSH_NO_LIMITS)

#define MKSH_NO_LIMITS	1

#endif

#ifdef MKSH_NO_LIMITS

#define c_ulimit	c_true

#endif

#if !defined(MKSH_UNEMPLOYED) && HAVE_GETSID

static int c_suspend(const char **);

#endif

static int do_whence(const char **, int, bool, bool);

/* getn() that prints error */

static int

bi_getn(const char *as, int *ai)

{

	int rv;

	if (!(rv = getn(as, ai)))

		bi_errorf(Tf_sD_s, Tbadnum, as);

	return (rv);

}

static int

c_true(const char **wp MKSH_A_UNUSED)

{

	return (0);

}

static int

c_false(const char **wp MKSH_A_UNUSED)

{

	return (1);

}

/*

 * A leading = means assignments before command are kept.

 * A leading * means a POSIX special builtin.

 * A leading ^ means declaration utility, - forwarder.

 */

const struct builtin mkshbuiltins[] = {

	{Tsgdot, c_dot},

	{"*=:", c_true},

	{Tbracket, c_test},

	/* no =: AT&T manual wrong */

	{Talias, c_alias},

	{Tsgbreak, c_brkcont},

	{T__builtin, c_builtin},

	{Tbuiltin, c_builtin},

	{Tbcat, c_cat},

	{Tcd, c_cd},

	/* dash compatibility hack */

	{"chdir", c_cd},

	{T_command, c_command},

	{Tsgcontinue, c_brkcont},

	{"echo", c_print},

	{"*=eval", c_eval},

	{"*=exec", c_exec},

	{"*=exit", c_exitreturn},

	{Tdsgexport, c_typeset},

	{Tfalse, c_false},

	{"fc", c_fc},

	{Tgetopts, c_getopts},

	/* deprecated, replaced by typeset -g */

	{"^=global", c_typeset},

	{Tjobs, c_jobs},

	{"kill", c_kill},

	{"let", c_let},

	{"print", c_print},

	{"pwd", c_pwd},

	{Tread, c_read},

	{Tdsgreadonly, c_typeset},

	{"!realpath", c_realpath},

	{"~rename", c_rename},

	{"*=return", c_exitreturn},

	{Tsgset, c_set},

	{"*=shift", c_shift},

	{Tgsource, c_dot},

#if !defined(MKSH_UNEMPLOYED) && HAVE_GETSID

	{Tsuspend, c_suspend},

#endif

	{"test", c_test},

	{"*=times", c_times},

	{"*=trap", c_trap},

	{Ttrue, c_true},

	{Tdgtypeset, c_typeset},

	{"ulimit", c_ulimit},

	{"umask", c_umask},

	{Tunalias, c_unalias},

	{"*=unset", c_unset},

	{"wait", c_wait},

	{"whence", c_whence},

#ifndef MKSH_UNEMPLOYED

	{Tbg, c_fgbg},

	{Tfg, c_fgbg},

#endif

#ifndef MKSH_NO_CMDLINE_EDITING

	{"bind", c_bind},

#endif

#if HAVE_MKNOD

	{"mknod", c_mknod},

#endif

#ifdef MKSH_PRINTF_BUILTIN

	{"~printf", c_printf},

#endif

#if HAVE_SELECT

	{"sleep", c_sleep},

#endif

#ifdef __MirBSD__

	/* alias to "true" for historical reasons */

	{"domainname", c_true},

#endif

#ifdef __OS2__

	{Textproc, c_true},

#endif

	{NULL, (int (*)(const char **))NULL}

};

struct kill_info {

	int num_width;

	int name_width;

};

static const struct t_op {

	char op_text[4];

	Test_op op_num;

} u_ops[] = {

	{"-a",	TO_FILAXST },

	{"-b",	TO_FILBDEV },

	{"-c",	TO_FILCDEV },

	{"-d",	TO_FILID },

	{"-e",	TO_FILEXST },

	{"-f",	TO_FILREG },

	{"-G",	TO_FILGID },

	{"-g",	TO_FILSETG },

	{"-H",	TO_FILCDF },

	{"-h",	TO_FILSYM },

	{"-k",	TO_FILSTCK },

	{"-L",	TO_FILSYM },

	{"-n",	TO_STNZE },

	{"-O",	TO_FILUID },

	{"-o",	TO_OPTION },

	{"-p",	TO_FILFIFO },

	{"-r",	TO_FILRD },

	{"-S",	TO_FILSOCK },

	{"-s",	TO_FILGZ },

	{"-t",	TO_FILTT },

	{"-u",	TO_FILSETU },

	{"-v",	TO_ISSET },

	{"-w",	TO_FILWR },

	{"-x",	TO_FILEX },

	{"-z",	TO_STZER },

	{"",	TO_NONOP }

};

static const struct t_op b_ops[] = {

	{"=",	TO_STEQL },

	{"==",	TO_STEQL },

	{"!=",	TO_STNEQ },

	{"<",	TO_STLT },

	{">",	TO_STGT },

	{"-eq",	TO_INTEQ },

	{"-ne",	TO_INTNE },

	{"-gt",	TO_INTGT },

	{"-ge",	TO_INTGE },

	{"-lt",	TO_INTLT },

	{"-le",	TO_INTLE },

	{"-ef",	TO_FILEQ },

	{"-nt",	TO_FILNT },

	{"-ot",	TO_FILOT },

	{"",	TO_NONOP }

};

static int test_oexpr(Test_env *, bool);

static int test_aexpr(Test_env *, bool);

static int test_nexpr(Test_env *, bool);

static int test_primary(Test_env *, bool);

static Test_op ptest_isa(Test_env *, Test_meta);

static const char *ptest_getopnd(Test_env *, Test_op, bool);

static void ptest_error(Test_env *, int, const char *);

static void kill_fmt_entry(char *, size_t, unsigned int, const void *);

static void p_time(struct shf *, bool, long, int, int,

    const char *, const char *);

int

c_pwd(const char **wp)

{

	int optc;

	bool physical = tobool(Flag(FPHYSICAL));

	char *p, *allocd = NULL;

	while ((optc = ksh_getopt(wp, &builtin_opt, "LP")) != -1)

		switch (optc) {

		case 'L':

			physical = false;

			break;

		case 'P':

			physical = true;

			break;

		case '?':

			return (1);

		}

	wp += builtin_opt.optind;

	if (wp[0]) {

		bi_errorf(Ttoo_many_args);

		return (1);

	}

	p = current_wd[0] ? (physical ? allocd = do_realpath(current_wd) :

	    current_wd) : NULL;

	/* LINTED use of access */

	if (p && access(p, R_OK) < 0)

		p = NULL;

	if (!p && !(p = allocd = ksh_get_wd())) {

		bi_errorf(Tf_sD_s, "can't determine current directory",

		    cstrerror(errno));

		return (1);

	}

	shprintf(Tf_sN, p);

	afree(allocd, ATEMP);

	return (0);

}

static const char *s_ptr;

static int s_get(void);

static void s_put(int);

int

c_print(const char **wp)

{

	int c;

	const char *s;

	char *xp;

	XString xs;

	struct {

		/* storage for columnisation */

		XPtrV words;

		/* temporary storage for a wide character */

		mksh_ari_t wc;

		/* output file descriptor (if any) */

		int fd;

		/* temporary storage for a multibyte character */

		char ts[4];

		/* output word separator */

		char ws;

		/* output line separator */

		char ls;

		/* output a trailing line separator? */

		bool nl;

		/* expand backslash sequences? */

		bool exp;

		/* columnise output? */

		bool col;

		/* print to history instead of file descriptor / stdout? */

		bool hist;

		/* print words as wide characters? */

		bool chars;

		/* writing to a coprocess (SIGPIPE blocked)? */

		bool coproc;

		bool copipe;

	} po;

	memset(&po, 0, sizeof(po));

	po.fd = 1;

	po.ws = ' ';

	po.ls = '\n';

	po.nl = true;

	if (wp[0][0] == 'e') {

		/* "echo" builtin */

		if (Flag(FPOSIX) ||

#ifndef MKSH_MIDNIGHTBSD01ASH_COMPAT

		    Flag(FSH) ||

#endif

		    Flag(FAS_BUILTIN)) {

			/* BSD "echo" cmd, Debian Policy 10.4 compliant */

			++wp;

 bsd_echo:

			if (*wp && !strcmp(*wp, "-n")) {

				po.nl = false;

				++wp;

			}

			po.exp = false;

		} else {

			bool new_exp, new_nl = true;

			/*-

			 * compromise between various historic echos: only

			 * recognise -Een if they appear in arguments with

			 * no illegal options; e.g. echo -nq outputs '-nq'

			 */

#ifdef MKSH_MIDNIGHTBSD01ASH_COMPAT

			/* MidnightBSD /bin/sh needs -e supported but off */

			if (Flag(FSH))

				new_exp = false;

			else

#endif

			/* otherwise compromise on -e enabled by default */

			  new_exp = true;

			goto print_tradparse_beg;

 print_tradparse_arg:

			if ((s = *wp) && *s++ == '-' && *s) {

 print_tradparse_ch:

				switch ((c = *s++)) {

				case 'E':

					new_exp = false;

					goto print_tradparse_ch;

				case 'e':

					new_exp = true;

					goto print_tradparse_ch;

				case 'n':

					new_nl = false;

					goto print_tradparse_ch;

				case '\0':

 print_tradparse_beg:

					po.exp = new_exp;

					po.nl = new_nl;

					++wp;

					goto print_tradparse_arg;

				}

			}

		}

	} else {

		/* "print" builtin */

		const char *opts = "AcelNnpRrsu,";

		const char *emsg;

		po.exp = true;

		while ((c = ksh_getopt(wp, &builtin_opt, opts)) != -1)

			switch (c) {

			case 'A':

				po.chars = true;

				break;

			case 'c':

				po.col = true;

				break;

			case 'e':

				po.exp = true;

				break;

			case 'l':

				po.ws = '\n';

				break;

			case 'N':

				po.ws = '\0';

				po.ls = '\0';

				break;

			case 'n':

				po.nl = false;

				break;

			case 'p':

				if ((po.fd = coproc_getfd(W_OK, &emsg)) < 0) {

					bi_errorf(Tf_coproc, emsg);

					return (1);

				}

				break;

			case 'R':

				/* fake BSD echo but don't reset other flags */

				wp += builtin_opt.optind;

				goto bsd_echo;

			case 'r':

				po.exp = false;

				break;

			case 's':

				po.hist = true;

				break;

			case 'u':

				if (!*(s = builtin_opt.optarg))

					po.fd = 0;

				else if ((po.fd = check_fd(s, W_OK, &emsg)) < 0) {

					bi_errorf("-u%s: %s", s, emsg);

					return (1);

				}

				break;

			case '?':

				return (1);

			}

		if (!(builtin_opt.info & GI_MINUSMINUS)) {

			/* treat a lone "-" like "--" */

			if (wp[builtin_opt.optind] &&

			    ksh_isdash(wp[builtin_opt.optind]))

				builtin_opt.optind++;

		}

		wp += builtin_opt.optind;

	}

	if (po.col) {

		if (*wp == NULL)

			return (0);

		XPinit(po.words, 16);

	}

	Xinit(xs, xp, 128, ATEMP);

	if (*wp == NULL)

		goto print_no_arg;

 print_read_arg:

	if (po.chars) {

		while (*wp != NULL) {

			s = *wp++;

			if (*s == '\0')

				break;

			if (!evaluate(s, &po.wc, KSH_RETURN_ERROR, true))

				return (1);

			Xcheck(xs, xp);

			if (UTFMODE) {

				po.ts[utf_wctomb(po.ts, po.wc)] = 0;

				c = 0;

				do {

					Xput(xs, xp, po.ts[c]);

				} while (po.ts[++c]);

			} else

				Xput(xs, xp, po.wc & 0xFF);

		}

	} else {

		s = *wp++;

		while ((c = *s++) != '\0') {

			Xcheck(xs, xp);

			if (po.exp && c == '\\') {

				s_ptr = s;

				c = unbksl(false, s_get, s_put);

				s = s_ptr;

				if (c == -1) {

					/* rejected by generic function */

					switch ((c = *s++)) {

					case 'c':

						po.nl = false;

						/* AT&T brain damage */

						continue;

					case '\0':

						--s;

						c = '\\';

						break;

					default:

						Xput(xs, xp, '\\');

					}

				} else if ((unsigned int)c > 0xFF) {

					/* generic function returned Unicode */

					po.ts[utf_wctomb(po.ts, c - 0x100)] = 0;

					c = 0;

					do {

						Xput(xs, xp, po.ts[c]);

					} while (po.ts[++c]);

					continue;

				}

			}

			Xput(xs, xp, c);

		}

	}

	if (po.col) {

		Xput(xs, xp, '\0');

		XPput(po.words, Xclose(xs, xp));

		Xinit(xs, xp, 128, ATEMP);

	}

	if (*wp != NULL) {

		if (!po.col)

			Xput(xs, xp, po.ws);

		goto print_read_arg;

	}

	if (po.col) {

		size_t w = XPsize(po.words);

		struct columnise_opts co;

		XPput(po.words, NULL);

		co.shf = shf_sopen(NULL, 128, SHF_WR | SHF_DYNAMIC, NULL);

		co.linesep = po.ls;

		co.prefcol = co.do_last = false;

		pr_list(&co, (char **)XPptrv(po.words));

		while (w--)

			afree(XPptrv(po.words)[w], ATEMP);

		XPfree(po.words);

		w = co.shf->wp - co.shf->buf;

		XcheckN(xs, xp, w);

		memcpy(xp, co.shf->buf, w);

		xp += w;

		shf_sclose(co.shf);

	}

 print_no_arg:

	if (po.nl)

		Xput(xs, xp, po.ls);

	c = 0;

	if (po.hist) {

		Xput(xs, xp, '\0');

		histsave(&source->line, Xstring(xs, xp), HIST_STORE, false);

	} else {

		size_t len = Xlength(xs, xp);

		/*

		 * Ensure we aren't killed by a SIGPIPE while writing to

		 * a coprocess. AT&T ksh doesn't seem to do this (seems

		 * to just check that the co-process is alive which is

		 * not enough).

		 */

		if (coproc.write >= 0 && coproc.write == po.fd) {

			po.coproc = true;

			po.copipe = block_pipe();

		} else

			po.coproc = po.copipe = false;

		s = Xstring(xs, xp);

		while (len > 0) {

			ssize_t nwritten;

			if ((nwritten = write(po.fd, s, len)) < 0) {

				if (errno == EINTR) {

					if (po.copipe)

						restore_pipe();

					/* give the user a chance to ^C out */

					intrcheck();

					/* interrupted, try again */

					if (po.coproc)

						po.copipe = block_pipe();

					continue;

				}

				c = 1;

				break;

			}

			s += nwritten;

			len -= nwritten;

		}

		if (po.copipe)

			restore_pipe();

	}

	Xfree(xs, xp);

	return (c);

}

static int

s_get(void)

{

	return (ord(*s_ptr++));

}

static void

s_put(int c MKSH_A_UNUSED)

{

	--s_ptr;

}

int

c_whence(const char **wp)

{

	int optc;

	bool pflag = false, vflag = false;

	while ((optc = ksh_getopt(wp, &builtin_opt, Tpv)) != -1)

		switch (optc) {

		case 'p':

			pflag = true;

			break;

		case 'v':

			vflag = true;

			break;

		case '?':

			return (1);

		}

	wp += builtin_opt.optind;

	return (do_whence(wp, pflag ? FC_PATH :

	    FC_BI | FC_FUNC | FC_PATH | FC_WHENCE, vflag, false));

}

/* note: command without -vV is dealt with in comexec() */

int

c_command(const char **wp)

{

	int optc, fcflags = FC_BI | FC_FUNC | FC_PATH | FC_WHENCE;

	bool vflag = false;

	while ((optc = ksh_getopt(wp, &builtin_opt, TpVv)) != -1)

		switch (optc) {

		case 'p':

			fcflags |= FC_DEFPATH;

			break;

		case 'V':

			vflag = true;

			break;

		case 'v':

			vflag = false;

			break;

		case '?':

			return (1);

		}

	wp += builtin_opt.optind;

	return (do_whence(wp, fcflags, vflag, true));

}

static int

do_whence(const char **wp, int fcflags, bool vflag, bool iscommand)

{

	uint32_t h;

	int rv = 0;

	struct tbl *tp;

	const char *id;

	while ((vflag || rv == 0) && (id = *wp++) != NULL) {

		h = hash(id);

		tp = NULL;

		if (fcflags & FC_WHENCE)

			tp = ktsearch(&keywords, id, h);

		if (!tp && (fcflags & FC_WHENCE)) {

			tp = ktsearch(&aliases, id, h);

			if (tp && !(tp->flag & ISSET))

				tp = NULL;

		}

		if (!tp)

			tp = findcom(id, fcflags);

		switch (tp->type) {

		case CSHELL:

		case CFUNC:

		case CKEYWD:

			shf_puts(id, shl_stdout);

			break;

		}

		switch (tp->type) {

		case CSHELL:

			if (vflag)

				shprintf(" is a %sshell %s",

				    (tp->flag & SPEC_BI) ? "special " : "",

				    Tbuiltin);

			break;

		case CFUNC:

			if (vflag) {

				shf_puts(" is a", shl_stdout);

				if (tp->flag & EXPORT)

					shf_puts("n exported", shl_stdout);

				if (tp->flag & TRACE)

					shf_puts(" traced", shl_stdout);

				if (!(tp->flag & ISSET)) {

					shf_puts(" undefined", shl_stdout);

					if (tp->u.fpath)

						shprintf(" (autoload from %s)",

						    tp->u.fpath);

				}

				shf_puts(T_function, shl_stdout);

			}

			break;

		case CEXEC:

		case CTALIAS:

			if (tp->flag & ISSET) {

				if (vflag) {

					shprintf("%s is ", id);

					if (tp->type == CTALIAS)

						shprintf("a tracked %s%s for ",

						    (tp->flag & EXPORT) ?

						    "exported " : "",

						    Talias);

				}

				shf_puts(tp->val.s, shl_stdout);

			} else {

				if (vflag)

					shprintf(Tnot_found_s, id);

				rv = 1;

			}

			break;

		case CALIAS:

			if (vflag) {

				shprintf("%s is an %s%s for ", id,

				    (tp->flag & EXPORT) ? "exported " : "",

				    Talias);

			} else if (iscommand)

				shprintf("%s %s=", Talias, id);

			print_value_quoted(shl_stdout, tp->val.s);

			break;

		case CKEYWD:

			if (vflag)

				shf_puts(" is a reserved word", shl_stdout);

			break;

#ifndef MKSH_SMALL

		default:

			bi_errorf(Tunexpected_type, id, Tcommand, tp->type);

			return (1);

#endif

		}

		if (vflag || !rv)

			shf_putc('\n', shl_stdout);

	}

	return (rv);

}

bool

valid_alias_name(const char *cp)

{

	if (ord(*cp) == ORD('-'))

		return (false);

	if (ord(cp[0]) == ORD('[') && ord(cp[1]) == ORD('[') && !cp[2])

		return (false);

	while (*cp)

		if (ctype(*cp, C_ALIAS))

			++cp;

		else

			return (false);

	return (true);

}

int

c_alias(const char **wp)

{

	struct table *t = &aliases;

	int rv = 0, prefix = 0;

	bool rflag = false, tflag, Uflag = false, pflag = false, chkalias;

	uint32_t xflag = 0;

	int optc;

	builtin_opt.flags |= GF_PLUSOPT;

	while ((optc = ksh_getopt(wp, &builtin_opt, "dprtUx")) != -1) {

		prefix = builtin_opt.info & GI_PLUS ? '+' : '-';

		switch (optc) {

		case 'd':

#ifdef MKSH_NOPWNAM

			t = NULL;	/* fix "alias -dt" */

#else

			t = &homedirs;

#endif

			break;

		case 'p':

			pflag = true;

			break;

		case 'r':

			rflag = true;

			break;

		case 't':

			t = &taliases;

			break;

		case 'U':

			/*

			 * kludge for tracked alias initialization

			 * (don't do a path search, just make an entry)

			 */

			Uflag = true;

			break;

		case 'x':

			xflag = EXPORT;

			break;

		case '?':

			return (1);

		}

	}

#ifdef MKSH_NOPWNAM

	if (t == NULL)

		return (0);

#endif

	wp += builtin_opt.optind;

	if (!(builtin_opt.info & GI_MINUSMINUS) && *wp &&

	    ctype(wp[0][0], C_MINUS | C_PLUS) && wp[0][1] == '\0') {

		prefix = wp[0][0];

		wp++;

	}

	tflag = t == &taliases;

	chkalias = t == &aliases;

	/* "hash -r" means reset all the tracked aliases.. */

	if (rflag) {

		static const char *args[] = {

			Tunalias, "-ta", NULL

		};

		if (!tflag || *wp) {

			shprintf("%s: -r flag can only be used with -t"

			    " and without arguments\n", Talias);

			return (1);

		}

		ksh_getopt_reset(&builtin_opt, GF_ERROR);

		return (c_unalias(args));

	}

	if (*wp == NULL) {

		struct tbl *ap, **p;

		for (p = ktsort(t); (ap = *p++) != NULL; )

			if ((ap->flag & (ISSET|xflag)) == (ISSET|xflag)) {

				if (pflag)

					shprintf(Tf_s_, Talias);

				shf_puts(ap->name, shl_stdout);

				if (prefix != '+') {

					shf_putc('=', shl_stdout);

					print_value_quoted(shl_stdout, ap->val.s);

				}

				shf_putc('\n', shl_stdout);

			}

	}

	for (; *wp != NULL; wp++) {

		const char *alias = *wp, *val, *newval;

		char *xalias = NULL;

		struct tbl *ap;

		uint32_t h;

		if ((val = cstrchr(alias, '='))) {

			strndupx(xalias, alias, val++ - alias, ATEMP);

			alias = xalias;

		}

		if (chkalias && !valid_alias_name(alias)) {

			bi_errorf(Tinvname, alias, Talias);

			afree(xalias, ATEMP);

			return (1);

		}

		h = hash(alias);

		if (val == NULL && !tflag && !xflag) {

			ap = ktsearch(t, alias, h);

			if (ap != NULL && (ap->flag&ISSET)) {

				if (pflag)

					shprintf(Tf_s_, Talias);

				shf_puts(ap->name, shl_stdout);

				if (prefix != '+') {

					shf_putc('=', shl_stdout);

					print_value_quoted(shl_stdout, ap->val.s);

				}

				shf_putc('\n', shl_stdout);

			} else {

				shprintf(Tf_s_s_sN, alias, Talias, Tnot_found);

				rv = 1;

			}

			continue;