path: root/src/main/parser.c

/*
 * parser.c	Parse various things
 *
 * Version:	$Id$
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 *
 * Copyright 2013  Alan DeKok <aland@freeradius.org>
 */

RCSID("$Id$")

#include <freeradius-devel/radiusd.h>
#include <freeradius-devel/parser.h>
#include <freeradius-devel/rad_assert.h>

#include <ctype.h>

#define PW_CAST_BASE (1850)

static const FR_NAME_NUMBER allowed_return_codes[] = {
	{ "reject",     1 },
	{ "fail",       1 },
	{ "ok",	 	1 },
	{ "handled",    1 },
	{ "invalid",    1 },
	{ "userlock",   1 },
	{ "notfound",   1 },
	{ "noop",       1 },
	{ "updated",    1 },
	{ NULL, 0 }
};

/*
 *	This file shouldn't use any functions from the server core.
 */

size_t fr_cond_sprint(char *buffer, size_t bufsize, fr_cond_t const *in)
{
	size_t len;
	char *p = buffer;
	char *end = buffer + bufsize - 1;
	fr_cond_t const *c = in;

	rad_assert(bufsize > 0);

next:
	rad_assert(p < end);

	if (!c) {
		p[0] = '\0';
		return 0;
	}

	/*
	 *	Don't overflow the output buffer.
	 */
	if ((end - p) < 2) {
		p[0] = '\0';
		return 0;
	}

	if (c->negate) {
		*(p++) = '!';	/* FIXME: only allow for child? */
	}

	switch (c->type) {
	case COND_TYPE_EXISTS:
		rad_assert(c->data.vpt != NULL);
		if (c->cast) {
			snprintf(p, end - p, "<%s>", fr_int2str(dict_attr_types,
								c->cast->type, "??"));
			p += strlen(p);
		}

		len = tmpl_prints(p, end - p, c->data.vpt, NULL);
		p += len;
		break;

	case COND_TYPE_MAP:
		rad_assert(c->data.map != NULL);
#if 0
		*(p++) = '[';	/* for extra-clear debugging */
#endif
		if (c->cast) {
			snprintf(p, end - p, "<%s>", fr_int2str(dict_attr_types,
								c->cast->type, "??"));
			p += strlen(p);
		}

		len = map_prints(p, end - p, c->data.map);
		p += len;
#if 0
		*(p++) = ']';
#endif
		break;

	case COND_TYPE_CHILD:
		rad_assert(c->data.child != NULL);
		*(p++) = '(';
		len = fr_cond_sprint(p, end - p, c->data.child);
		p += len;
		*(p++) = ')';
		break;

	case COND_TYPE_TRUE:
		strlcpy(buffer, "true", bufsize);
		return strlen(buffer);

	case COND_TYPE_FALSE:
		strlcpy(buffer, "false", bufsize);
		return strlen(buffer);

	default:
		*buffer = '\0';
		return 0;
	}

	if (c->next_op == COND_NONE) {
		rad_assert(c->next == NULL);
		*p = '\0';
		return p - buffer;
	}

	if (c->next_op == COND_AND) {
		strlcpy(p, " && ", end - p);
		p += strlen(p);

	} else if (c->next_op == COND_OR) {
		strlcpy(p, " || ", end - p);
		p += strlen(p);

	} else {
		rad_assert(0 == 1);
	}

	c = c->next;
	goto next;
}


static ssize_t condition_tokenize_string(TALLOC_CTX *ctx, char **out,  char const **error, char const *start,
					 FR_TOKEN *op)
{
	char const *p = start;
	char *q;

	switch (*p++) {
	default:
		return -1;

	case '"':
		*op = T_DOUBLE_QUOTED_STRING;
		break;

	case '\'':
		*op = T_SINGLE_QUOTED_STRING;
		break;

	case '`':
		*op = T_BACK_QUOTED_STRING;
		break;

	case '/':
		*op = T_OP_REG_EQ; /* a bit of a hack. */
		break;

	}

	*out = talloc_array(ctx, char, strlen(start) - 1); /* + 2 - 1 */
	if (!*out) return -1;

	q = *out;

	while (*p) {
		if (*p == *start) {
			/*
			 *	Call the STANDARD parse function to figure out what the string is.
			 */
			if (cf_new_escape) {
				ssize_t slen;
				value_data_t data;
				char quote = *start;
				PW_TYPE src_type = PW_TYPE_STRING;

				/*
				 *	Regex compilers can handle escapes.  So we don't do it.
				 */
				if (quote == '/') quote = '\0';

				slen = value_data_from_str(ctx, &data, &src_type, NULL, start + 1, p - (start + 1), quote);
				if (slen < 0) {
					*error = "error parsing string";
					return slen - 1;
				}

				talloc_free(*out);
				*out = talloc_steal(ctx, data.ptr);
				data.strvalue = NULL;
			} else {
				char *out2;

				*(q++) = '\0'; /* terminate the output string */

				out2 = talloc_realloc(ctx, *out, char, (q - *out));
				if (!out2) {
					*error = "Out of memory";
					return -1;
				}
				*out = out2;
			}

			p++;
			return (p - start);
		}

		if (*p == '\\') {
			if (!p[1]) {
				p++;
				*error = "End of string after escape";
				return -(p - start);
			}

			/*
			 *	Hacks for backwards compatibility
			 */
			if (cf_new_escape) {
				if (p[1] == start[0]) { /* Convert '\'' --> ' */
					p++;
				} else {
					*(q++) = *(p++);
				}

			} else {
				switch (p[1]) {
				case 'r':
					*q++ = '\r';
					break;
				case 'n':
					*q++ = '\n';
					break;
				case 't':
					*q++ = '\t';
					break;
				default:
					*q++ = p[1];
					break;
				}
				p += 2;
				continue;
			}

		}
		*(q++) = *(p++);
	}

	*error = "Unterminated string";
	return -1;
}

