%{
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the 
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 * Copyright 1998 Sun Microsystems, Inc.  All Rights Reserved.
 * Use is subject to license terms.
 */

#pragma ident	"@(#)personal.y	1.15	05/06/12 SMI"

%}

%start configuration

%token NUMBER
%token MACROS
%token EQUAL
%token OPENBRACKET
%token CLOSEBRACKET
%token IDENTIFIER
%token MIB2
%token SUN
%token ENTERPRISE
%token DOT
%token AGENTS
%token NAME
%token SUBTREES
%token TABLES
%token TABLE
%token COLUMNS
%token INDEXS
%token TIMEOUT
%token PORT
%token QUOTEDSTRING
%token COMA
%token MINUS
%token OPENSQUAREBRACKET
%token CLOSESQUAREBRACKET
%token WATCHDOGTIME

/* support SNMP security(5-13-96) */
%token COMMUNITIES
%token READONLY
%token READWRITE
%token MANAGERS
%token TRAPCOMMUNITY
%token TRAPDESTINATORS
%token ACL
%token ACCESS
%token TRAPNUM
%token HOSTS
%token TRAP

%{
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <dirent.h>
#include <string.h>

#include "impl.h"
#include "error.h"
#include "trace.h"
#include "pdu.h"

#include "pagent.h"
#include "subtree.h"

/** SNMP security (5-13-96) */
#include "trap.h"
#include "agent_msg.h"
#include "access.h"
#include "snmpd.h"


/***** DEFINE *****/

/*
#define DEBUG_YACC(string) printf("\t\tYACC: %s: %s at line %d\n", string, yytext, yylineno);
*/
#define DEBUG_YACC(string)

#define SNMPRELAY_SUFFIX	".snmprelay"


/***** TYPEDEF *****/

typedef struct _Macro {
	struct _Macro *next_macro;
	char *label;
	Oid name;
} Macro;

#include "table.h"
static int table_index=0;


/*
typedef struct _Table {
	struct _Table *next_table;
	Agent *agent;
	Oid name;
	Subid regTblStartColumn;
	Subid regTblEndColumn;
	Subid regTblStartRow;
	Subid regTblEndRow;
} Table;
*/



/***** STATIC VARIABLES AND FUNCTIONS *****/

/* access control(6-20-96) */
static AccessServer *static_access_server=NULL;
static AccessPolicy *static_access_policy=NULL;
static Community *static_community=NULL;

/* trap filter (6-25-96) */
static SubMember *static_sub_member=NULL;
static Manager *static_host=NULL;
static EFilter *static_filter=NULL;
static int static_trap_low=-1;
static int static_trap_high=-1;

/* snmp security(5-13-96) */
static int community_type = 0;
static char *current_filename = NULL;

/* lexinput points to the current focus point in the config file */
static char *lexinput;

/* first_macro is the begining of the list	*/
/* of the user defined macros			*/

static Macro *first_macro = NULL;


/* first_table is the begining of the list	*/
/* of tables supported by the agents		*/

static Table *first_table = NULL;
static Table *last_table = NULL;


/* the boolean parsing_oid is used to		*/
/* know if we are parsing an			*/
/* object identifier or not.			*/

static int parsing_oid = False;


/* here are the values of the predifined macros	*/
/* that can be used in the configuration file	*/

static Subid subids_mib2[] = { 1, 3, 6, 1, 2, 1 };
static int mib2_len = 6;
static Subid subids_enterprise[] = { 1, 3, 6, 1, 4, 1 };
static int enterprise_len = 6;
static Subid subids_sun[] = { 1, 3, 6, 1, 4, 1, 42 };
static int sun_len = 7;


/* the 2 static variables static_subids and	*/
/* static_len are used when parsing an	*/
/* object identifier. Then the boolean		*/
/* parsing_oid should be true. When a new sub-	*/
/* identifier (or a list of sub-identifiers)	*/
/* is found, we use the function		*/
/* subids_cat to append it to the static_subids.*/

static Subid *static_subids = NULL;
static int static_len = 0;
static int subids_cat(Subid *subids, int len);


/* macro_add() is used to append a macro to	*/
/* the macro list. macro_find is used to find	*/
/* a macro in the macro list			*/

static Macro *macro_add(char *label, Subid *subids, int len);
static Macro *macro_find(char *label);
static void macro_free(Macro *mp);
static void macro_list_delete();


static void table_free(Table *tp);
static void table_list_delete();

extern int SSARegSubagent(Agent *);
extern int SSASubagentOpen(int, char *);
extern int SSARegSubtable(SSA_Table *);

/* static_label is used when parsing a macro	*/
static char *static_label = NULL;

/* static_agent is used when parsing an agent	*/
static Agent *static_agent = NULL;

/* static_table is used when parsing n table	*/
static Table *static_table = NULL;

/* static_inf_value and static_max_value are	*/
/* used when parsing a range			*/
static int static_inf_value = -1;
static int static_sup_value = -1;

static int count;
%}

%%


configuration :	agents | macros agents | snmp_security
		{
			DEBUG_YACC("configuration")
		}

