[lttng-tools.git] / src / lib / lttng-ctl / filter / filter-visitor-ir-validate-string.c

/*
 * filter-visitor-ir-validate-string.c
 *
 * LTTng filter IR validate string
 *
 * Copyright 2014 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License, version 2.1 only,
 * as published by the Free Software Foundation.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <errno.h>
#include <inttypes.h>

#include <common/macros.h>

#include "filter-ast.h"
#include "filter-parser.h"
#include "filter-ir.h"

enum parse_char_result {
	PARSE_CHAR_UNKNOWN = -2,
	PARSE_CHAR_WILDCARD = -1,
	PARSE_CHAR_NORMAL = 0,
};

static
enum parse_char_result parse_char(const char **p)
{
	switch (**p) {
	case '\\':
		(*p)++;
		switch (**p) {
		case '\\':
		case '*':
			return PARSE_CHAR_NORMAL;
		default:
			return PARSE_CHAR_UNKNOWN;
		}
	case '*':
		return PARSE_CHAR_WILDCARD;
	default:
		return PARSE_CHAR_NORMAL;
	}
}

static
int validate_string(struct ir_op *node)
{
	switch (node->op) {
	case IR_OP_UNKNOWN:
	default:
		fprintf(stderr, "[error] %s: unknown op type\n", __func__);
		return -EINVAL;

	case IR_OP_ROOT:
		return validate_string(node->u.root.child);
	case IR_OP_LOAD:
	{
		int ret = 0;

		if (node->data_type == IR_DATA_STRING) {
			const char *str;

			assert(node->u.load.u.string.value);
			str = node->u.load.u.string.value;

			for (;;) {
				enum parse_char_result res;

				if (!(*str)) {
					break;
				}

				res = parse_char(&str);
				str++;

				switch (res) {
				case PARSE_CHAR_UNKNOWN:
					ret = -EINVAL;
					fprintf(stderr,
						"Unsupported escape character detected.\n");
					goto end_load;
				case PARSE_CHAR_NORMAL:
				default:
					break;
				}
			}
		}
end_load:
		return ret;
	}
	case IR_OP_UNARY:
		return validate_string(node->u.unary.child);
	case IR_OP_BINARY:
	{
		int ret = validate_string(node->u.binary.left);

		if (ret)
			return ret;
		return validate_string(node->u.binary.right);
	}
	case IR_OP_LOGICAL:
	{
		int ret;

		ret = validate_string(node->u.logical.left);
		if (ret)
			return ret;
		return validate_string(node->u.logical.right);
	}
	}
}

LTTNG_HIDDEN
int filter_visitor_ir_validate_string(struct filter_parser_ctx *ctx)
{
	return validate_string(ctx->ir_root);
}
Commit	Line	Data
dcd5daf2 JG	1	/*
	2	* filter-visitor-ir-validate-string.c
	3	*
	4	* LTTng filter IR validate string
	5	*
	6	* Copyright 2014 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
	7	*
	8	* This library is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU Lesser General Public License, version 2.1 only,
	10	* as published by the Free Software Foundation.
	11	*
	12	* This library is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public License
	18	* along with this library; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include <stdio.h>
	23	#include <unistd.h>
	24	#include <string.h>
	25	#include <stdlib.h>
	26	#include <assert.h>
	27	#include <errno.h>
	28	#include <inttypes.h>
ed4549a1 DG	29
	30	#include <common/macros.h>
	31
dcd5daf2 JG	32	#include "filter-ast.h"
	33	#include "filter-parser.h"
	34	#include "filter-ir.h"
	35
	36	enum parse_char_result {
	37	PARSE_CHAR_UNKNOWN = -2,
	38	PARSE_CHAR_WILDCARD = -1,
	39	PARSE_CHAR_NORMAL = 0,
	40	};
	41
	42	static
	43	enum parse_char_result parse_char(const char **p)
	44	{
	45	switch (**p) {
	46	case '\\':
	47	(*p)++;
	48	switch (**p) {
	49	case '\\':
	50	case '*':
	51	return PARSE_CHAR_NORMAL;
	52	default:
	53	return PARSE_CHAR_UNKNOWN;
	54	}
	55	case '*':
	56	return PARSE_CHAR_WILDCARD;
	57	default:
	58	return PARSE_CHAR_NORMAL;
	59	}
	60	}
	61
	62	static
	63	int validate_string(struct ir_op *node)
	64	{
	65	switch (node->op) {
	66	case IR_OP_UNKNOWN:
	67	default:
	68	fprintf(stderr, "[error] %s: unknown op type\n", __func__);
	69	return -EINVAL;
	70
	71	case IR_OP_ROOT:
	72	return validate_string(node->u.root.child);
	73	case IR_OP_LOAD:
	74	{
	75	int ret = 0;
	76
	77	if (node->data_type == IR_DATA_STRING) {
	78	const char *str;
	79
9f449915 PP	80	assert(node->u.load.u.string.value);
9f449915 PP	81	str = node->u.load.u.string.value;
dcd5daf2	82
dcd5daf2 JG	83	for (;;) {
	84	enum parse_char_result res;
	85
	86	if (!(*str)) {
	87	break;
	88	}
	89
	90	res = parse_char(&str);
	91	str++;
	92
	93	switch (res) {
dcd5daf2 JG	94	case PARSE_CHAR_UNKNOWN:
	95	ret = -EINVAL;
	96	fprintf(stderr,
	97	"Unsupported escape character detected.\n");
	98	goto end_load;
	99	case PARSE_CHAR_NORMAL:
	100	default:
	101	break;
	102	}
	103	}
	104	}
	105	end_load:
	106	return ret;
	107	}
	108	case IR_OP_UNARY:
	109	return validate_string(node->u.unary.child);
	110	case IR_OP_BINARY:
	111	{
	112	int ret = validate_string(node->u.binary.left);
	113
	114	if (ret)
	115	return ret;
	116	return validate_string(node->u.binary.right);
	117	}
	118	case IR_OP_LOGICAL:
	119	{
	120	int ret;
	121
	122	ret = validate_string(node->u.logical.left);
	123	if (ret)
	124	return ret;
	125	return validate_string(node->u.logical.right);
	126	}
	127	}
	128	}
	129
ed4549a1	130	LTTNG_HIDDEN
dcd5daf2 JG	131	int filter_visitor_ir_validate_string(struct filter_parser_ctx *ctx)
	132	{
	133	return validate_string(ctx->ir_root);
	134	}