/*
 * 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 1992 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/label.h> 
#include <sys/audit.h> 
#include <auevents.h> 

#define ON 1
#define OK 0 
#define OFF -1
#define COMMA  ','
#define COMMASTR ","

#define COMMON 0
#define SUCCESS 1
#define FAILURE 2

#define MAXFLDLEN 25 
#define MAXSTRLEN 360
#define MAXEVENT 11 

/* GLOBALS */

static int length;
static int pos = 0;

struct list {
	short count;
	short on[MAXEVENT+1]; 
	short off;
}; 
typedef struct list list_t; 

struct exception {
	short type;
	short exception;
};
typedef struct exception except_t;

static int	stringcopy(char *, char *, int);

/*
 * getauditflagschar() - convert bit flag to character string  
 * 
 * input: masks->as_success - audit on success 
 *	  masks->as_failure - audit on failure 
 *  	  verbose     - string format. 0 if short name; 1 if long name;  
 *
 * output: auditstring - resultant audit string 
 *
 * returns:  	0 - entry read ok
 *    		-1 - error
 */

int
getauditflagschar(char *auditstring, audit_state_t *masks, int verbose)  
{
	int i, j, k, mask_num;
	int list = -1, retstat = 0; 
	int except_list[3];
	char *prefix = "  ";
	except_t except[2];
	list_t lists[3]; 

	/* 
	 * initialize input buffer 
	 */
	strcpy(auditstring, "");
	/* 
	 * initialize lists struct 
	 */
	for (mask_num = COMMON; mask_num <= FAILURE; mask_num++) {
		lists[mask_num].count = 0;
		lists[mask_num].off = -1;
		for (i=0;i<MAXEVENT+1;i++)
			lists[mask_num].on[i] = -1;
	}
	/* 
	 * initialize exception lists 
	 */
	for (i = 0; i < 2; i++) {
		except[i].type = -1;
		except[i].exception = -1;
	}

	for (i = 0; i < 3; i++)
		except_list[i] = 0;

	/* 
	 * set length global 
	 */
	length = verbose;
	pos = 0;

	/* 
	 * find turned-on events - if on, store index of event  
	 * in one of the three event lists, common, success, failure.
	 */
	for ( i = 0; i < MAXEVENT; i++) {
		if (((event_class[i].event_mask & masks->as_success) > 0) ||
		  ((event_class[i].event_mask & masks->as_failure) > 0)) {

			/* 
			 * check for events in common 
			 */
			if (((event_class[i].event_mask & masks->as_success) > 
			  0) && 
			  ((event_class[i].event_mask & masks->as_failure) > 0))
				lists[COMMON].on[lists[COMMON].count++] = i;  
  
			/* 
			 * check for success events 
			 */
			if ((event_class[i].event_mask & masks->as_success) > 0)
				lists[SUCCESS].on[lists[SUCCESS].count++] = i;  
			else {
				except_list[SUCCESS]++;
			if (lists[SUCCESS].off == -1) 
				lists[SUCCESS].off = i;
			}
			/* 
			 * check for failure events 
			 */
			if ((event_class[i].event_mask & masks->as_failure) > 0)
				lists[FAILURE].on[lists[FAILURE].count++] = i;  
			else { 
				except_list[FAILURE]++;
				if (lists[FAILURE].off == -1)
				lists[FAILURE].off = i;
			}
		} else {
			except_list[COMMON]++;
			if (lists[COMMON].off == -1)  
			lists[COMMON].off = i;
		}
	}
	/* 
	* check for all set or all-1 set - output all and common exceptions. 
	*   the all or common state is exclusive; only one of the
	*   three, (+-)all, allowed
	*/
	/* 
	 * no exceptions 
	 */
	if (lists[COMMON].count >= MAXEVENT-2) {
		if (lists[COMMON].count == MAXEVENT)
			list = COMMON;

		/* 
		 * one exception 
		 */
		else if (lists[COMMON].count == MAXEVENT-1) {
			for (i=COMMON;i<=FAILURE && (list == -1);i++) {
				if (except_list[i] == 1) {
					list = COMMON;
					except[0].type = i;
					except[0].exception = lists[i].off;
				}
			}
		}
		/* 
		 * two exceptions 
		 */
		else if (lists[COMMON].count == MAXEVENT-2) {
			if (except_list[COMMON] == 1) {
				list = COMMON;
				except[0].type = COMMON;
				except[0].exception = lists[COMMON].off;
				for (i=SUCCESS;i<=FAILURE;i++) {
					if (except_list[i] == 1) {
						except[1].type = i;
						except[1].exception = lists[i].off;
					}
				}

			 } else if (except_list[COMMON] == 0) {
				for (i=SUCCESS,j=0;i<=FAILURE;i++) {
					if (except_list[i] == 1) {
						list = COMMON;
						except[j].type = i;
						except[j++].exception = lists[i].off;
					}
				}
			}
		}
	} else {
		/* 
		 * check for +all or -all 
		 */
		for (i=SUCCESS,j=0;i<=FAILURE;i++) { 
			if (lists[i].count >= MAXEVENT-1) {
				list = i; 
				except[j].type = i;
				if (lists[i].count != MAXEVENT) {
					if (lists[i].off != -1)
						except[j++].exception = 
						  lists[i].off;
					else
						except[j++].exception = 
						  lists[COMMON].off;
				} 
			}
		}
	}
	/* 
	 * output all and exceptions 
	 */
	if (list != -1) {
		if(list==SUCCESS) {
			if ((stringcopy(auditstring, "+", 0)) == -1)
				retstat = -1;
		}
		if(list==FAILURE) {
			if ((stringcopy(auditstring, "-", 0)) == -1)
				retstat = -1;
		}

		if (retstat == 0) {
			if (length) {
				if 
				  ((stringcopy(auditstring,event_class[11].event_lname,1)) == -1) 
					retstat = -1;
			} else 
				if ((stringcopy(auditstring, event_class[11].event_sname,1)) == -1) 
					retstat = -1;
		}

		if (retstat == 0) {
			/* 
			 * output exceptions 
			 */ 
			for (i=0;i<2 && except[i].exception != -1; i++) {
				if ((stringcopy(auditstring, "^", 0)) == -1)
					retstat = -1;
				if(except[i].type==SUCCESS) {
					if ((stringcopy(auditstring, "+", 0)) == -1)
						retstat = -1;
				}
				if (except[i].type==FAILURE) {
					if ((stringcopy(auditstring, "-", 0)) == -1)
						retstat = -1;
				}
				if (length == 1 && retstat == 0) {
					if ((stringcopy(auditstring, 
					 event_class[except[i].exception].event_lname, 1))==-1)
						retstat = -1;
				} else if (retstat == 0) {
					if ((stringcopy(auditstring, 
					event_class[except[i].exception].event_sname, 1))==-1) 
						retstat = -1;
				}
			}
		}
	} /* end of " all " processing */
   
	/* 
	 * process common events if no "all" was output 
	 */
	if (list == -1 && (lists[COMMON].count > 0) && retstat == 0) {
		/* 
		 * output common events first 
		 */
		for (j=0;j<lists[COMMON].count;j++) {
			if (length == 1) { 
				if ((stringcopy(auditstring, 
				 event_class[lists[COMMON].on[j]].event_lname, 1)) == -1)
					retstat = -1;
			} else if ((stringcopy(auditstring, 
			 event_class[lists[COMMON].on[j]].event_sname, 1)) == -1) 
				retstat = -1;
		}
		/* 
		 * remove common events from individual lists 
		 */
		if (retstat == 0) {
			for (i=SUCCESS;i<=FAILURE;i++) {
				for(j=0;j<lists[COMMON].count;j++) {
					for(k=0;k < lists[i].count;k++) { 
						if (lists[COMMON].on[j] == 
						  lists[i].on[k]) 
							lists[i].on[k] = -1;
					}
				}
			}
		}
	}

	/* 
	 * start processing individual event flags in success 
	 * and failure lists 
	 */
	if (list != COMMON && retstat == 0) {
		for (i=SUCCESS;i<=FAILURE;i++) {
			if(list != i) {
				if (i==SUCCESS) strcpy(prefix, "+");
				if (i==FAILURE) strcpy(prefix, "-");
				for (j=0;j<MAXEVENT && j<lists[i].count;j++) {
					if (lists[i].on[j] != -1) {
						if ((stringcopy(auditstring, prefix, 0)) == -1)
							retstat = -1;
						if (length == 1 && 
						  retstat == 0) {    
							if ((stringcopy(auditstring, 
							  event_class[lists[i].on[j]].event_lname, 1))==-1) 
							retstat = -1;
						} else if (retstat == 0) {
							if ((stringcopy(auditstring, 
							 event_class[lists[i].on[j]].event_sname, 1))==-1)
								retstat = -1;
						}
					}
				}
			}
		}
	}
	if ((stringcopy(auditstring, "\0", 2)) == -1)
		retstat = -1;

	return (retstat);
}