/******************* SNMP security (5-13-96) *********/
snmp_security : acls  trap_block  /*trapcommunity trapdestinators*/
                {
                        DEBUG_YACC("security configuration")
                }

/***************/
/* accesscontrol */
/***************/

acls :	/*empty */ | t_acls t_equal t_openbracket acls_list t_closebracket
		{
			DEBUG_YACC("acls_list")
		}
		| t_acls t_equal t_openbracket error t_closebracket
		{
		  error("BUG: acl stmt parsing error at line %d",yylineno);
		  if(static_access_policy != NULL){
			access_policy_list_free(static_access_policy);
			static_access_policy = NULL;
		  }
		}

acls_list : /*empty*/ | acls_list acl_item 
	{
		DEBUG_YACC("acls_list")
	}

acl_item : t_openbracket 
	{
		static_access_policy = calloc(1,sizeof(AccessPolicy));
		if(static_access_policy == NULL)
		{
			error("calloc() failed");
			YYERROR;
		}
	} communities_stmt acl_access
	{
		if(static_access_policy!=NULL)
			static_access_policy->access_type = community_type;	
	} hosts t_closebracket
	{
		/* create AccessServer */
		/* put the AccessPolicy into AccessServer */
		/* put AccessServer into corresponding manager */
		static_access_server = NULL;
		static_access_policy = NULL;
		static_community = NULL;
		community_type = 0;
	}

communities_stmt :      t_communities t_equal communities_set
        {
                DEBUG_YACC("communities_stmt");
        }

communities_set : communities_set t_coma community_elem | community_elem
	{
		DEBUG_YACC("communities_set");
	}

community_elem : ct_identifier
	{
		if(static_access_policy==NULL){
			error("acl statement error");
			YYERROR;
		}
		/* add community into AccessPolicy */
		static_community = calloc(1, sizeof(Community));
		if(static_community == NULL)
		{
			error("calloc() failed");
			YYERROR;
		}	
		static_community->name = strdup(yytext);
		community_attach(static_access_policy,static_community);
		static_community = NULL;
	}

acl_access:	t_access t_equal acl_access_type
	{
		DEBUG_YACC("acl_access")
	}

acl_access_type : t_readonly | t_readwrite
		{
			DEBUG_YACC("acl_access_type")
		}

hosts : t_managers t_equal hosts_list
        { 
                DEBUG_YACC("hosts") 
        } 

hosts_list : hosts_list t_coma host_item | host_item
	{
		DEBUG_YACC("hosts_list");
	}

host_item :  ct_identifier
	{
		/* add the host item to manager list */
		/* it should return the pointer if exists */
                Manager *res;
 
                DEBUG_YACC("manager_item")
 
                res = manager_add(yytext, error_label);
                if(res==NULL){
                                error("error in %s at line %d: %s",
                                        current_filename? current_filename:
"???",
                                        yylineno, error_label);
                } 
		static_access_server = calloc(1,sizeof(AccessServer));
		if(static_access_server == NULL)
		{
			error("malloc() failed");
			if(static_access_policy) 
			  access_policy_list_free(static_access_policy);
			YYERROR;
		}
		if(static_access_policy!=NULL)
			static_access_policy->count++;
		static_access_server->first_acc_policy = static_access_policy;
		access_server_add_tail(res,static_access_server);
		static_access_server = NULL;
	}


/************/
/* managers */
/************/
 
/*
managers :      t_managers t_equal t_openbracket managers_list t_closebracket
                {
                        DEBUG_YACC("agents")
                }
 
 
managers_list :  | managers_list list_separator manager_item
                {
                        DEBUG_YACC("managers_list")
                }
 
 
manager_item :  ct_identifier
                {
                        Manager *res;
 
                        DEBUG_YACC("manager_item")
 
                        res = manager_add(yytext, error_label);
			if(res==NULL){
                                        error("error in %s at line %d: %s",
                                                current_filename? current_filename:
"???",
                                                yylineno, error_label);
			}
                }
*/

/*** trap hanlding (6-25-96) */
trap_block :	t_trap t_equal t_openbracket trap_list t_closebracket
		{
			DEBUG_YACC("trap_block")
		}
		| t_trap t_equal t_openbracket error t_closebracket
		{
			/* clean up */
			if(static_sub_member != NULL){
			  sub_member_free(static_sub_member);
			  static_sub_member=NULL;
			}	
		}

trap_list : /*empty*/ | trap_list trap_item
	{
		DEBUG_YACC("trap_list")
	}

trap_item : t_openbracket
	{
		/* create submember */
		static_sub_member = calloc(1,sizeof(SubMember));
		if(static_sub_member == NULL)
		{
			error("malloc() failed");
			YYERROR;
		}
	} trap_community_string trap_interest_hosts
	{
		/* attach submember to subgroup */
	} enterprise_list t_closebracket
	{
		static_sub_member = NULL;
	}

trap_community_string : t_trapcommunity t_equal ct_identifier
	{
		/* set the community field in submember */
		if(static_sub_member != NULL)
		{
			static_sub_member->community_string = strdup(yytext);
			if(static_sub_member == NULL)
			{	
				error(ERR_MSG_ALLOC);
				YYERROR;
			}
		}else{
			error("BUG: missing trap community name");
		}
	}