static ssize_t condition_tokenize_word(TALLOC_CTX *ctx, char const *start, char **out,
				       FR_TOKEN *op, char const **error)
{
	size_t len;
	char const *p = start;

	if ((*p == '"') || (*p == '\'') || (*p == '`') || (*p == '/')) {
		return condition_tokenize_string(ctx, out, error, start, op);
	}

	*op = T_BARE_WORD;
	if (*p == '&') p++;	/* special-case &User-Name */

	while (*p) {
		/*
		 *	The LHS should really be limited to only a few
		 *	things.  For now, we allow pretty much anything.
		 */
		if (*p == '\\') {
			*error = "Unexpected escape";
			return -(p - start);
		}

		/*
		 *	("foo") is valid.
		 */
		if (*p == ')') {
			break;
		}

		/*
		 *	Spaces or special characters delineate the word
		 */
		if (isspace((int) *p) || (*p == '&') || (*p == '|') ||
		    (*p == '!') || (*p == '=') || (*p == '<') || (*p == '>')) {
			break;
		}

		if ((*p == '"') || (*p == '\'') || (*p == '`')) {
			*error = "Unexpected start of string";
			return -(p - start);
		}

		p++;
	}

	len = p - start;
	if (!len) {
		*error = "Empty string is invalid";
		return 0;
	}

	*out = talloc_array(ctx, char, len + 1);
	memcpy(*out, start, len);
	(*out)[len] = '\0';
	return len;
}


static ssize_t condition_tokenize_cast(char const *start, DICT_ATTR const **pda, char const **error)
{
	char const *p = start;
	char const *q;
	PW_TYPE cast;

	while (isspace((int) *p)) p++; /* skip spaces before condition */

	if (*p != '<') return 0;
	p++;

	q = p;
	while (*q && *q != '>') q++;

	cast = fr_substr2int(dict_attr_types, p, PW_TYPE_INVALID, q - p);
	if (cast == PW_TYPE_INVALID) {
		*error = "Invalid data type in cast";
		return -(p - start);
	}

	/*
	 *	We can only cast to basic data types.  Complex ones
	 *	are forbidden.
	 */
	switch (cast) {
#ifdef WITH_ASCEND_BINARY
	case PW_TYPE_ABINARY:
#endif
	case PW_TYPE_COMBO_IP_ADDR:
	case PW_TYPE_TLV:
	case PW_TYPE_EXTENDED:
	case PW_TYPE_LONG_EXTENDED:
	case PW_TYPE_EVS:
	case PW_TYPE_VSA:
		*error = "Forbidden data type in cast";
		return -(p - start);

	default:
		break;
	}

	*pda = dict_attrbyvalue(PW_CAST_BASE + cast, 0);
	if (!*pda) {
		*error = "Cannot cast to this data type";
		return -(p - start);
	}

	q++;

	while (isspace((int) *q)) q++; /* skip spaces after cast */

	return q - start;
}

static bool condition_check_types(fr_cond_t *c, PW_TYPE lhs_type)
{
	/*
	 *	SOME integer mismatch is OK.  If the LHS has a large type,
	 *	and the RHS has a small type, it's OK.
	 *
	 *	If the LHS has a small type, and the RHS has a large type,
	 *	then add a cast to the LHS.
	 */
	if (lhs_type == PW_TYPE_INTEGER64) {
		if ((c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER) ||
		    (c->data.map->rhs->tmpl_da->type == PW_TYPE_SHORT) ||
		    (c->data.map->rhs->tmpl_da->type == PW_TYPE_BYTE)) {
			c->cast = NULL;
			return true;
		}
	}

	if (lhs_type == PW_TYPE_INTEGER) {
		if ((c->data.map->rhs->tmpl_da->type == PW_TYPE_SHORT) ||
		    (c->data.map->rhs->tmpl_da->type == PW_TYPE_BYTE)) {
			c->cast = NULL;
			return true;
		}

		if (c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER64) {
			c->cast = c->data.map->rhs->tmpl_da;
			return true;
		}
	}

	if (lhs_type == PW_TYPE_SHORT) {
		if (c->data.map->rhs->tmpl_da->type == PW_TYPE_BYTE) {
			c->cast = NULL;
			return true;
		}

		if ((c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER64) ||
		    (c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER)) {
			c->cast = c->data.map->rhs->tmpl_da;
			return true;
		}
	}

	if (lhs_type == PW_TYPE_BYTE) {
		if ((c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER64) ||
		    (c->data.map->rhs->tmpl_da->type == PW_TYPE_INTEGER) ||
		    (c->data.map->rhs->tmpl_da->type == PW_TYPE_SHORT)) {
			c->cast = c->data.map->rhs->tmpl_da;
			return true;
		}
	}

	if ((lhs_type == PW_TYPE_IPV4_PREFIX) &&
	    (c->data.map->rhs->tmpl_da->type == PW_TYPE_IPV4_ADDR)) {
		return true;
	}

	if ((lhs_type == PW_TYPE_IPV6_PREFIX) &&
	    (c->data.map->rhs->tmpl_da->type == PW_TYPE_IPV6_ADDR)) {
		return true;
	}

	/*
	 *	Same checks as above, but with the types swapped, and
	 *	with explicit cast for the interpretor.
	 */
	if ((lhs_type == PW_TYPE_IPV4_ADDR) &&
	    (c->data.map->rhs->tmpl_da->type == PW_TYPE_IPV4_PREFIX)) {
		c->cast = c->data.map->rhs->tmpl_da;
		return true;
	}

	if ((lhs_type == PW_TYPE_IPV6_ADDR) &&
	    (c->data.map->rhs->tmpl_da->type == PW_TYPE_IPV6_PREFIX)) {
		c->cast = c->data.map->rhs->tmpl_da;
		return true;
	}

	return false;
}


/*
 *	Less code means less bugs
 */
#define return_P(_x) *error = _x;goto return_p
#define return_0(_x) *error = _x;goto return_0
#define return_lhs(_x) *error = _x;goto return_lhs
#define return_rhs(_x) *error = _x;goto return_rhs
#define return_SLEN goto return_slen


/** Tokenize a conditional check
 *
 *  @param[in] ctx for talloc
 *  @param[in] ci for CONF_ITEM
 *  @param[in] start the start of the string to process.  Should be "(..."
 *  @param[in] brace look for a closing brace
 *  @param[out] pcond pointer to the returned condition structure
 *  @param[out] error the parse error (if any)
 *  @param[in] flags do one/two pass
 *  @return length of the string skipped, or when negative, the offset to the offending error
 */