static int
stringcopy(char *auditstring, char *event,
    int flag)	/* if set, output comma after event */
{
	int retstat = 0;

	/* 
	 * check size 
	 */
	if (pos >= MAXSTRLEN) {
		fprintf(stderr,"getauditflagschar: Inputted buffer too small.\n");
		retstat = -1;
	} else if (flag != 2) {
		strcpy(auditstring+pos, event); 
		pos += strlen(event);
		if(flag) {
			strcpy(auditstring+pos, COMMASTR); 
			pos += strlen(COMMASTR); 
		}
	} else {
		/* 
		 * add null terminator only 
		 */
		if (pos)
			strcpy(auditstring+(pos-1), event);

	}
	return (retstat);
}

/*
 * getauditflagsbin() -  converts character string to success and 
 *			 failure bit masks
 * 
 * input: auditstring - audit string 
 *  	  cnt - number of elements in the masks array 
 *
 * output: masks->as_success - audit on success 
 *         masks->as_failure - audit on failure 
 *
 * returns: 0 - ok
 *    	    -1 - error - string contains characters which do 
 *        		not match event flag names
 */

int
getauditflagsbin(char *auditstring, audit_state_t *masks)  
{
	int i, gotone, done = 0, invert = 0, tryagain;
	int retstat = 0, succ_event, fail_event;
	char *ptr, tmp_buff[MAXFLDLEN];

	/* 
	 * process character string 
	 */
	do {
		gotone = 0;
		/* 
		 * read through string storing chars. until a comma 
		 */
		for (ptr=tmp_buff; !gotone;) {
			if(*auditstring!=COMMA && *auditstring!='\0' && 
			  *auditstring!='\n' && *auditstring!=' ')
				*ptr++ = *auditstring++;
			else if (*auditstring == ' ')
				*auditstring++;
			else {
				if (*auditstring == '\0' || 
				  *auditstring == '\n') {
					done = 1;
					if (ptr == tmp_buff)
						done = 2;
				}
				gotone = 1;
			}
		}
		/* 
		 * process audit state 
		 */
		if(gotone && done != 2) { 
			if(!done) auditstring++;
			*ptr++ = '\0';
			ptr = tmp_buff;
			gotone = 0;
			succ_event = ON;
			fail_event = ON;
			tryagain = 1;
			invert = 0;

			/* 
			 * get flags 
			 */
			do { 
				switch (*ptr++) {
				case '^':
					invert = 1;
					succ_event = OFF;
					fail_event = OFF;
					break;
				case '+':
					if (invert) 
						fail_event = OK;
					else {
						succ_event = ON;
						fail_event = OK;
					}
					break;
				case '-':
					if (invert) 
						succ_event = OK;
					else {
						fail_event = ON;
						succ_event = OK;
					}
					break;
				default:
					tryagain = 0;
					ptr--;
					break;
				}
			} while(tryagain);

			/* add audit state to mask */
			for (i=0;i<MAXEVENT+1 && !gotone;i++) {
				if ((!(strcmp(ptr, event_class[i].event_sname))) ||
				 (!(strcmp(ptr, event_class[i].event_lname)))) {
					if (succ_event == ON)
						masks->as_success |= event_class[i].event_mask;
					else if (succ_event == OFF)
						masks->as_success &= ~(event_class[i].event_mask);
					if (fail_event == ON)
						masks->as_failure |= event_class[i].event_mask;
					else if (fail_event == OFF)
						masks->as_failure &= ~(event_class[i].event_mask);
					gotone = 1;
				}
			}
			if(!gotone) {
				retstat = -1;
				done = 1;
			}
		} 
	} while (!done);
			
	return (retstat); 
}