trap_interest_hosts : t_hosts t_equal trap_interest_hosts_list
	{
		DEBUG_YACC("trap_interest_hosts")
	}

trap_interest_hosts_list : trap_interest_hosts_list t_coma 
		 trap_interest_host_item | trap_interest_host_item
	{
		DEBUG_YACC("trap_interest_hosts_list")
	}

trap_interest_host_item : ct_identifier
	{
		DEBUG_YACC("trap_interest_host_item")
		/* attach host to the submember */
		if(static_sub_member==NULL){
		 	error("trap statement error");
			YYERROR;
		}else{
		  static_host = calloc(1,sizeof(Manager));
		  if(static_host == NULL)
		  {
			error("malloc() failed");
			YYERROR;
		  }
		  static_host->name = strdup(yytext);
		  if(name_to_ip_address(static_host->name, 
			&static_host->ip_address,error_label)){
			error("unknown host %s",static_host->name);
			free(static_host);
			static_host=NULL;
			YYERROR;
		  }
		  static_host->next_manager = static_sub_member->first_manager;
		  static_sub_member->first_manager=static_host;
		  static_host=NULL;
		}
	}

enterprise_list : /* empty */ | enterprise_list enterprise_item
	{
		DEBUG_YACC("enterprise_list")
	}

enterprise_item : t_openbracket enterprise_stmt trap_number_stmt 
		  t_closebracket
		{
			DEBUG_YACC("enterprise_item")
		}

enterprise_stmt : ENTERPRISE t_equal t_quotedstring
		{
			/* currently, it supports single enterprise */

			DEBUG_YACC("enterprise_stmt")
			/* add or find the enterprise */
			static_filter = efilter_add(quoted_string,error_label);
			if(static_filter==NULL){
			  error("error in %s at line %d: %s",
				current_filename?current_filename:"???",
				yylineno,error_label);
			}
		}

trap_number_stmt : t_trap_num t_equal trap_number_list
		{
			DEBUG_YACC("trap_number_stmt")
		}

trap_number_list : trap_number_item
		{
			DEBUG_YACC("trap_number_list")
		}
		| trap_number_list t_coma trap_number_item
		{
			DEBUG_YACC("trap_number_list")
		}

trap_number_item : trap_range
	{
			DEBUG_YACC("trap_number_item")
			/* for each trap, find/add to the
			   enterprise, and add_tailthe subgroup 
			   to each trap */

			if(static_filter!=NULL){
				/* expand the trap */
				mem_filter_join(static_trap_low,
					static_trap_high,static_sub_member,
					static_filter);
			}else{
				error("error in enterprise statement");
				YYERROR;
			}
	}

trap_range :	 NUMBER
		{
			/* starting trap num */
		 	static_trap_low = token_value;
		}
		t_minus NUMBER
		{
			/* ending trap num */
			static_trap_high = token_value;
		}
		| NUMBER
		{
			/* start & end num the same */
			DEBUG_YACC("trap_range")
			static_trap_low=static_trap_high=token_value;
		}

 
/*
trapcommunity : t_trapcommunity t_equal ct_identifier
                {
                        DEBUG_YACC("trap_community")

                        if(trap_community)
                        {
                                error("BUG: trap_community not NULL in trap_community");
                        }

                        trap_community = strdup(yytext);
                        if(trap_community == NULL)
                        {
                                error(ERR_MSG_ALLOC);
                                YYERROR;
                        }
                }
*/

/*******************/
/* trapdestinators */
/*******************/
/*

trapdestinators : t_trapdestinators t_equal t_openbracket trapdestinators_list t_closebracket
                {
                        DEBUG_YACC("trapdestinators")
                }


trapdestinators_list :  | trapdestinators_list list_separator trapdestinator_item
                {
                        DEBUG_YACC("trapdestinators_list")
                }


trapdestinator_item : ct_identifier
                {
                        int res; 

                        DEBUG_YACC("trapdestinator_item")
 
                        res = trap_destinator_add(yytext, error_label);
                        switch(res)
                        {
                                case 0:
                                        break;
 
                                case 1:
                                        error("error in %s at line %d: %s",
                                                current_filename? current_filename:
"???",
                                                yylineno, error_label);
                                        break;
 
                                default:
                                        error("fatal error in %s at line %d: %s",
                                                current_filename? current_filename:
"???",
                                                yylineno, error_label);
                                        YYERROR;
                        }
                }

*/

/******************* SNMP security (5-13-96) *********/




/**********/
/* macros */
/**********/

macros :	t_macros t_equal t_openbracket macros_list t_closebracket
		{
			DEBUG_YACC("macros")
		}


macros_list :	/* empty */ | macros_list macro_item
		{
			DEBUG_YACC("macros_list")
		}


macro_item :	label t_equal
		{
			if(parsing_oid != False)
			{
				error("BUG at line %d: parsing_oid not False in macro_item", yylineno);
			}
			parsing_oid = True;

			if(static_subids != NULL)
			{
				error("BUG at line %d: static_subids not NULL in macro_item", yylineno);
			}
			if(static_len != 0)
			{
				error("BUG at line %d: static_len not 0 in macro_item", yylineno);
			}
		}
		subids_list
		{
			DEBUG_YACC("macro_item")
	
			if(macro_add(static_label, static_subids, static_len) == NULL)
			{
				error("error at line %d", yylineno);
				YYERROR;
			}

			parsing_oid = False;
			free(static_label);
			static_label = NULL;
			free(static_subids);
			static_subids = NULL;
			static_len = 0;
		}


