freebsd-src/usr.sbin/jail/jailparse.y

%{
/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2011 James Gritton
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#include <err.h>
#include <stdlib.h>
#include <string.h>

#include "jailp.h"

#ifdef DEBUG
#define YYDEBUG 1
#endif

static struct cfjail *current_jail;
static struct cfjail *global_jail;
%}

%union {
	struct cfparam		*p;
	struct cfstrings	*ss;
	struct cfstring		*s;
	char			*cs;
}

%token      PLEQ
%token <cs> STR STR1 VAR VAR1

%type <p>  param name
%type <ss> value
%type <s>  string

%pure-parser

%lex-param { void *scanner }
%parse-param { void *scanner }

%%

/*
 * A config file is a list of jails and parameters.  Parameters are
 * added to the current jail, otherwise to a global pesudo-jail.
 */
conf	:
	| conf jail
	| conf param ';'
	{
		if (!special_param($2, scanner)) {
			struct cfjail *j = current_jail;

			if (j == NULL) {
				if (global_jail == NULL) {
					global_jail = add_jail();
					global_jail->name = estrdup("*");
				}
				j = global_jail;
			}
			TAILQ_INSERT_TAIL(&j->params, $2, tq);
		}
	}
	| conf ';'
	;

jail	: jail_name '{' conf '}'
	{
		current_jail = current_jail->cfparent;
	}
	;

jail_name : STR
	{
		struct cfjail *j = add_jail();

		if (current_jail == NULL)
			j->name = $1;
		else {
			/*
			 * A nested jail definition becomes
			 * a hierarchically-named sub-jail.
			 */
			size_t parentlen = strlen(current_jail->name);
			j->name = emalloc(parentlen + strlen($1) + 2);
			strcpy(j->name, current_jail->name);
			j->name[parentlen++] = '.';
			strcpy(j->name + parentlen, $1);
			free($1);
		}
		j->cfparent = current_jail;
		current_jail = j;
	}
	;

/*
 * Parameters have a name and an optional list of value strings,
 * which may have "+=" or "=" preceding them.
 */
param	: name
	{
		$$ = $1;
	}
	| name '=' value
	{
		$$ = $1;
		TAILQ_CONCAT(&$$->val, $3, tq);
		free($3);
	}
	| name PLEQ value
	{
		$$ = $1;
		TAILQ_CONCAT(&$$->val, $3, tq);
		$$->flags |= PF_APPEND;
		free($3);
	}
	| name value
	{
		$$ = $1;
		TAILQ_CONCAT(&$$->val, $2, tq);
		$$->flags |= PF_NAMEVAL;
		free($2);
	}
	| error
	;

/*
 * A parameter has a fixed name.  A variable definition looks just like a
 * parameter except that the name is a variable.
 */
name	: STR
	{
		$$ = emalloc(sizeof(struct cfparam));
		$$->name = $1;
		TAILQ_INIT(&$$->val);
		$$->flags = 0;
	}
	| VAR
	{
		$$ = emalloc(sizeof(struct cfparam));
		$$->name = $1;
		TAILQ_INIT(&$$->val);
		$$->flags = PF_VAR;
	}
	;

value	: string
	{
		$$ = emalloc(sizeof(struct cfstrings));
		TAILQ_INIT($$);
		TAILQ_INSERT_TAIL($$, $1, tq);
	}
	| value ',' string
	{
		$$ = $1;
		TAILQ_INSERT_TAIL($$, $3, tq);
	}
	;

/*
 * Strings may be passed in pieces, because of quoting and/or variable
 * interpolation.  Reassemble them into a single string.
 */
string	: STR
	{
		$$ = emalloc(sizeof(struct cfstring));
		$$->s = $1;
		$$->len = strlen($1);
		STAILQ_INIT(&$$->vars);
	}
	| VAR
	{
		struct cfvar *v;

		$$ = emalloc(sizeof(struct cfstring));
		$$->s = estrdup("");
		$$->len = 0;
		STAILQ_INIT(&$$->vars);
		v = emalloc(sizeof(struct cfvar));
		v->name = $1;
		v->pos = 0;
		STAILQ_INSERT_TAIL(&$$->vars, v, tq);
	}
	| string STR1
	{
		size_t len1;

		$$ = $1;
		len1 = strlen($2);
		$$->s = erealloc($$->s, $$->len + len1 + 1);
		strcpy($$->s + $$->len, $2);
		free($2);
		$$->len += len1;
	}
	| string VAR1
	{
		struct cfvar *v;

		$$ = $1;
		v = emalloc(sizeof(struct cfvar));
		v->name = $2;
		v->pos = $$->len;
		STAILQ_INSERT_TAIL(&$$->vars, v, tq);
	}
	;

%%

extern int YYLEX_DECL();

static void
YYERROR_DECL()
{
	struct cflex *cflex = yyget_extra(scanner);

	if (!yyget_text(scanner))
		warnx("%s line %d: %s",
		    cflex->cfname, yyget_lineno(scanner), s);
	else if (!yyget_text(scanner)[0])
		warnx("%s: unexpected EOF",
		    cflex->cfname);
	else
		warnx("%s line %d: %s: %s",
		    cflex->cfname, yyget_lineno(scanner),
		    yyget_text(scanner), s);
	cflex->error = 1;
}

/* Handle special parameters (i.e. the include directive).
 * Return true if the parameter was specially handled.
 */
static int
special_param(struct cfparam *p, void *scanner)
{
	if ((p->flags & (PF_VAR | PF_APPEND | PF_NAMEVAL)) != PF_NAMEVAL
	    || strcmp(p->name, ".include"))
		return 0;
	struct cfstring *s;
	TAILQ_FOREACH(s, &p->val, tq) {
		if (STAILQ_EMPTY(&s->vars))
			include_config(scanner, s->s);
		else {
			warnx("%s line %d: "
			    "variables not permitted in '.include' filename",
			    yyget_extra(scanner)->cfname,
			    yyget_lineno(scanner));
			yyget_extra(scanner)->error = 1;
		}
	}
	free_param_strings(p);
	free(p);
	return 1;
}