libsepol/cil/src/cil_parser.c - platform/external/selinux - Git at Google

 /*
  * Copyright 2011 Tresys Technology, LLC. 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 TRESYS TECHNOLOGY, LLC ``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 TRESYS TECHNOLOGY, LLC 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.
  *
  * The views and conclusions contained in the software and documentation are those
  * of the authors and should not be interpreted as representing official policies,
  * either expressed or implied, of Tresys Technology, LLC.
  */

 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdint.h>
 #include <sepol/errcodes.h>

 #include "cil_internal.h"
 #include "cil_log.h"
 #include "cil_mem.h"
 #include "cil_tree.h"
 #include "cil_lexer.h"
 #include "cil_parser.h"
 #include "cil_strpool.h"
 #include "cil_stack.h"

 #define CIL_PARSER_MAX_EXPR_DEPTH (0x1 << 12)

 struct hll_info {
 	uint32_t hll_offset;
 	uint32_t hll_expand;
 };

 static void push_hll_info(struct cil_stack *stack, uint32_t hll_offset, uint32_t hll_expand)
 {
 	struct hll_info *new = cil_malloc(sizeof(*new));

 	new->hll_offset = hll_offset;
 	new->hll_expand = hll_expand;

 	cil_stack_push(stack, CIL_NONE, new);
 }

 static void pop_hll_info(struct cil_stack *stack, uint32_t *hll_offset, uint32_t *hll_expand)
 {
 	struct cil_stack_item *curr = cil_stack_pop(stack);
 	struct hll_info *info;

 	if (!curr) {
 		return;
 	}
 	info = curr->data;
 	*hll_expand = info->hll_expand;
 	*hll_offset = info->hll_offset;
 	free(curr->data);
 }

 static void create_node(struct cil_tree_node **node, struct cil_tree_node *current, uint32_t line, uint32_t hll_offset, void *value)
 {
 	cil_tree_node_init(node);
 	(*node)->parent = current;
 	(*node)->flavor = CIL_NODE;
 	(*node)->line = line;
 	(*node)->hll_offset = hll_offset;
 	(*node)->data = value;
 }

 static void insert_node(struct cil_tree_node *node, struct cil_tree_node *current)
 {
 	if (current->cl_head == NULL) {
 		current->cl_head = node;
 	} else {
 		current->cl_tail->next = node;
 	}
 	current->cl_tail = node;
 }

 static int add_hll_linemark(struct cil_tree_node **current, uint32_t *hll_offset, uint32_t *hll_expand, struct cil_stack *stack, char *path)
 {
 	char *hll_type;
 	struct cil_tree_node *node;
 	struct token tok;
 	uint32_t prev_hll_expand, prev_hll_offset;

 	cil_lexer_next(&tok);
 	if (tok.type != SYMBOL) {
 		cil_log(CIL_ERR, "Invalid line mark syntax\n");
 		goto exit;
 	}
 	hll_type = cil_strpool_add(tok.value);
 	if (hll_type != CIL_KEY_SRC_HLL_LME && hll_type != CIL_KEY_SRC_HLL_LMS && hll_type != CIL_KEY_SRC_HLL_LMX) {
 		cil_log(CIL_ERR, "Invalid line mark syntax\n");
 		goto exit;
 	}
 	if (hll_type == CIL_KEY_SRC_HLL_LME) {
 		if (cil_stack_is_empty(stack)) {
 			cil_log(CIL_ERR, "Line mark end without start\n");
 			goto exit;
 		}
 		prev_hll_expand = *hll_expand;
 		prev_hll_offset = *hll_offset;
 		pop_hll_info(stack, hll_offset, hll_expand);
 		if (!*hll_expand) {
 			/* This is needed if not going back to an lmx section. */
 			*hll_offset = prev_hll_offset;
 		}
 		if (prev_hll_expand && !*hll_expand) {
 			/* This is needed to count the lme at the end of an lmx section
 			 * within an lms section (or within no hll section).
 			 */
 			(*hll_offset)++;
 		}
 		*current = (*current)->parent;
 	} else {
 		push_hll_info(stack, *hll_offset, *hll_expand);
 		if (cil_stack_number_of_items(stack) > CIL_PARSER_MAX_EXPR_DEPTH) {
 			cil_log(CIL_ERR, "Number of active line marks exceeds limit of %d\n", CIL_PARSER_MAX_EXPR_DEPTH);
 			goto exit;
 		}

 		create_node(&node, *current, tok.line, *hll_offset, NULL);
 		insert_node(node, *current);
 		*current = node;

 		create_node(&node, *current, tok.line, *hll_offset, CIL_KEY_SRC_INFO);
 		insert_node(node, *current);

 		create_node(&node, *current, tok.line, *hll_offset, hll_type);
 		insert_node(node, *current);

 		cil_lexer_next(&tok);
 		if (tok.type != SYMBOL) {
 			cil_log(CIL_ERR, "Invalid line mark syntax\n");
 			goto exit;
 		}

 		create_node(&node, *current, tok.line, *hll_offset, cil_strpool_add(tok.value));
 		insert_node(node, *current);

 		cil_lexer_next(&tok);
 		if (tok.type != SYMBOL && tok.type != QSTRING) {
 			cil_log(CIL_ERR, "Invalid line mark syntax\n");
 			goto exit;
 		}

 		if (tok.type == QSTRING) {
 			tok.value[strlen(tok.value) - 1] = '\0';
 			tok.value = tok.value+1;
 		}

 		create_node(&node, *current, tok.line, *hll_offset, cil_strpool_add(tok.value));
 		insert_node(node, *current);

 		*hll_expand = (hll_type == CIL_KEY_SRC_HLL_LMX) ? 1 : 0;
 	}

 	cil_lexer_next(&tok);
 	if (tok.type != NEWLINE) {
 		cil_log(CIL_ERR, "Invalid line mark syntax\n");
 		goto exit;
 	}

 	if (!*hll_expand) {
 		/* Need to increment because of the NEWLINE */
 		(*hll_offset)++;
 	}

 	return SEPOL_OK;

 exit:
 	cil_log(CIL_ERR, "Problem with high-level line mark at line %u of %s\n", tok.line, path);
 	return SEPOL_ERR;
 }

 static void add_cil_path(struct cil_tree_node **current, char *path)
 {
 	struct cil_tree_node *node;

 	create_node(&node, *current, 0, 0, NULL);
 	insert_node(node, *current);
 	*current = node;

 	create_node(&node, *current, 0, 0, CIL_KEY_SRC_INFO);
 	insert_node(node, *current);

 	create_node(&node, *current, 0, 0, CIL_KEY_SRC_CIL);
 	insert_node(node, *current);

 	create_node(&node, *current, 0, 0, cil_strpool_add("1"));
 	insert_node(node, *current);

 	create_node(&node, *current, 0, 0, path);
 	insert_node(node, *current);
 }

 int cil_parser(const char *_path, char *buffer, uint32_t size, struct cil_tree **parse_tree)
 {

 	int paren_count = 0;

 	struct cil_tree *tree = NULL;
 	struct cil_tree_node *node = NULL;
 	struct cil_tree_node *current = NULL;
 	char *path = cil_strpool_add(_path);
 	struct cil_stack *stack;
 	uint32_t hll_offset = 1;
 	uint32_t hll_expand = 0;
 	struct token tok;
 	int rc = SEPOL_OK;

 	cil_stack_init(&stack);

 	cil_lexer_setup(buffer, size);

 	tree = *parse_tree;
 	current = tree->root;

 	add_cil_path(&current, path);

 	do {
 		cil_lexer_next(&tok);
 		switch (tok.type) {
 		case HLL_LINEMARK:
 			rc = add_hll_linemark(&current, &hll_offset, &hll_expand, stack, path);
 			if (rc != SEPOL_OK) {
 				goto exit;
 			}
 			break;
 		case OPAREN:
 			paren_count++;
 			if (paren_count > CIL_PARSER_MAX_EXPR_DEPTH) {
 				cil_log(CIL_ERR, "Number of open parenthesis exceeds limit of %d at line %d of %s\n", CIL_PARSER_MAX_EXPR_DEPTH, tok.line, path);
 				goto exit;
 			}
 			create_node(&node, current, tok.line, hll_offset, NULL);
 			insert_node(node, current);
 			current = node;
 			break;
 		case CPAREN:
 			paren_count--;
 			if (paren_count < 0) {
 				cil_log(CIL_ERR, "Close parenthesis without matching open at line %d of %s\n", tok.line, path);
 				goto exit;
 			}
 			current = current->parent;
 			break;
 		case QSTRING:
 			tok.value[strlen(tok.value) - 1] = '\0';
 			tok.value = tok.value+1;
 			/* FALLTHRU */
 		case SYMBOL:
 			if (paren_count == 0) {
 				cil_log(CIL_ERR, "Symbol not inside parenthesis at line %d of %s\n", tok.line, path);
 				goto exit;
 			}

 			create_node(&node, current, tok.line, hll_offset, cil_strpool_add(tok.value));
 			insert_node(node, current);
 			break;
 		case NEWLINE :
 			if (!hll_expand) {
 				hll_offset++;
 			}
 			break;
 		case COMMENT:
 			while (tok.type != NEWLINE && tok.type != END_OF_FILE) {
 				cil_lexer_next(&tok);
 			}
 			if (!hll_expand) {
 				hll_offset++;
 			}
 			if (tok.type != END_OF_FILE) {
 				break;
 			}
 			/* FALLTHRU */
 			// Fall through if EOF
 		case END_OF_FILE:
 			if (paren_count > 0) {
 				cil_log(CIL_ERR, "Open parenthesis without matching close at line %d of %s\n", tok.line, path);
 				goto exit;
 			}
 			if (!cil_stack_is_empty(stack)) {
 				cil_log(CIL_ERR, "High-level language line marker start without close at line %d of %s\n", tok.line, path);
 				goto exit;
 			}
 			break;
 		case UNKNOWN:
 			cil_log(CIL_ERR, "Invalid token '%s' at line %d of %s\n", tok.value, tok.line, path);
 			goto exit;
 		default:
 			cil_log(CIL_ERR, "Unknown token type '%d' at line %d of %s\n", tok.type, tok.line, path);
 			goto exit;
 		}
 	}
 	while (tok.type != END_OF_FILE);

 	cil_lexer_destroy();

 	cil_stack_destroy(&stack);

 	*parse_tree = tree;

 	return SEPOL_OK;

 exit:
 	while (!cil_stack_is_empty(stack)) {
 		pop_hll_info(stack, &hll_offset, &hll_expand);
 	}
 	cil_lexer_destroy();
 	cil_stack_destroy(&stack);

 	return SEPOL_ERR;
 }
	/*
	* Copyright 2011 Tresys Technology, LLC. 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 TRESYS TECHNOLOGY, LLC ``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 TRESYS TECHNOLOGY, LLC 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.
	*
	* The views and conclusions contained in the software and documentation are those
	* of the authors and should not be interpreted as representing official policies,
	* either expressed or implied, of Tresys Technology, LLC.
	*/

	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <stdint.h>
	#include <sepol/errcodes.h>

	#include "cil_internal.h"
	#include "cil_log.h"
	#include "cil_mem.h"
	#include "cil_tree.h"
	#include "cil_lexer.h"
	#include "cil_parser.h"
	#include "cil_strpool.h"
	#include "cil_stack.h"

	#define CIL_PARSER_MAX_EXPR_DEPTH (0x1 << 12)

	struct hll_info {
	uint32_t hll_offset;
	uint32_t hll_expand;
	};

	static void push_hll_info(struct cil_stack *stack, uint32_t hll_offset, uint32_t hll_expand)
	{
	struct hll_info new = cil_malloc(sizeof(new));

	new->hll_offset = hll_offset;
	new->hll_expand = hll_expand;

	cil_stack_push(stack, CIL_NONE, new);
	}

	static void pop_hll_info(struct cil_stack stack, uint32_t hll_offset, uint32_t *hll_expand)
	{
	struct cil_stack_item *curr = cil_stack_pop(stack);
	struct hll_info *info;

	if (!curr) {
	return;
	}
	info = curr->data;
	*hll_expand = info->hll_expand;
	*hll_offset = info->hll_offset;
	free(curr->data);
	}

	static void create_node(struct cil_tree_node *node, struct cil_tree_node current, uint32_t line, uint32_t hll_offset, void *value)
	{
	cil_tree_node_init(node);
	(*node)->parent = current;
	(*node)->flavor = CIL_NODE;
	(*node)->line = line;
	(*node)->hll_offset = hll_offset;
	(*node)->data = value;
	}

	static void insert_node(struct cil_tree_node node, struct cil_tree_node current)
	{
	if (current->cl_head == NULL) {
	current->cl_head = node;
	} else {
	current->cl_tail->next = node;
	}
	current->cl_tail = node;
	}

	static int add_hll_linemark(struct cil_tree_node *current, uint32_t hll_offset, uint32_t hll_expand, struct cil_stack stack, char *path)
	{
	char *hll_type;
	struct cil_tree_node *node;
	struct token tok;
	uint32_t prev_hll_expand, prev_hll_offset;

	cil_lexer_next(&tok);
	if (tok.type != SYMBOL) {
	cil_log(CIL_ERR, "Invalid line mark syntax\n");
	goto exit;
	}
	hll_type = cil_strpool_add(tok.value);
	if (hll_type != CIL_KEY_SRC_HLL_LME && hll_type != CIL_KEY_SRC_HLL_LMS && hll_type != CIL_KEY_SRC_HLL_LMX) {
	cil_log(CIL_ERR, "Invalid line mark syntax\n");
	goto exit;
	}
	if (hll_type == CIL_KEY_SRC_HLL_LME) {
	if (cil_stack_is_empty(stack)) {
	cil_log(CIL_ERR, "Line mark end without start\n");
	goto exit;
	}
	prev_hll_expand = *hll_expand;
	prev_hll_offset = *hll_offset;
	pop_hll_info(stack, hll_offset, hll_expand);
	if (!*hll_expand) {
	/* This is needed if not going back to an lmx section. */
	*hll_offset = prev_hll_offset;
	}
	if (prev_hll_expand && !*hll_expand) {
	/* This is needed to count the lme at the end of an lmx section
	* within an lms section (or within no hll section).
	*/
	(*hll_offset)++;
	}
	current = (current)->parent;
	} else {
	push_hll_info(stack, hll_offset, hll_expand);
	if (cil_stack_number_of_items(stack) > CIL_PARSER_MAX_EXPR_DEPTH) {
	cil_log(CIL_ERR, "Number of active line marks exceeds limit of %d\n", CIL_PARSER_MAX_EXPR_DEPTH);
	goto exit;
	}

	create_node(&node, current, tok.line, hll_offset, NULL);
	insert_node(node, *current);
	*current = node;

	create_node(&node, current, tok.line, hll_offset, CIL_KEY_SRC_INFO);
	insert_node(node, *current);

	create_node(&node, current, tok.line, hll_offset, hll_type);
	insert_node(node, *current);

	cil_lexer_next(&tok);
	if (tok.type != SYMBOL) {
	cil_log(CIL_ERR, "Invalid line mark syntax\n");
	goto exit;
	}

	create_node(&node, current, tok.line, hll_offset, cil_strpool_add(tok.value));
	insert_node(node, *current);

	cil_lexer_next(&tok);
	if (tok.type != SYMBOL && tok.type != QSTRING) {
	cil_log(CIL_ERR, "Invalid line mark syntax\n");
	goto exit;
	}

	if (tok.type == QSTRING) {
	tok.value[strlen(tok.value) - 1] = '\0';
	tok.value = tok.value+1;
	}

	create_node(&node, current, tok.line, hll_offset, cil_strpool_add(tok.value));
	insert_node(node, *current);

	*hll_expand = (hll_type == CIL_KEY_SRC_HLL_LMX) ? 1 : 0;
	}

	cil_lexer_next(&tok);
	if (tok.type != NEWLINE) {
	cil_log(CIL_ERR, "Invalid line mark syntax\n");
	goto exit;
	}

	if (!*hll_expand) {
	/* Need to increment because of the NEWLINE */
	(*hll_offset)++;
	}

	return SEPOL_OK;

	exit:
	cil_log(CIL_ERR, "Problem with high-level line mark at line %u of %s\n", tok.line, path);
	return SEPOL_ERR;
	}

	static void add_cil_path(struct cil_tree_node *current, char path)
	{
	struct cil_tree_node *node;

	create_node(&node, *current, 0, 0, NULL);
	insert_node(node, *current);
	*current = node;

	create_node(&node, *current, 0, 0, CIL_KEY_SRC_INFO);
	insert_node(node, *current);

	create_node(&node, *current, 0, 0, CIL_KEY_SRC_CIL);
	insert_node(node, *current);

	create_node(&node, *current, 0, 0, cil_strpool_add("1"));
	insert_node(node, *current);

	create_node(&node, *current, 0, 0, path);
	insert_node(node, *current);
	}

	int cil_parser(const char _path, char buffer, uint32_t size, struct cil_tree **parse_tree)
	{

	int paren_count = 0;

	struct cil_tree *tree = NULL;
	struct cil_tree_node *node = NULL;
	struct cil_tree_node *current = NULL;
	char *path = cil_strpool_add(_path);
	struct cil_stack *stack;
	uint32_t hll_offset = 1;
	uint32_t hll_expand = 0;
	struct token tok;
	int rc = SEPOL_OK;

	cil_stack_init(&stack);

	cil_lexer_setup(buffer, size);

	tree = *parse_tree;
	current = tree->root;

	add_cil_path(&current, path);

	do {
	cil_lexer_next(&tok);
	switch (tok.type) {
	case HLL_LINEMARK:
	rc = add_hll_linemark(&current, &hll_offset, &hll_expand, stack, path);
	if (rc != SEPOL_OK) {
	goto exit;
	}
	break;
	case OPAREN:
	paren_count++;
	if (paren_count > CIL_PARSER_MAX_EXPR_DEPTH) {
	cil_log(CIL_ERR, "Number of open parenthesis exceeds limit of %d at line %d of %s\n", CIL_PARSER_MAX_EXPR_DEPTH, tok.line, path);
	goto exit;
	}
	create_node(&node, current, tok.line, hll_offset, NULL);
	insert_node(node, current);
	current = node;
	break;
	case CPAREN:
	paren_count--;
	if (paren_count < 0) {
	cil_log(CIL_ERR, "Close parenthesis without matching open at line %d of %s\n", tok.line, path);
	goto exit;
	}
	current = current->parent;
	break;
	case QSTRING:
	tok.value[strlen(tok.value) - 1] = '\0';
	tok.value = tok.value+1;
	/* FALLTHRU */
	case SYMBOL:
	if (paren_count == 0) {
	cil_log(CIL_ERR, "Symbol not inside parenthesis at line %d of %s\n", tok.line, path);
	goto exit;
	}

	create_node(&node, current, tok.line, hll_offset, cil_strpool_add(tok.value));
	insert_node(node, current);
	break;
	case NEWLINE :
	if (!hll_expand) {
	hll_offset++;
	}
	break;
	case COMMENT:
	while (tok.type != NEWLINE && tok.type != END_OF_FILE) {
	cil_lexer_next(&tok);
	}
	if (!hll_expand) {
	hll_offset++;
	}
	if (tok.type != END_OF_FILE) {
	break;
	}
	/* FALLTHRU */
	// Fall through if EOF
	case END_OF_FILE:
	if (paren_count > 0) {
	cil_log(CIL_ERR, "Open parenthesis without matching close at line %d of %s\n", tok.line, path);
	goto exit;
	}
	if (!cil_stack_is_empty(stack)) {
	cil_log(CIL_ERR, "High-level language line marker start without close at line %d of %s\n", tok.line, path);
	goto exit;
	}
	break;
	case UNKNOWN:
	cil_log(CIL_ERR, "Invalid token '%s' at line %d of %s\n", tok.value, tok.line, path);
	goto exit;
	default:
	cil_log(CIL_ERR, "Unknown token type '%d' at line %d of %s\n", tok.type, tok.line, path);
	goto exit;
	}
	}
	while (tok.type != END_OF_FILE);

	cil_lexer_destroy();

	cil_stack_destroy(&stack);

	*parse_tree = tree;

	return SEPOL_OK;

	exit:
	while (!cil_stack_is_empty(stack)) {
	pop_hll_info(stack, &hll_offset, &hll_expand);
	}
	cil_lexer_destroy();
	cil_stack_destroy(&stack);

	return SEPOL_ERR;
	}