label :		t_identifier
		{
			DEBUG_YACC("label")

			if(static_label != NULL)
			{
				error("BUG at line %d: static_label not NULL in label", yylineno);
			}
			static_label = strdup(yytext);
			if(static_label == NULL)
			{
				error("malloc() failed");
				YYERROR;
			}
		}



/**********/
/* agents */
/**********/

agents :	t_agents t_equal t_openbracket agents_list t_closebracket
		{
			DEBUG_YACC("agents")
		}


agents_list :	agent_item | agents_list agent_item
		{
			DEBUG_YACC("agents_list")
		}


agent_item :		t_openbracket
		{
			if(static_agent != NULL)
			{
				error("BUG at line %d: static_agent not NULL in agent", yylineno);
			}
			static_agent = malloc(sizeof(Agent));
			if(static_agent == NULL)
			{
				error("malloc() failed");
				YYERROR;
			}
			(void)memset(static_agent, 0, sizeof(Agent));
			/* LINTED */
			static_agent->agent_id = (int32_t)getpid();
			static_agent->agent_status = SSA_OPER_STATUS_NOT_IN_SERVICE;
			static_agent->personal_file = strdup (current_filename);
		}
		name subtrees_tables timeout optional_watch_dog_time optional_port t_closebracket
		{
			DEBUG_YACC("agent_item");

			/* add the agent id to agent, currently, agent_id is pid */
			if(first_agent == NULL)
			{
				static_agent->next_agent = NULL;
			}
			else
			{
				static_agent->next_agent = first_agent;
			}
			first_agent = static_agent;

			/* if port is 0, assigned a non-reserved available port */
			if(static_agent->address.sin_port == 0 && agent_port_number != -1)
			  static_agent->address.sin_port = agent_port_number;
			else if(static_agent->address.sin_port==0)
			  static_agent->address.sin_port =
				get_a_non_reserved_port();
			if (agent_port_number == -1)
			  agent_port_number = static_agent->address.sin_port;

			/* the registration is for confirmation and
	 		   fill in extra value */
			static_agent->agent_status = SSA_OPER_STATUS_ACTIVE;
			if(SSARegSubagent(static_agent) == 0)
			{
				error("subagent registration failed");
				YYERROR;
			}
			static_agent = NULL;
		}


name :		t_name t_equal t_quotedstring
		{
			DEBUG_YACC("name")

			if(static_agent->name != NULL)
			{
				error("BUG at line %d: static_agent->name not NULL in name", yylineno);
			}
			static_agent->name = strdup(quoted_string);
			if(static_agent->name == NULL)
			{
				error("malloc() failed");
				YYERROR;
			}
/*
 * Increased the num. of retries for SSASubagentOpen in order to insure success
 * typically for boot time race condition between the master and subagent
 * Initial sleep is introduced to increase the probability of success the very
 * first time. This could be removed at a later time, after modifying the timeout
 * parameters for the subagent
 */ 
                        (void)sleep(15);
                        count=1;
                        while(count) {
			if( (static_agent->agent_id =
			     SSASubagentOpen(max_agent_reg_retry,static_agent->name)) == INVALID_HANDLER )
			{
                              if (count == 5) {
				error_exit("subagent registration failed");
				YYERROR;
                              }
			}
                        if (static_agent->agent_id ) break;
                         count++;
                        }
			if(SSARegSubagent(static_agent) == 0)
			{
				error("subagent registration failed");
				YYERROR;
			}
			/* LINTED */
			static_agent->process_id = (int32_t)getpid();
		}


subtrees_tables :  subtrees tables | subtrees | tables
		{
			DEBUG_YACC("subtrees_tables")
		}


subtrees :	t_subtrees t_equal t_openbracket
		{
			if(parsing_oid != False)
			{
				error("BUG at line %d: parsing_oid is not False in subtrees", yylineno);
			}
			parsing_oid = True;

			if(static_subids != NULL)
			{
				error("BUG at line %d: static_subids not NULL in subtrees", yylineno);
			}
			if(static_len != 0)
			{
				error("BUG at line %d: static_len not 0 in subtrees", yylineno);
			}
		}
		subtrees_list t_closebracket
		{
			DEBUG_YACC("subtrees")

			if(parsing_oid != True)
			{
				error("BUG at line %d: parsing_oid is not True in subtrees", yylineno);
			}
			parsing_oid = False;
		}


subtrees_list : /* empty */ | subtrees_list_coma_separated
		{
			DEBUG_YACC("subtrees_list")
		}


subtrees_list_coma_separated : subtree_item | subtrees_list_coma_separated t_coma subtree_item
		{
			DEBUG_YACC("subtrees_list_coma_separated")
		}


