[lttng-tools.git] / src / common / 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>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

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

#include <common/macros.h>
#include <common/compat/errno.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;

			LTTNG_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	*
ab5be9fa	6	* Copyright 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
dcd5daf2	7	*
ab5be9fa	8	* SPDX-License-Identifier: LGPL-2.1-only
dcd5daf2	9	*
dcd5daf2 JG	10	*/
	11
	12	#include <stdio.h>
	13	#include <unistd.h>
	14	#include <string.h>
	15	#include <stdlib.h>
dcd5daf2	16	#include <inttypes.h>
ed4549a1 DG	17
ed4549a1 DG	18	#include <common/macros.h>
edf4b93e	19	#include <common/compat/errno.h>
ed4549a1	20
dcd5daf2 JG	21	#include "filter-ast.h"
	22	#include "filter-parser.h"
	23	#include "filter-ir.h"
	24
	25	enum parse_char_result {
	26	PARSE_CHAR_UNKNOWN = -2,
	27	PARSE_CHAR_WILDCARD = -1,
	28	PARSE_CHAR_NORMAL = 0,
	29	};
	30
	31	static
	32	enum parse_char_result parse_char(const char **p)
	33	{
	34	switch (**p) {
	35	case '\\':
	36	(*p)++;
	37	switch (**p) {
	38	case '\\':
	39	case '*':
	40	return PARSE_CHAR_NORMAL;
	41	default:
	42	return PARSE_CHAR_UNKNOWN;
	43	}
	44	case '*':
	45	return PARSE_CHAR_WILDCARD;
	46	default:
	47	return PARSE_CHAR_NORMAL;
	48	}
	49	}
	50
	51	static
	52	int validate_string(struct ir_op *node)
	53	{
	54	switch (node->op) {
	55	case IR_OP_UNKNOWN:
	56	default:
	57	fprintf(stderr, "[error] %s: unknown op type\n", __func__);
	58	return -EINVAL;
	59
	60	case IR_OP_ROOT:
	61	return validate_string(node->u.root.child);
	62	case IR_OP_LOAD:
	63	{
	64	int ret = 0;
	65
	66	if (node->data_type == IR_DATA_STRING) {
	67	const char *str;
	68
a0377dfe	69	LTTNG_ASSERT(node->u.load.u.string.value);
9f449915	70	str = node->u.load.u.string.value;
dcd5daf2	71
dcd5daf2 JG	72	for (;;) {
	73	enum parse_char_result res;
	74
	75	if (!(*str)) {
	76	break;
	77	}
	78
	79	res = parse_char(&str);
	80	str++;
	81
	82	switch (res) {
dcd5daf2 JG	83	case PARSE_CHAR_UNKNOWN:
	84	ret = -EINVAL;
	85	fprintf(stderr,
	86	"Unsupported escape character detected.\n");
	87	goto end_load;
	88	case PARSE_CHAR_NORMAL:
	89	default:
	90	break;
	91	}
	92	}
	93	}
	94	end_load:
	95	return ret;
	96	}
	97	case IR_OP_UNARY:
	98	return validate_string(node->u.unary.child);
	99	case IR_OP_BINARY:
	100	{
	101	int ret = validate_string(node->u.binary.left);
	102
	103	if (ret)
	104	return ret;
	105	return validate_string(node->u.binary.right);
	106	}
	107	case IR_OP_LOGICAL:
	108	{
	109	int ret;
	110
	111	ret = validate_string(node->u.logical.left);
	112	if (ret)
	113	return ret;
	114	return validate_string(node->u.logical.right);
	115	}
	116	}
	117	}
	118
ed4549a1	119	LTTNG_HIDDEN
dcd5daf2 JG	120	int filter_visitor_ir_validate_string(struct filter_parser_ctx *ctx)
	121	{
	122	return validate_string(ctx->ir_root);
	123	}