static ssize_t condition_tokenize(TALLOC_CTX *ctx, CONF_ITEM *ci, char const *start, bool brace,
				  fr_cond_t **pcond, char const **error, int flags)
{
	ssize_t slen, tlen;
	char const *p = start;
	char const *lhs_p, *rhs_p;
	fr_cond_t *c;
	char *lhs, *rhs;
	FR_TOKEN op, lhs_type, rhs_type;

	c = talloc_zero(ctx, fr_cond_t);

	rad_assert(c != NULL);
	lhs = rhs = NULL;
	lhs_type = rhs_type = T_INVALID;

	while (isspace((int) *p)) p++; /* skip spaces before condition */

	if (!*p) {
		return_P("Empty condition is invalid");
	}

	/*
	 *	!COND
	 */
	if (*p == '!') {
		p++;
		c->negate = true;
		while (isspace((int) *p)) p++; /* skip spaces after negation */

		/*
		 *  Just for stupidity
		 */
		if (*p == '!') {
			return_P("Double negation is invalid");
		}
	}

	/*
	 *	(COND)
	 */
	if (*p == '(') {
		p++;

		/*
		 *	We've already eaten one layer of
		 *	brackets.  Go recurse to get more.
		 */
		c->type = COND_TYPE_CHILD;
		c->ci = ci;
		slen = condition_tokenize(c, ci, p, true, &c->data.child, error, flags);
		if (slen <= 0) {
			return_SLEN;
		}

		if (!c->data.child) {
			return_P("Empty condition is invalid");
		}

		p += slen;
		while (isspace((int) *p)) p++; /* skip spaces after (COND)*/

	} else { /* it's a bare FOO==BAR */
		/*
		 *	We didn't see anything special.  The condition must be one of
		 *
		 *	FOO
		 *	FOO OP BAR
		 */

		/*
		 *	Grab the LHS
		 */
		if (*p == '/') {
			return_P("Conditional check cannot begin with a regular expression");
		}

		slen = condition_tokenize_cast(p, &c->cast, error);
		if (slen < 0) {
			return_SLEN;
		}
		p += slen;

#ifndef __clang_analyzer__
		lhs_p = p;
#endif
		slen = condition_tokenize_word(c, p, &lhs, &lhs_type, error);
		if (slen <= 0) {
			return_SLEN;
		}
		p += slen;


#ifdef __clang_analyzer__
		if (!lhs) return_P("Internal error");
#endif

		/*
		 *	If the LHS is 0xabcdef... automatically cast it to octets
		 */
		if (!c->cast && (lhs_type == T_BARE_WORD) &&
		    (lhs[0] == '0') && (lhs[1] == 'x') &&
		    ((slen & 0x01) == 0)) {
			if (slen == 2) {
				return_P("Empty octet string is invalid");
			}

			c->cast = dict_attrbyvalue(PW_CAST_BASE + PW_TYPE_OCTETS, 0);
		}

		while (isspace((int)*p)) p++; /* skip spaces after LHS */

		/*
		 *	We may (or not) have an operator
		 */


		/*
		 *	(FOO)
		 */
		if (*p == ')') {
			/*
			 *	don't skip the brace.  We'll look for it later.
			 */
			goto exists;

			/*
			 *	FOO
			 */
		} else if (!*p) {
			if (brace) {
				return_P("No closing brace at end of string");
			}

			goto exists;

			/*
			 *	FOO && ...
			 */
		} else if (((p[0] == '&') && (p[1] == '&')) ||
			   ((p[0] == '|') && (p[1] == '|'))) {

		exists:
			if (c->cast) {
				return_0("Cannot do cast for existence check");
			}

			c->type = COND_TYPE_EXISTS;
			c->ci = ci;

			tlen = tmpl_afrom_str(c, &c->data.vpt, lhs, talloc_array_length(lhs) - 1,
					      lhs_type, REQUEST_CURRENT, PAIR_LIST_REQUEST, false);
			if (tlen < 0) {
				p = lhs_p - tlen;
				return_P(fr_strerror());
			}

			rad_assert(c->data.vpt->type != TMPL_TYPE_REGEX);

			if (c->data.vpt->type == TMPL_TYPE_ATTR_UNDEFINED) {
				c->pass2_fixup = PASS2_FIXUP_ATTR;
			}

		} else { /* it's an operator */
#ifdef HAVE_REGEX
			bool regex = false;
			bool iflag = false;
			bool mflag = false;
#endif
			vp_map_t *map;

			/*
			 *	The next thing should now be a comparison operator.
			 */
			c->type = COND_TYPE_MAP;
			c->ci = ci;

			switch (*p) {
			default:
				return_P("Invalid text. Expected comparison operator");

			case '!':
				if (p[1] == '=') {
					op = T_OP_NE;
					p += 2;

#ifdef HAVE_REGEX
				} else if (p[1] == '~') {
					regex = true;

					op = T_OP_REG_NE;
					p += 2;
#endif

				} else if (p[1] == '*') {
					if (lhs_type != T_BARE_WORD) {
						return_P("Cannot use !* on a string");
					}

					op = T_OP_CMP_FALSE;
					p += 2;

				} else {
					goto invalid_operator;
				}
				break;

			case '=':
				if (p[1] == '=') {
					op = T_OP_CMP_EQ;
					p += 2;

#ifdef HAVE_REGEX
				} else if (p[1] == '~') {
					regex = true;

					op = T_OP_REG_EQ;
					p += 2;
#endif

				} else if (p[1] == '*') {
					if (lhs_type != T_BARE_WORD) {
						return_P("Cannot use =* on a string");
					}

					op = T_OP_CMP_TRUE;
					p += 2;

				} else {
				invalid_operator:
					return_P("Invalid operator");
				}

				break;

			case '<':
				if (p[1] == '=') {
					op = T_OP_LE;
					p += 2;

				} else {
					op = T_OP_LT;
					p++;
				}
				break;

			case '>':
				if (p[1] == '=') {
					op = T_OP_GE;
					p += 2;

				} else {
					op = T_OP_GT;
					p++;
				}
				break;
			}

			while (isspace((int) *p)) p++; /* skip spaces after operator */

			if (!*p) {
				return_P("Expected text after operator");
			}

			/*
			 *	Cannot have a cast on the RHS.
			 *	But produce good errors, too.
			 */
			if (*p == '<') {
				DICT_ATTR const *cast_da;

				slen = condition_tokenize_cast(p, &cast_da, error);
				if (slen < 0) {
					return_SLEN;
				}

#ifdef __clang_analyzer__
				if (!cast_da) return_P("Internal error");
#endif

				if (!c->cast) {
					return_P("Unexpected cast");
				}

				if (c->cast != cast_da) {
					return_P("Cannot cast to a different data type");
				}

				return_P("Unnecessary cast");
			}

			/*
			 *	Grab the RHS
			 */
			rhs_p = p;
			slen = condition_tokenize_word(c, p, &rhs, &rhs_type, error);
			if (slen <= 0) {
				return_SLEN;
			}

#ifdef HAVE_REGEX
			/*
			 *	Sanity checks for regexes.
			 */
			if (regex) {
				if (*p != '/') {
					return_P("Expected regular expression");
				}
				for (;;) {
					switch (p[slen]) {
					/*
					 *	/foo/i
					 */
					case 'i':
						iflag = true;
						slen++;
						continue;

					/*
					 *	/foo/m
					 */
					case 'm':
						mflag = true;
						slen++;
						continue;

					default:
						break;
					}
					break;
				}
			} else if (!regex && (*p == '/')) {
				return_P("Unexpected regular expression");
			}

#endif
			/*
			 *	Duplicate map_from_fields here, as we
			 *	want to separate parse errors in the
			 *	LHS from ones in the RHS.
			 */
			c->data.map = map = talloc_zero(c, vp_map_t);

			tlen = tmpl_afrom_str(map, &map->lhs, lhs, talloc_array_length(lhs) - 1,
					      lhs_type, REQUEST_CURRENT, PAIR_LIST_REQUEST, false);
			if (tlen < 0) {
				p = lhs_p - tlen;
				return_P(fr_strerror());
			}

			if (tmpl_define_unknown_attr(map->lhs) < 0) {
				return_lhs("Failed defining attribute");
			return_lhs:
				if (lhs) talloc_free(lhs);
				if (rhs) talloc_free(rhs);
				talloc_free(c);
				return -(lhs_p - start);
			}

			map->op = op;

			/*
			 *	If the RHS is 0xabcdef... automatically cast it to octets
			 *	unless the LHS is an attribute of type octets, or an
			 *	integer type.
			 */
			if (!c->cast && (rhs_type == T_BARE_WORD) &&
			    (rhs[0] == '0') && (rhs[1] == 'x') &&
			    ((slen & 0x01) == 0)) {
				if (slen == 2) {
					return_P("Empty octet string is invalid");
				}

				if ((map->lhs->type != TMPL_TYPE_ATTR) ||
				    !((map->lhs->tmpl_da->type == PW_TYPE_OCTETS) ||
				      (map->lhs->tmpl_da->type == PW_TYPE_BYTE) ||
				      (map->lhs->tmpl_da->type == PW_TYPE_SHORT) ||
				      (map->lhs->tmpl_da->type == PW_TYPE_INTEGER) ||
				      (map->lhs->tmpl_da->type == PW_TYPE_INTEGER64))) {
					c->cast = dict_attrbyvalue(PW_CAST_BASE + PW_TYPE_OCTETS, 0);
				}
			}

			if ((map->lhs->type == TMPL_TYPE_ATTR) &&
			    map->lhs->tmpl_da->flags.is_unknown &&
			    map_cast_from_hex(map, rhs_type, rhs)) {
				/* do nothing */

			} else {
				tlen = tmpl_afrom_str(map, &map->rhs, rhs, talloc_array_length(rhs) - 1, rhs_type,
						      REQUEST_CURRENT, PAIR_LIST_REQUEST, false);
				if (tlen < 0) {
					p = rhs_p - tlen;
					return_P(fr_strerror());
				}

				if (tmpl_define_unknown_attr(map->rhs) < 0) {
					return_rhs("Failed defining attribute");
				}
			}

			/*
			 *	Unknown attributes get marked up for pass2.
			 */
			if ((c->data.map->lhs->type == TMPL_TYPE_ATTR_UNDEFINED) ||
			    (c->data.map->rhs->type == TMPL_TYPE_ATTR_UNDEFINED)) {
				c->pass2_fixup = PASS2_FIXUP_ATTR;
			}

#ifdef HAVE_REGEX
			if (c->data.map->rhs->type == TMPL_TYPE_REGEX) {
				c->data.map->rhs->tmpl_iflag = iflag;
				c->data.map->rhs->tmpl_mflag = mflag;
			}
#endif

			/*
			 *	Save the CONF_ITEM for later.
			 */
			c->data.map->ci = ci;

			/*
			 *	@todo: check LHS and RHS separately, to
			 *	get better errors
			 */
			if ((c->data.map->rhs->type == TMPL_TYPE_LIST) ||
			    (c->data.map->lhs->type == TMPL_TYPE_LIST)) {
				return_0("Cannot use list references in condition");
			}

			/*
			 *	Check cast type.  We can have the RHS
			 *	a string if the LHS has a cast.  But
			 *	if the RHS is an attr, it MUST be the
			 *	same type as the LHS.
			 */
			if (c->cast) {
				if ((c->data.map->rhs->type == TMPL_TYPE_ATTR) &&
				    (c->cast->type != c->data.map->rhs->tmpl_da->type)) {
					if (condition_check_types(c, c->cast->type)) {
						goto keep_going;
					}

					goto same_type;
				}

#ifdef HAVE_REGEX
				if (c->data.map->rhs->type == TMPL_TYPE_REGEX) {
					return_0("Cannot use cast with regex comparison");
				}
#endif

				/*
				 *	The LHS is a literal which has been cast to a data type.
				 *	Cast it to the appropriate data type.
				 */
				if ((c->data.map->lhs->type == TMPL_TYPE_LITERAL) &&
				    (tmpl_cast_in_place(c->data.map->lhs, c->cast->type, c->cast) < 0)) {
					*error = "Failed to parse field";
					if (lhs) talloc_free(lhs);
					if (rhs) talloc_free(rhs);
					talloc_free(c);
					return -(lhs_p - start);
				}

				/*
				 *	The RHS is a literal, and the LHS has been cast to a data
				 *	type.
				 */
				if ((c->data.map->lhs->type == TMPL_TYPE_DATA) &&
				    (c->data.map->rhs->type == TMPL_TYPE_LITERAL) &&
				    (tmpl_cast_in_place(c->data.map->rhs, c->cast->type, c->cast) < 0)) {
					return_rhs("Failed to parse field");
				}

				/*
				 *	We may be casting incompatible
				 *	types.  We check this based on
				 *	their size.
				 */
				if (c->data.map->lhs->type == TMPL_TYPE_ATTR) {
					/*
					 *      dst.min == src.min
					 *	dst.max == src.max
					 */
					if ((dict_attr_sizes[c->cast->type][0] == dict_attr_sizes[c->data.map->lhs->tmpl_da->type][0]) &&
					    (dict_attr_sizes[c->cast->type][1] == dict_attr_sizes[c->data.map->lhs->tmpl_da->type][1])) {
						goto cast_ok;
					}

					/*
					 *	Run-time parsing of strings.
					 *	Run-time copying of octets.
					 */
					if ((c->data.map->lhs->tmpl_da->type == PW_TYPE_STRING) ||
					    (c->data.map->lhs->tmpl_da->type == PW_TYPE_OCTETS)) {
						goto cast_ok;
					}

					/*
					 *	ifid to integer64 is OK
					 */
					if ((c->data.map->lhs->tmpl_da->type == PW_TYPE_IFID) &&
					    (c->cast->type == PW_TYPE_INTEGER64)) {
						goto cast_ok;
					}

					/*
					 *	ipaddr to ipv4prefix is OK
					 */
					if ((c->data.map->lhs->tmpl_da->type == PW_TYPE_IPV4_ADDR) &&
					    (c->cast->type == PW_TYPE_IPV4_PREFIX)) {
						goto cast_ok;
					}

					/*
					 *	ipv6addr to ipv6prefix is OK
					 */
					if ((c->data.map->lhs->tmpl_da->type == PW_TYPE_IPV6_ADDR) &&
					    (c->cast->type == PW_TYPE_IPV6_PREFIX)) {
						goto cast_ok;
					}

					/*
					 *	integer64 to ethernet is OK.
					 */
					if ((c->data.map->lhs->tmpl_da->type == PW_TYPE_INTEGER64) &&
					    (c->cast->type == PW_TYPE_ETHERNET)) {
						goto cast_ok;
					}

					/*
					 *	dst.max < src.min
					 *	dst.min > src.max
					 */
					if ((dict_attr_sizes[c->cast->type][1] < dict_attr_sizes[c->data.map->lhs->tmpl_da->type][0]) ||
					    (dict_attr_sizes[c->cast->type][0] > dict_attr_sizes[c->data.map->lhs->tmpl_da->type][1])) {
						return_0("Cannot cast to attribute of incompatible size");
					}
				}

			cast_ok:
				/*
				 *	Casting to a redundant type means we don't need the cast.
				 *
				 *	Do this LAST, as the rest of the code above assumes c->cast
				 *	is not NULL.
				 */
				if ((c->data.map->lhs->type == TMPL_TYPE_ATTR) &&
				    (c->cast->type == c->data.map->lhs->tmpl_da->type)) {
					c->cast = NULL;
				}

			} else {
				vp_tmpl_t *vpt;

				/*
				 *	Two attributes?  They must be of the same type
				 */
				if ((c->data.map->rhs->type == TMPL_TYPE_ATTR) &&
				    (c->data.map->lhs->type == TMPL_TYPE_ATTR) &&
				    (c->data.map->lhs->tmpl_da->type != c->data.map->rhs->tmpl_da->type)) {
					if (condition_check_types(c, c->data.map->lhs->tmpl_da->type)) {
						goto keep_going;
					}

				same_type:
					return_0("Attribute comparisons must be of the same data type");
				}

				/*
				 *	Without a cast, we can't compare "foo" to User-Name,
				 *	it has to be done the other way around.
				 */
				if ((c->data.map->rhs->type == TMPL_TYPE_ATTR) &&
				    (c->data.map->lhs->type != TMPL_TYPE_ATTR)) {
					*error = "Cannot use attribute reference on right side of condition";
				return_0:
					if (lhs) talloc_free(lhs);
					if (rhs) talloc_free(rhs);
					talloc_free(c);
					return 0;
				}

				/*
				 *	Invalid: User-Name == bob
				 *	Valid:   User-Name == "bob"
				 *
				 *	There's no real reason for
				 *	this, other than consistency.
				 */
				if ((c->data.map->lhs->type == TMPL_TYPE_ATTR) &&
				    (c->data.map->rhs->type != TMPL_TYPE_ATTR) &&
				    (c->data.map->lhs->tmpl_da->type == PW_TYPE_STRING) &&
				    (c->data.map->op != T_OP_CMP_TRUE) &&
				    (c->data.map->op != T_OP_CMP_FALSE) &&
				    (rhs_type == T_BARE_WORD)) {
					return_rhs("Must have string as value for attribute");
				}

				/*
				 *	Quotes around non-string
				 *	attributes mean that it's
				 *	either xlat, or an exec.
				 */
				if ((c->data.map->lhs->type == TMPL_TYPE_ATTR) &&
				    (c->data.map->rhs->type != TMPL_TYPE_ATTR) &&
				    (c->data.map->lhs->tmpl_da->type != PW_TYPE_STRING) &&
				    (c->data.map->lhs->tmpl_da->type != PW_TYPE_OCTETS) &&
				    (c->data.map->lhs->tmpl_da->type != PW_TYPE_DATE) &&
				    (rhs_type == T_SINGLE_QUOTED_STRING)) {
					*error = "Value must be an unquoted string";
				return_rhs:
					if (lhs) talloc_free(lhs);
					if (rhs) talloc_free(rhs);
					talloc_free(c);
					return -(rhs_p - start);
				}

				/*
				 *	The LHS has been cast to a data type, and the RHS is a
				 *	literal.  Cast the RHS to the type of the cast.
				 */
				if (c->cast && (c->data.map->rhs->type == TMPL_TYPE_LITERAL) &&
				    (tmpl_cast_in_place(c->data.map->rhs, c->cast->type, c->cast) < 0)) {
					return_rhs("Failed to parse field");
				}

				/*
				 *	The LHS is an attribute, and the RHS is a literal.  Cast the
				 *	RHS to the data type of the LHS.
				 *
				 *	Note: There's a hack in here to always parse RHS as the
				 *	equivalent prefix type if the LHS is an IP address.
				 *
				 *	This allows Framed-IP-Address < 192.168.0.0./24
				 */
				if ((c->data.map->lhs->type == TMPL_TYPE_ATTR) &&
				    (c->data.map->rhs->type == TMPL_TYPE_LITERAL)) {
					PW_TYPE type = c->data.map->lhs->tmpl_da->type;

					switch (c->data.map->lhs->tmpl_da->type) {
					case PW_TYPE_IPV4_ADDR:
						if (strchr(c->data.map->rhs->name, '/') != NULL) {
							type = PW_TYPE_IPV4_PREFIX;
							c->cast = dict_attrbyvalue(PW_CAST_BASE + type, 0);
						}
						break;

					case PW_TYPE_IPV6_ADDR:
						if (strchr(c->data.map->rhs->name, '/') != NULL) {
							type = PW_TYPE_IPV6_PREFIX;
							c->cast = dict_attrbyvalue(PW_CAST_BASE + type, 0);
						}
						break;

					default:
						break;
					}

					if (tmpl_cast_in_place(c->data.map->rhs, type, c->data.map->lhs->tmpl_da) < 0) {
						DICT_ATTR const *da = c->data.map->lhs->tmpl_da;

						if ((da->vendor == 0) &&
						    ((da->attr == PW_AUTH_TYPE) ||
						     (da->attr == PW_AUTZ_TYPE) ||
						     (da->attr == PW_ACCT_TYPE) ||
						     (da->attr == PW_SESSION_TYPE) ||
						     (da->attr == PW_POST_AUTH_TYPE) ||
						     (da->attr == PW_PRE_PROXY_TYPE) ||
						     (da->attr == PW_POST_PROXY_TYPE) ||
						     (da->attr == PW_PRE_ACCT_TYPE) ||
						     (da->attr == PW_RECV_COA_TYPE) ||
						     (da->attr == PW_SEND_COA_TYPE))) {
							/*
							 *	The types for these attributes are dynamically allocated
							 *	by modules.c, so we can't enforce strictness here.
							 */
							c->pass2_fixup = PASS2_FIXUP_TYPE;
						} else {
							return_rhs("Failed to parse value for attribute");
						}
					}

					/*
					 *	Stupid WiMAX shit.
					 *	Cast the LHS to the
					 *	type of the RHS.
					 */
					if (c->data.map->lhs->tmpl_da->type == PW_TYPE_COMBO_IP_ADDR) {
						DICT_ATTR const *da;

						da = dict_attrbytype(c->data.map->lhs->tmpl_da->attr,
								     c->data.map->lhs->tmpl_da->vendor,
								     c->data.map->rhs->tmpl_data_type);
						if (!da) {
							return_rhs("Cannot find type for attribute");
						}
						c->data.map->lhs->tmpl_da = da;
					}
				} /* attr to literal comparison */

				/*
				 *	The RHS will turn into... something.  Allow for prefixes
				 *	there, too.
				 */
				if ((c->data.map->lhs->type == TMPL_TYPE_ATTR) &&
				    ((c->data.map->rhs->type == TMPL_TYPE_XLAT) ||
				     (c->data.map->rhs->type == TMPL_TYPE_XLAT_STRUCT) ||
				     (c->data.map->rhs->type == TMPL_TYPE_EXEC))) {
					if (c->data.map->lhs->tmpl_da->type == PW_TYPE_IPV4_ADDR) {
						c->cast = dict_attrbyvalue(PW_CAST_BASE + PW_TYPE_IPV4_PREFIX, 0);
					}

					if (c->data.map->lhs->tmpl_da->type == PW_TYPE_IPV6_ADDR) {
						c->cast = dict_attrbyvalue(PW_CAST_BASE + PW_TYPE_IPV6_PREFIX, 0);
					}
				}

				/*
				 *	If the LHS is a bare word, AND it looks like
				 *	an attribute, try to parse it as such.
				 *
				 *	This allows LDAP-Group and SQL-Group to work.
				 *
				 *	The real fix is to just read the config files,
				 *	and do no parsing until after all of the modules
				 *	are loaded.  But that has issues, too.
				 */
				if ((c->data.map->lhs->type == TMPL_TYPE_LITERAL) && (lhs_type == T_BARE_WORD)) {
					int hyphens = 0;
					bool may_be_attr = true;
					size_t i;
					ssize_t attr_slen;

					/*
					 *	Backwards compatibility: Allow Foo-Bar,
					 *	e.g. LDAP-Group and SQL-Group.
					 */
					for (i = 0; i < c->data.map->lhs->len; i++) {
						if (!dict_attr_allowed_chars[(unsigned char) c->data.map->lhs->name[i]]) {
							may_be_attr = false;
							break;
						}

						if (c->data.map->lhs->name[i] == '-') {
							hyphens++;
						}
					}

					if (!hyphens || (hyphens > 3)) may_be_attr = false;

					if (may_be_attr) {
						attr_slen = tmpl_afrom_attr_str(c->data.map, &vpt, lhs,
										REQUEST_CURRENT, PAIR_LIST_REQUEST,
										true, true);
						if ((attr_slen > 0) && (vpt->len == c->data.map->lhs->len)) {
							talloc_free(c->data.map->lhs);
							c->data.map->lhs = vpt;
							c->pass2_fixup = PASS2_FIXUP_ATTR;
						}
					}
				}
			} /* we didn't have a cast */

		keep_going:
			p += slen;

			while (isspace((int) *p)) p++; /* skip spaces after RHS */
		} /* parse OP RHS */
	} /* parse a condition (COND) or FOO OP BAR*/

	/*
	 *	...COND)
	 */
	if (*p == ')') {
		if (!brace) {
			return_P("Unexpected closing brace");
		}

		p++;
		while (isspace((int) *p)) p++; /* skip spaces after closing brace */
		goto done;
	}

	/*
	 *	End of string is now allowed.
	 */
	if (!*p) {
		if (brace) {
			return_P("No closing brace at end of string");
		}

		goto done;
	}

	if (!(((p[0] == '&') && (p[1] == '&')) ||
	      ((p[0] == '|') && (p[1] == '|')))) {
		*error = "Unexpected text after condition";
	return_p:
		if (lhs) talloc_free(lhs);
		if (rhs) talloc_free(rhs);
		talloc_free(c);
		return -(p - start);
	}

	/*
	 *	Recurse to parse the next condition.
	 */
	c->next_op = p[0];
	p += 2;

	/*
	 *	May still be looking for a closing brace.
	 */
	slen = condition_tokenize(c, ci, p, brace, &c->next, error, flags);
	if (slen <= 0) {
	return_slen:
		if (lhs) talloc_free(lhs);
		if (rhs) talloc_free(rhs);
		talloc_free(c);
		return slen - (p - start);
	}
	p += slen;

done:
	/*
	 *	Normalize the condition before returning.
	 *
	 *	We collapse multiple levels of braces to one.  Then
	 *	convert maps to literals.  Then literals to true/false
	 *	statements.  Then true/false ||/&& followed by other
	 *	conditions to just conditions.
	 *
	 *	Order is important.  The more complex cases are
	 *	converted to simpler ones, from the most complex cases
	 *	to the simplest ones.
	 */

	/*
	 *	(FOO)     --> FOO
	 *	(FOO) ... --> FOO ...
	 */
	if ((c->type == COND_TYPE_CHILD) && !c->data.child->next) {
		fr_cond_t *child;

		child = talloc_steal(ctx, c->data.child);
		c->data.child = NULL;

		child->next = talloc_steal(child, c->next);
		c->next = NULL;

		child->next_op = c->next_op;

		/*
		 *	Set the negation properly
		 */
		if ((c->negate && !child->negate) ||
		    (!c->negate && child->negate)) {
			child->negate = true;
		} else {
			child->negate = false;
		}

		lhs = rhs = NULL;
		talloc_free(c);
		c = child;
	}

	/*
	 *	(FOO ...) --> FOO ...
	 *
	 *	But don't do !(FOO || BAR) --> !FOO || BAR
	 *	Because that's different.
	 */
	if ((c->type == COND_TYPE_CHILD) &&
	    !c->next && !c->negate) {
		fr_cond_t *child;

		child = talloc_steal(ctx, c->data.child);
		c->data.child = NULL;

		lhs = rhs = NULL;
		talloc_free(c);
		c = child;
	}

	/*
	 *	Convert maps to literals.  Convert one form of map to
	 *	a standardized form.  This doesn't make any
	 *	theoretical difference, but it does mean that the
	 *	run-time evaluation has fewer cases to check.
	 */
	if (c->type == COND_TYPE_MAP) do {
		VERIFY_MAP(c->data.map);

		/*
		 *	!FOO !~ BAR --> FOO =~ BAR
		 */
		if (c->negate && (c->data.map->op == T_OP_REG_NE)) {
			c->negate = false;
			c->data.map->op = T_OP_REG_EQ;
		}

		/*
		 *	FOO !~ BAR --> !FOO =~ BAR
		 */
		if (!c->negate && (c->data.map->op == T_OP_REG_NE)) {
			c->negate = true;
			c->data.map->op = T_OP_REG_EQ;
		}

		/*
		 *	!FOO != BAR --> FOO == BAR
		 */
		if (c->negate && (c->data.map->op == T_OP_NE)) {
			c->negate = false;
			c->data.map->op = T_OP_CMP_EQ;
		}

		/*
		 *	This next one catches "LDAP-Group != foo",
		 *	which doesn't work as-is, but this hack fixes
		 *	it.
		 *
		 *	FOO != BAR --> !FOO == BAR
		 */
		if (!c->negate && (c->data.map->op == T_OP_NE)) {
			c->negate = true;
			c->data.map->op = T_OP_CMP_EQ;
		}

		/*
		 *	FOO =* BAR --> FOO
		 *	FOO !* BAR --> !FOO
		 *
		 *	FOO may be a string, or a delayed attribute
		 *	reference.
		 */
		if ((c->data.map->op == T_OP_CMP_TRUE) ||
		    (c->data.map->op == T_OP_CMP_FALSE)) {
			vp_tmpl_t *vpt;

			vpt = talloc_steal(c, c->data.map->lhs);
			c->data.map->lhs = NULL;

			/*
			 *	Invert the negation bit.
			 */
			if (c->data.map->op == T_OP_CMP_FALSE) {
				c->negate = !c->negate;
			}

			TALLOC_FREE(c->data.map);

			c->type = COND_TYPE_EXISTS;
			c->data.vpt = vpt;
			break;	/* it's no longer a map */
		}

		/*
		 *	Both are data (IP address, integer, etc.)
		 *
		 *	We can do the evaluation here, so that it
		 *	doesn't need to be done at run time
		 */
		if ((c->data.map->lhs->type == TMPL_TYPE_DATA) &&
		    (c->data.map->rhs->type == TMPL_TYPE_DATA)) {
			int rcode;

			rad_assert(c->cast != NULL);

			rcode = radius_evaluate_map(NULL, 0, 0, c);
			TALLOC_FREE(c->data.map);
			c->cast = NULL;
			if (rcode) {
				c->type = COND_TYPE_TRUE;
			} else {
				c->type = COND_TYPE_FALSE;
			}

			break;	/* it's no longer a map */
		}

		/*
		 *	Both are literal strings.  They're not parsed
		 *	as TMPL_TYPE_DATA because there's no cast to an
		 *	attribute.
		 *
		 *	We can do the evaluation here, so that it
		 *	doesn't need to be done at run time
		 */
		if ((c->data.map->rhs->type == TMPL_TYPE_LITERAL) &&
		    (c->data.map->lhs->type == TMPL_TYPE_LITERAL) &&
		    !c->pass2_fixup) {
			int rcode;

			rad_assert(c->cast == NULL);

			rcode = radius_evaluate_map(NULL, 0, 0, c);
			if (rcode) {
				c->type = COND_TYPE_TRUE;
			} else {
				DEBUG3("OPTIMIZING (%s %s %s) --> FALSE",
				       c->data.map->lhs->name,
				       fr_int2str(fr_tokens, c->data.map->op, "??"),
				       c->data.map->rhs->name);
				c->type = COND_TYPE_FALSE;
			}

			/*
			 *	Free map after using it above.
			 */
			TALLOC_FREE(c->data.map);
			break;
		}

		/*
		 *	<ipaddr>"foo" CMP &Attribute-Name The cast may
		 *	not be necessary, and we can re-write it so
		 *	that the attribute reference is on the LHS.
		 */
		if (c->cast &&
		    (c->data.map->rhs->type == TMPL_TYPE_ATTR) &&
		    (c->cast->type == c->data.map->rhs->tmpl_da->type) &&
		    (c->data.map->lhs->type != TMPL_TYPE_ATTR)) {
			vp_tmpl_t *tmp;

			tmp = c->data.map->rhs;
			c->data.map->rhs = c->data.map->lhs;
			c->data.map->lhs = tmp;

			c->cast = NULL;

			switch (c->data.map->op) {
			case T_OP_CMP_EQ:
				/* do nothing */
				break;

			case T_OP_LE:
				c->data.map->op = T_OP_GE;
				break;

			case T_OP_LT:
				c->data.map->op = T_OP_GT;
				break;

			case T_OP_GE:
				c->data.map->op = T_OP_LE;
				break;

			case T_OP_GT:
				c->data.map->op = T_OP_LT;
				break;

			default:
				return_0("Internal sanity check failed 1");
			}

			/*
			 *	This must have been parsed into TMPL_TYPE_DATA.
			 */
			rad_assert(c->data.map->rhs->type != TMPL_TYPE_LITERAL);
		}

	} while (0);

	/*
	 *	Existence checks.  We short-circuit static strings,
	 *	too.
	 *
	 *	FIXME: the data types should be in the template, too.
	 *	So that we know where a literal came from.
	 *
	 *	"foo" is NOT the same as 'foo' or a bare foo.
	 */
	if (c->type == COND_TYPE_EXISTS) {
		VERIFY_TMPL(c->data.vpt);

		switch (c->data.vpt->type) {
		case TMPL_TYPE_XLAT:
		case TMPL_TYPE_ATTR:
		case TMPL_TYPE_ATTR_UNDEFINED:
		case TMPL_TYPE_LIST:
		case TMPL_TYPE_EXEC:
			break;

			/*
			 *	'true' and 'false' are special strings
			 *	which mean themselves.
			 *
			 *	For integers, 0 is false, all other
			 *	integers are true.
			 *
			 *	For strings, '' and "" are false.
			 *	'foo' and "foo" are true.
			 *
			 *	The str2tmpl function takes care of
			 *	marking "%{foo}" as TMPL_TYPE_XLAT, so
			 *	the strings here are fixed at compile
			 *	time.
			 *
			 *	`exec` and "%{...}" are left alone.
			 *
			 *	Bare words must be module return
			 *	codes.
			 */
		case TMPL_TYPE_LITERAL:
			if ((strcmp(c->data.vpt->name, "true") == 0) ||
			    (strcmp(c->data.vpt->name, "1") == 0)) {
				c->type = COND_TYPE_TRUE;
				TALLOC_FREE(c->data.vpt);

			} else if ((strcmp(c->data.vpt->name, "false") == 0) ||
				   (strcmp(c->data.vpt->name, "0") == 0)) {
				c->type = COND_TYPE_FALSE;
				TALLOC_FREE(c->data.vpt);

			} else if (!*c->data.vpt->name) {
				c->type = COND_TYPE_FALSE;
				TALLOC_FREE(c->data.vpt);

			} else if ((lhs_type == T_SINGLE_QUOTED_STRING) ||
				   (lhs_type == T_DOUBLE_QUOTED_STRING)) {
				c->type = COND_TYPE_TRUE;
				TALLOC_FREE(c->data.vpt);

			} else if (lhs_type == T_BARE_WORD) {
				int rcode;
				bool zeros = true;
				char const *q;

				for (q = c->data.vpt->name;
				     *q != '\0';
				     q++) {
					if (!isdigit((int) *q)) {
						break;
					}
					if (*q != '0') zeros = false;
				}

				/*
				 *	It's all digits, and therefore
				 *	'false' if zero, and 'true' otherwise.
				 */
				if (!*q) {
					if (zeros) {
						c->type = COND_TYPE_FALSE;
					} else {
						c->type = COND_TYPE_TRUE;
					}
					TALLOC_FREE(c->data.vpt);
					break;
				}

				/*
				 *	Allow &Foo-Bar where Foo-Bar is an attribute
				 *	defined by a module.
				 */
				if (c->pass2_fixup == PASS2_FIXUP_ATTR) {
					break;
				}

				rcode = fr_str2int(allowed_return_codes,
						   c->data.vpt->name, 0);
				if (!rcode) {
					return_0("Expected a module return code");
				}
			}

			/*
			 *	Else lhs_type==T_INVALID, and this
			 *	node was made by promoting a child
			 *	which had already been normalized.
			 */
			break;

		case TMPL_TYPE_DATA:
			return_0("Cannot use data here");

		default:
			return_0("Internal sanity check failed 2");
		}
	}

	/*
	 *	!TRUE -> FALSE
	 */
	if (c->type == COND_TYPE_TRUE) {
		if (c->negate) {
			c->negate = false;
			c->type = COND_TYPE_FALSE;
		}
	}

	/*
	 *	!FALSE -> TRUE
	 */
	if (c->type == COND_TYPE_FALSE) {
		if (c->negate) {
			c->negate = false;
			c->type = COND_TYPE_TRUE;
		}
	}

	/*
	 *	true && FOO --> FOO
	 */
	if ((c->type == COND_TYPE_TRUE) &&
	    (c->next_op == COND_AND)) {
		fr_cond_t *next;

		next = talloc_steal(ctx, c->next);
		c->next = NULL;

		lhs = rhs = NULL;
		talloc_free(c);
		c = next;
	}

	/*
	 *	false && FOO --> false
	 */
	if ((c->type == COND_TYPE_FALSE) &&
	    (c->next_op == COND_AND)) {
		talloc_free(c->next);
		c->next = NULL;
		c->next_op = COND_NONE;
	}

	/*
	 *	false || FOO --> FOO
	 */
	if ((c->type == COND_TYPE_FALSE) &&
	    (c->next_op == COND_OR)) {
		fr_cond_t *next;

		next = talloc_steal(ctx, c->next);
		c->next = NULL;

		lhs = rhs = NULL;
		talloc_free(c);
		c = next;
	}

	/*
	 *	true || FOO --> true
	 */
	if ((c->type == COND_TYPE_TRUE) &&
	    (c->next_op == COND_OR)) {
		talloc_free(c->next);
		c->next = NULL;
		c->next_op = COND_NONE;
	}

	if (lhs) talloc_free(lhs);
	if (rhs) talloc_free(rhs);

	*pcond = c;
	return p - start;
}