subtree_item : subids_list
		{
			DEBUG_YACC("subtree_item")

			if(parsing_oid != True)
			{
				error("BUG at line %d: parsing_oid is not True in subtree_item", yylineno);
			}

			if(subtree_add(static_agent, static_subids, static_len) == -1)
			{
				error("error at line %d", yylineno);
				YYERROR;
			}

			free(static_subids);
			static_subids = NULL;
			static_len = 0;
		}


tables :	t_tables t_equal t_openbracket tables_list t_closebracket
		{
			DEBUG_YACC("tables")
		}


tables_list :	/* empty */ | tables_list table_item
		{
			DEBUG_YACC("tables_list")
		}


table_item :	t_openbracket
		{
			if(static_agent == NULL)
			{
				error("BUG at line %d: static_agent is NULL in table_item", yylineno);
			}

			if(static_table)
			{
				error("BUG at line %d: static_table not NULL in table_item", yylineno);
			}

			static_table = calloc(1,sizeof(Table));
			if(static_table == NULL)
			{
				error("malloc() failed");
				YYERROR;
			}
			static_table->regTblStatus =
			 SSA_OPER_STATUS_NOT_IN_SERVICE;
			static_table->next_table = NULL;
			static_table->agent = static_agent;
			if(static_agent!=NULL)
			  static_table->regTblAgentID =
			  static_agent->agent_id;
			static_table->regTblOID.subids = NULL;
			static_table->regTblOID.len = 0;
			static_table->regTblStartColumn = 0;
			static_table->regTblEndColumn = 0;
			static_table->regTblIndex = ++table_index;
/*
			static_table->indexs.subids = NULL;
			static_table->indexs.len = 0;
*/
		}
		table columns indexs t_closebracket
		{
			DEBUG_YACC("table_item")

			if(static_table == NULL)
			{
				error_exit("BUG at line %d: static_table is NULL in table_item", yylineno);
			}
	
		 	/* register the table, if register fails, delete 
			   the table */
			if(SSARegSubtable(static_table)==0){
				/* unregister the table */
				
				error_exit("TABLE CONFIG");
			}
	

			if(last_table)
			{
				last_table->next_table = static_table;
			}
			else
			{
				first_table = static_table;
			}
			last_table = static_table;
			static_table = NULL;
		}


table :		t_table t_equal
		{
			if(parsing_oid != False)
			{
				error("BUG at line %d: parsing_oid is not False in tables", yylineno);
			}

			parsing_oid = True;
		}
		subids_list
		{
			DEBUG_YACC("table")

			if(parsing_oid != True)
			{
				error("BUG at line %d: parsing_oid is not True in tables", yylineno);
			}
			parsing_oid = False;

			if(static_table == NULL)
			{
				error_exit("BUG at line %d: static_table is NULL in table", yylineno);
			}

			static_table->regTblOID.subids = static_subids;
			static_subids = NULL;
			static_table->regTblOID.len = static_len;
			static_len = 0;
		}


columns :	t_columns t_equal range
		{
			DEBUG_YACC("columns")

			if(static_table == NULL)
			{
				error_exit("BUG at line %d: static_table is NULL in columns", yylineno);
			}

			static_table->regTblStartColumn = static_inf_value;
			static_inf_value = -1;
			static_table->regTblEndColumn = static_sup_value;
			static_sup_value = -1;
		}


/*
indexs :	t_indexs t_equal
		{
			if(parsing_oid != False)
			{
				error("BUG at line %d: parsing_oid is not False in indexs", yylineno);
			}

			parsing_oid = True;
		}
		subids_list
		{
			DEBUG_YACC("indexs")

			if(parsing_oid != True)
			{
				error("BUG at line %d: parsing_oid is not True in indexs", yylineno);
			}
			parsing_oid = False;

			if(static_table == NULL)
			{
				error_exit("BUG at line %d: static_table is NULL in indexs", yylineno);
			}

			static_table->indexs.subids = static_subids;
			static_subids = NULL;
			static_table->indexs.len = static_len;
			static_len = 0;
		}
*/

indexs :	t_indexs t_equal range
		{
			DEBUG_YACC("indexs")

			if(static_inf_value == -1)
			{
				error("BUG at line %d: static_inf_value is -1", yylineno);
			}
			if(static_sup_value == -1)
			{
				error("BUG at line %d: static_sup_value is -1", yylineno);
			}
			static_table->regTblStartRow = static_inf_value;
			static_table->regTblEndRow = static_sup_value;
			static_inf_value = -1;
			static_sup_value = -1;
		}


range :		t_opensquarebracket t_number
		{
			if(static_inf_value != -1)
			{
				error("BUG at line %d: static_inf_value (%d) is not -1 in range",
					yylineno,
					static_inf_value);
			}

			static_inf_value = token_value;
		}
		t_minus t_number
		{
			if(static_sup_value != -1)
			{
				error("BUG at line %d: static_sup_value (%d) is not -1 in range",
					yylineno,
					static_inf_value);
			}

			static_sup_value = token_value;
		}
		t_closesquarebracket
		{
			DEBUG_YACC("range")
		}
		| t_number
		{
			if(static_inf_value != -1)
			{
				error("BUG at line %d: static_inf_value (%d) is not -1 in range",
					yylineno,
					static_inf_value);
			}
			if(static_sup_value != -1)
			{
				error("BUG at line %d: static_sup_value (%d) is not -1 in range",
					yylineno,
					static_sup_value);
			}

			static_inf_value = token_value;
			static_sup_value = token_value;
		}


timeout :	t_timeout t_equal t_number
		{
			DEBUG_YACC("subtree")

			static_agent->timeout = token_value;
		}

optional_watch_dog_time : /*empty*/ |   t_watch_dog_time t_equal NUMBER
                {
                        DEBUG_YACC("optional_watch_dog_time")
                        static_agent->watch_dog_time = token_value;
                }

optional_port:	/*empty*/ | port
	{
                        DEBUG_YACC("optional_port")
	}

port :		t_port t_equal t_number
		{
			DEBUG_YACC("port")

			if(token_value > 0xFFFF)
			{
				error("error at line %d: the port number (%d) should not be greater than %d", yylineno, token_value, 0xFFFF);
				YYERROR;
			}

			/* LINTED */
			static_agent->address.sin_port = (short) token_value;

			if(agent_find(&(static_agent->address)))
			{
				error("error at line %d: the port number %d is already used by another agent", yylineno, token_value);
				YYERROR;
			}
		}



/***************/
/* subids_list */
/***************/

subids_list :	subid | subids_list t_dot subid
		{
			DEBUG_YACC("subids_list")
		}


subid :		t_mib2 | t_sun | t_enterprise | t_identifier | t_number
		{
			DEBUG_YACC("subid")
		}



/*******************/
/* terminal tokens */
/*******************/

/**************** SNMP security (5-13-96) ***/
ct_identifier : IDENTIFIER
		{
			DEBUG_YACC("ct_indentifier")
		}

t_communities : COMMUNITIES
                {
                        DEBUG_YACC("t_communities")
                }

t_hosts : HOSTS
	{
		DEBUG_YACC("t_hosts")
	}

t_acls  : ACL
        {
                DEBUG_YACC("t_acls")
        }

t_access : ACCESS
	{
		DEBUG_YACC("t_access")
	}

t_readonly :    READONLY
                {
                        DEBUG_YACC("t_readonly")

                        community_type = READ_ONLY;
                }

t_readwrite :   READWRITE
                {
                        DEBUG_YACC("t_readwrite")

                        community_type = READ_WRITE;
                }

t_managers :    MANAGERS
                {
                        DEBUG_YACC("t_managers")
                }


t_trap :	TRAP
		{
			DEBUG_YACC("t_trap")
		}

t_trap_num:	TRAPNUM
		{
			DEBUG_YACC("t_trap_num")
		}

t_trapcommunity : TRAPCOMMUNITY
                {
                        DEBUG_YACC("t_trapcommunity")
                }


/*
t_trapdestinators : TRAPDESTINATORS
                {
                        DEBUG_YACC("t_trapdestinators")
                }

list_separator : | t_coma
                {
                        DEBUG_YACC("list_separator")
                }
*/


/**************** SNMP security (5-13-96) ***/


t_number :	NUMBER
		{
			DEBUG_YACC("t_number")

			if(parsing_oid == True)
			{
				if(subids_cat((Subid *) &token_value, 1) == -1)
				{
					YYERROR;
				}
			}
		}


t_macros :	MACROS
		{
			DEBUG_YACC("t_macros")
		}


t_equal :	EQUAL
		{
			DEBUG_YACC("t_equal")
		}


t_minus :	MINUS
		{
			DEBUG_YACC("t_minus")
		}


t_openbracket :	OPENBRACKET
		{
			DEBUG_YACC("t_openbracket")
		}


t_closebracket : CLOSEBRACKET
		{
			DEBUG_YACC("t_closebracket")
		}


t_opensquarebracket : OPENSQUAREBRACKET
		{
			DEBUG_YACC("t_opensquarebracket")
		}


t_closesquarebracket : CLOSESQUAREBRACKET
		{
			DEBUG_YACC("t_closesquarebracket")
		}


t_identifier :	IDENTIFIER
		{
			DEBUG_YACC("t_identifier")

			if(parsing_oid == True)
			{
				Macro *mp;


				mp = macro_find(yytext);
				if(mp == NULL)
				{
					error("error at line %d: %s is not a macro", yylineno, yytext);
					YYERROR;
				}

				if(subids_cat(mp->name.subids, mp->name.len) == -1)
				{
					YYERROR;	
				}
			}
		}


t_mib2 :	MIB2
		{
			DEBUG_YACC("t_mib2")

			if(parsing_oid == False)
			{
				error("BUG at line %d: parsing_oid not True in t_mib2", yylineno);
			}
			if(subids_cat(subids_mib2, mib2_len) == -1)
			{
				YYERROR;
			}
		}


t_sun :		SUN
		{
			DEBUG_YACC("t_sun")

			if(parsing_oid == False)
			{
				error("BUG at line %d: parsing_oid not True in t_sun", yylineno);
			}
			if(subids_cat(subids_sun, sun_len) == -1)
			{
				YYERROR;
			}
		}