/** Tokenize a conditional check
 *
 *  @param[in] ctx for talloc
 *  @param[in] ci for CONF_ITEM
 *  @param[in] start the start of the string to process.  Should be "(..."
 *  @param[out] head the parsed condition structure
 *  @param[out] error the parse error (if any)
 *  @param[in] flags do one/two pass
 *  @return length of the string skipped, or when negative, the offset to the offending error
 */
ssize_t fr_condition_tokenize(TALLOC_CTX *ctx, CONF_ITEM *ci, char const *start, fr_cond_t **head, char const **error, int flags)
{
	return condition_tokenize(ctx, ci, start, false, head, error, flags);
}

/*
 *	Walk in order.
 */
bool fr_condition_walk(fr_cond_t *c, bool (*callback)(void *, fr_cond_t *), void *ctx)
{
	while (c) {
		/*
		 *	Process this one, exit on error.
		 */
		if (!callback(ctx, c)) return false;

		switch (c->type) {
		case COND_TYPE_INVALID:
			return false;

		case COND_TYPE_EXISTS:
		case COND_TYPE_MAP:
		case COND_TYPE_TRUE:
		case COND_TYPE_FALSE:
			break;

		case COND_TYPE_CHILD:
			/*
			 *	Walk over the child.
			 */
			if (!fr_condition_walk(c->data.child, callback, ctx)) {
				return false;
			}
		}

		/*
		 *	No sibling, stop.
		 */
		if (c->next_op == COND_NONE) break;

		/*
		 *	process the next sibling
		 */
		c = c->next;
	}

	return true;
}