t_enterprise :	ENTERPRISE
		{
			DEBUG_YACC("t_enterprise")

			if(parsing_oid == False)
			{
				error("BUG at line %d: parsing_oid not True in t_enterprise", yylineno);
			}
			if(subids_cat(subids_enterprise, enterprise_len) == -1)
			{
				YYERROR;
			}
		}

t_dot :		DOT
		{
			DEBUG_YACC("t_dot")
		}


t_agents :	AGENTS
		{
			DEBUG_YACC("t_agents")
		}


t_name :	NAME
		{
			DEBUG_YACC("t_name")
		}


t_subtrees :	SUBTREES
		{
			DEBUG_YACC("t_subtrees")
		}


t_tables :	TABLES
		{
			DEBUG_YACC("t_tables")
		}


t_table :	TABLE
		{
			DEBUG_YACC("t_table")
		}


t_columns :	COLUMNS
		{
			DEBUG_YACC("t_columns")
		}


t_indexs :	INDEXS
		{
			DEBUG_YACC("t_indexs")
		}


t_timeout :	TIMEOUT
		{
			DEBUG_YACC("t_timeout")
		}

t_watch_dog_time :      WATCHDOGTIME
                {
                        DEBUG_YACC("t_watch_dog_time")
                }

t_port :	PORT
		{
			DEBUG_YACC("t_port")
		}


t_quotedstring : QUOTEDSTRING
		{
			DEBUG_YACC("t_quotedstring\n")
		}


t_coma :	COMA
		{
			DEBUG_YACC("t_coma")
		}
%%

#include "personal.lex.c"

/****************************************************************/

static int subids_cat(Subid *subids, int len)
{
	Subid *new_subids;
	int new_len;


	new_len = static_len + len;
			/* LINTED */
	new_subids = (Subid *) malloc(new_len * (int32_t)sizeof(Subid));
	if(new_subids == NULL)
	{
		error("malloc() failed");
		if(static_subids)
		{
			free(static_subids);
		}
		static_subids = NULL;
		static_len = 0;
		return -1;
	}
			/* LINTED */
	(void)memcpy(new_subids, static_subids, static_len * (int32_t)sizeof(Subid));
			/* LINTED */
	(void)memcpy(&(new_subids[static_len]), subids, len * (int32_t)sizeof(Subid));


	if(static_subids)
	{
		free(static_subids);
	}
	static_subids = new_subids;
	static_len = new_len;

	return 0;
}


/****************************************************************/

static Macro *macro_add(char *label, Subid *subids, int len)
{
	Macro *new;


	if(macro_find(label) != NULL)
	{
		error("%s is already a macro", label);
		return NULL;
	}

	new = (Macro *) malloc(sizeof(Macro));
	if(new == NULL)
	{
		error("malloc() failed");
		return NULL;
	}
	new->label = NULL;
	new->name.subids = NULL;

	new->label = strdup(label);
	if(new->label == NULL)
	{
		error("malloc() failed");
		macro_free(new);
		return NULL;
	}
			/* LINTED */
	new->name.subids = (Subid *) malloc(len * (int32_t)sizeof(Subid));
	if(new->name.subids == NULL)
	{
		error("malloc() failed");
		macro_free(new);
		return NULL;
	}
			/* LINTED */
	(void)memcpy(new->name.subids, subids, len * (int32_t)sizeof(Subid));
	new->name.len = len;
	new->next_macro = first_macro;
	first_macro = new;

	return new;
}


/****************************************************************/

static Macro *macro_find(char *label)
{
	Macro *mp;


	for(mp = first_macro; mp; mp = mp->next_macro)
	{
		if(strcmp(mp->label, label) == 0)
		{
			return mp;
		}
	}

	return NULL;
}


/****************************************************************/

static void macro_free(Macro *mp)
{
	if(mp == NULL)
	{
		return;
	}

	if(mp->label)
	{
		free(mp->label);
	}

	if(mp->name.subids)
	{
		free(mp->name.subids);
	}

	free(mp);

	return;
}


/****************************************************************/

static void macro_list_delete()
{
	Macro *mp = first_macro;
	Macro *next;


	while(mp)
	{
		next = mp->next_macro;

		macro_free(mp);

		mp = next;
	}

	first_macro = NULL;

	return;
}



/****************************************************************/

int yyerror(char *s)
{
	error("%s at line %d: %s", s, yylineno, yytext);

	return (0);
}


/****************************************************************/

/* If we have a serious problem, this function will	*/
/* terminate (<==> exit) the program			*/

void config_init(char *filename)
{
		struct stat statb;
		char *fileaddr;
		int fd;


		yylineno = 1;

		if((fd = open(filename, O_RDONLY)) < 0)
		{
			error_exit(ERR_MSG_OPEN,
				filename, errno_string());
		}

		/* 
		 * get the size of the file
		 */
		if(fstat(fd, &statb) < 0)
		{
			error_exit(ERR_MSG_FSTAT,
				filename, errno_string());
		}
		if(!S_ISREG(statb.st_mode))
		{
			error_exit("filename: %s is not a file\n",filename);
		}

		/* 
		 * and map it into my address space
		 */
		if(statb.st_size != 0)
		{
			/* Purify IPR/IPW error - bug 4124843. yylook wants to
			   read the last + 1 byte to decide EOF */
			/* LINTED */
			if((fileaddr = (char *) mmap(0, (int32_t)statb.st_size+1, PROT_READ|PROT_WRITE,
				MAP_PRIVATE, fd, 0)) <= (char *) 0)
			{
				error_exit(ERR_MSG_MMAP,
					filename, errno_string());
			}

			/*
			 * set current lex focus on the file
			 */

			lexinput = fileaddr;

			/*
			 * and parse the file
			 */
			current_filename = filename;
			if(yyparse() == 1)
			{
				error_exit("parsing %s failed", filename);
			}
			current_filename = NULL;

			/*
			 * Parsing is finished
			 *
			 * unmap the file and close it
			 */

			/* Purify IPR/IPW error - bug 4124843 */
			/* LINTED */
			if(munmap(fileaddr, (int32_t)statb.st_size+1) == -1)
			{
				error(ERR_MSG_MUNMAP, errno_string());
			}
		}
		else
		{
			/* empty file, ignore it */

			error_exit("empty configuration file %s", filename);
		}

		if(close(fd) == -1)
		{
			error(ERR_MSG_CLOSE, errno_string());
		}

		macro_list_delete();


	table_list_delete();


	if(first_agent == NULL)
	{
		error_exit("No SNMP agent configured");
	}

	if(trace_level > 0)
	{
		trace_subtrees();
		trace_agents();
	}
}


/****************************************************************/

static void table_list_delete()
{
	Table *next;

	while(first_table)
	{
		next = first_table->next_table;
		table_free(first_table);
		first_table = next;
	}

	first_table = NULL;
	last_table = NULL;
}


/****************************************************************/

static void table_free(Table *tp)
{
	if(tp == NULL)
	{
		return;
	}

	if(tp->regTblOID.subids)
	{
		free(tp->regTblOID.subids);
	}

/*
	if(tp->indexs.subids)
	{
		free(tp->indexs.subids);
	}
*/

	free(tp);
}


/****************************************************************/


/*********** SNMP security (5-13-96) ******/
/* If we have a serious problem, this function will	*/
/* terminate (<==> exit) the program			*/

void sec_config_init(char *filename)
{
	struct stat statb;
	char *fileaddr;
	int fd;


	delete_manager_list();
	delete_community_list();
	if(trap_community)
	{
		free(trap_community);
		trap_community = NULL;
	}
	delete_trap_destinator_list();


	yylineno = 1;

	if((fd = open(filename, O_RDONLY)) < 0)
	{
		error_exit(ERR_MSG_OPEN,
			filename, errno_string());
	}

	/* 
	 * get the size of the file
	 */
	if(fstat(fd, &statb) < 0 )
	{
		error_exit(ERR_MSG_FSTAT,
			filename, errno_string());
	}
	if(!S_ISREG(statb.st_mode))
	{
		error_exit("filename: %s is not a file\n",filename);
	}

	/* 
	 * and map it into my address space
	 */
	if(statb.st_size)
	{
		/* Purify IPR/IPW error - bug 4124843. yylook wants to
		   read the last + 1 byte to decide EOF */
			/* LINTED */
		if((fileaddr = (char *) mmap(0, (int32_t)statb.st_size+1, PROT_READ|PROT_WRITE,
			MAP_PRIVATE, fd, 0)) <= (char *) 0)
		{
			error_exit(ERR_MSG_MMAP,
				filename, errno_string());
		}

		/*
		 * set current lex focus on the file
		 */

		lexinput = fileaddr;

		/*
		 * and parse the file
		 */

		current_filename = filename;
		if(yyparse() == 1)
		{
			error_exit("parsing %s failed", filename);
		}
		current_filename = NULL;

		/*
		 * Parsing is finished
		 *
		 * unmap the file and close it
		 */

		/* Purify IPR/IPW error - bug 4124843 */
			/* LINTED */
		if(munmap(fileaddr, (int32_t)statb.st_size+1) == -1)
		{
			error(ERR_MSG_MUNMAP,
				errno_string());
		}
	}
	else
	{
		/* empty file, ignore it */

		error_exit("empty configuration file %s", filename);
	}

	if(close(fd) == -1)
	{
		error(ERR_MSG_CLOSE, errno_string());
	}

	if(trace_level > 0)
	{
		trace("\n");
		trace_managers();
		trace_filter();
		trace_trap_destinators();
	}
}
/*********** SNMP security (5-13-96) ******/

int yywrap()
{
  return 1;
}

static int get_a_non_reserved_port()
{
  struct sockaddr_in me;
  socklen_t len;
  int cnt=0;
  int sd;

  sd = socket(AF_INET,SOCK_DGRAM,0);
  if(sd<0) return 0;
  me.sin_family = AF_INET;
  me.sin_addr.s_addr = INADDR_ANY;

  for(;cnt<5;cnt++){
    me.sin_port = htons(0);
    if(bind(sd,(struct sockaddr*)&me,sizeof(me))!=0)continue;
    len = (socklen_t) sizeof(me);
    if(getsockname(sd,(struct sockaddr*)&me, &len)==-1) continue;
    (void)close(sd);
    return me.sin_port;
  }
  (void)close(sd);
  return 0;
}