/*

 * 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 2004 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

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

/*	Copyright (c) 1988 AT&T	*/

/*	  All Rights Reserved  	*/

/*

 * fmtmsg.c

 *

 *  Contains:

 *	fmtmsg()	Writes a message in standard format.

 *	addseverity()	Adds a severity definition to the list of known

 *			severity definitions.

 *

 *	Notes:

 *	  - None of these functions can use strtok().

 */

/*

 * Header Files Referenced:

 *	<stdio.h>		C Standard I/O Definitions

 *	<string.h>		C string handling definitions

 *	<fcntl.h>		UNIX file control definitions

 *	<errno.h>		UNIX error numbers and definitions

 *	<fmtmsg.h>		Global definitions for fmtmsg()

 *	<stdlib.h>		miscellaneous function declarations

 */

#pragma weak fmtmsg = _fmtmsg

#pragma weak addseverity = _addseverity

#include "synonyms.h"

#include "mtlib.h"

#include "libc.h"

#include <sys/types.h>

#include <stddef.h>

#include <stdio.h>

#include <string.h>

#include <fcntl.h>

#include <errno.h>

#include <fmtmsg.h>

#include <stdlib.h>

#include <thread.h>

#include <synch.h>

#include <alloca.h>

/*

 * External functions referenced:

 *	(Others may be defined in header files above)

 *

 *	getenv		Extracts data from the environment

 *	libc_malloc	Allocates space from main memory

 *	libc_free	Frees space allocated via libc_malloc()

 *	strtol		Convert string to "long"

 *	clearerr	Clears an error on a stream (this is to make "lint"

 *			happy)

 */

/*

 * Local Constant Definitions

 */

/*

 * Boolean constants

 *	TRUE	Boolean value for "true" (any bits on)

 *	FALSE	Boolean value for "false" (all bits off)

 */

#ifndef	FALSE

#define	FALSE		(0)

#endif

#ifndef TRUE

#define	TRUE		(1)

#endif

#define	MAX_MSG_SIZE	1024

/*

 * Keywords for fields named in the MSGVERB environment variable.

 */

#define	ST_LBL		"label"

#define	ST_SEV		"severity"

#define	ST_TXT		"text"

#define	ST_TAG		"tag"

#define	ST_ACT		"action"

/*

 *	The following constants define the value of the "msgverb"

 *	variable.  This variable tells fmtmsg() which parts of the

 *	standard message it is to display.  If !(msgverb&MV_SET),

 *	fmtmsg() will interrogate the "MSGVERB" environment variable

 *	and set "msgverb" accordingly.

 *

 *	NOTE:  This means that if MSGVERB changes after the first call

 *	       to fmtmsg(), it will be ignored.

 *

 *	Constants:

 *		MV_INV	Check MSGVERB environment variable (invalidates value)

 *		MV_SET	MSGVERB checked, msgverb value valid

 *		MV_LBL	"label" selected

 *		MV_SEV	"severity" selected

 *		MV_TXT	"text" selected

 *		MV_TAG	"messageID" selected

 *		MV_ACT	"action" selected

 *

 *		MV_ALL	All components selected

 *		MV_DFLT	Default value for MSGVERB

 */

#define	MV_INV		0

#define	MV_SET		0x0001

#define	MV_LBL		0x0002

#define	MV_SEV		0x0004

#define	MV_TXT		0x0008

#define	MV_TAG		0x0010

#define	MV_ACT		0x0020

#define	MV_ALL		(MV_LBL|MV_SEV|MV_TXT|MV_TAG|MV_ACT)

#define	MV_DFLT		(MV_LBL|MV_SEV|MV_TXT|MV_TAG|MV_ACT)

/*

 * Strings defining the different severities of a message.

 * Internationalization may demand that these come from the message database

 */

#define	SV_UNK		"UNKNOWN"

#define	SV_HALT		"HALT"

#define	SV_ERROR	"ERROR"

#define	SV_WARN		"WARNING"

#define	SV_INF		"INFO"

/*

 * Text string if none is provided:

 */

#define	DEFLT_TEXT	"No text provided with this message"

/*

 * Text string introduction for "action".  This may have to come from

 * the message database because of internationalization.

 */

#define	ACTINTRO	"TO FIX: "

#define	ACTINTROLN	8

/*

 * SEPSTR is the string that separates the "label" from what follows it,

 * and the severity from what follows it.

 */

#define	SEPSTR		": "

#define	SEPSTRLN	2

/*

 * Miscellaneous constants:

 *	CONNAME		Filesystem entry name for the system console

 */

#define	CONNAME		"/dev/console"

/*

 * Local data type definitions

 */

/*

 * Severity string structure

 *

 *	struct sevstr

 *		sevvalue	Value of the severity-level being defined

 *		sevkywd		Keyword identifying the severity

 *		sevprptr	Pointer to the string associated with the value

 *		sevnext		Pointer to the next value in the list.

 *

 *	Restrictions:

 *		sevvalue	Must be a non-negative integer (>=0)

 *

 *	There are three (possibly null) lists of these structures.

 *	  1)	is the list of standard severities

 *	  2)	is the list of severity-levels defined by SEV_LEVEL

 *	  3)	is the list of severity-levels defined by calls to

 *		addseverity()

 */

struct sevstr {

	int		sevvalue;

	const char	*sevkywd;

	const char	*sevprstr;

	struct sevstr  *sevnext;

};

/*

 * Local Static Data

 *	msgverb		int

 *			Contains the internal representation or the

 *			MSGVERB environment variable.

 *	sevlook		TRUE if fmtmsg() has to look at SEV_LEVEL the

 *			next time it is called.

 *	paugsevs	struct sevstr *

 *			Head of the linked list of structures that define

 *			severities that augment the standard severities,

 *			as defined by addseverity().

 *	penvsevs	struct sevstrs *

 *			Head of the linked list of structures that define

 *			severities that augment the standard severities,

 *			as defined by SEV_LEVEL.

 *	pstdsevs	struct sevstrs *

 *			Head of the linked list of structures that define

 *			the standard severities.

 */

static mutex_t fmt_lock = DEFAULTMUTEX;

static	int		msgverb		= 0;

static	int		sevlook		= TRUE;

static	struct sevstr  *paugsevs	= (struct sevstr *)NULL;

static	struct sevstr  *penvsevs	= (struct sevstr *)NULL;

static	struct sevstr	sevstrs[]	= {

	{ MM_HALT,	"", SV_HALT,	&sevstrs[1]},

	{ MM_ERROR,    "", SV_ERROR,	&sevstrs[2]},

	{ MM_WARNING,  "", SV_WARN, 	&sevstrs[3]},

	{ MM_INFO,	"", SV_INF,  	(struct sevstr *)NULL},

};

static	struct sevstr  *pstdsevs	= &sevstrs[0];

/*

 * static char *exttok(str, delims)

 *	const char   *str

 *	const char   *delims

 *

 *	This function examines the string pointed to by "str", looking

 *	for the first occurrence of any of the characters in the string

 *	whose address is "delims".  It returns the address of that

 *	character or (char *)NULL if there was nothing to search.

 *

 * Arguments:

 *	str	Address of the string to search

 *	delims	Address of the string containing delimiters

 *

 * Returns:  char *

 *	Returns the address of the first occurrence of any of the characters

 *	in "delim" in the string "str" (incl '\0').  If there was nothing

 *	to search, the function returns (char *)NULL.

 *

 * Notes:

 *    - This function is needed because strtok() can't be used inside a

 *	function.  Besides, strtok() is destructive in the string, which

 *	is undesirable in many circumstances.

 *    - This function understands escaped delimiters as non-delimiters.

 *	Delimiters are escaped by preceding them with '\' characters.

 *	The '\' character also must be escaped.

 */

static char *

exttok(const char *tok, const char *delims)

{

	char	*tokend;	/* Ptr to the end of the token */

	char	*p, *q;		/* Temp pointers */

	/*

	 * Algorithm:

	 *    1.  Get the starting address(new string or where we

	 *	  left off).  If nothing to search, return(char *)NULL

	 *    2.  Find the end of the string

	 *    3.  Look for the first unescaped delimiter closest to the

	 *	  beginning of the string

	 *    4.  Remember where we left off

	 *    5.  Return a pointer to the delimiter we found

	 */

	/* Begin at the beginning, if any */

	if (tok == (char *)NULL) {

		return ((char *)NULL);

	}

	/* Find end of the token string */

	tokend = (char *)tok + (ptrdiff_t)strlen(tok);

	/* Look for the 1st occurrence of any delimiter */

	for (p = (char *)delims; *p != '\0'; p++) {

		for (q = strchr(tok, (int)*p);

		    (q != 0) && (q != tok) && (*(q - (ptrdiff_t)1) == '\\');

		    q = strchr(q + (ptrdiff_t)1, (int)*p))

			;

		if ((q != 0) && (q < tokend))

			tokend = q;

	}

	/* Done */

	return (tokend);

}

/*

 * char *noesc(str)

 *

 *	This function squeezes out all of the escaped character sequences

 *	from the string <str>.  It returns a pointer to that string.

 *

 *  Arguments:

 *	str	char *

 *		The string that is to have its escaped characters removed.

 *

 *  Returns:  char *

 *	This function returns its argument <str> always.

 *

 *  Notes:

 *	This function potentially modifies the string it is given.

 */

static char *

noesc(char *str)

{

	char   *p;		/* Temp string pointer */

	char   *q;		/* Temp string pointer */

	/* Look for an escaped character */

	p = str;

	while (*p && (*p != '\\')) p++;

	/*

	 * If there was at least one, squeeze them out

	 * Otherwise, don't touch the argument string

	 */

	if (*p) {

		q = p++;

		while (*q++ = *p++) {

			if (*p == '\\')

				p++;

		}

	}

	/* Finished.  Return our argument */

	return (str);

}

/*

 * struct sevstr *getauxsevs(ptr)

 *

 *	Parses a string that is in the format of the severity definitions.

 *	Returns a pointer to a (malloc'd) structure that contains the

 *	definition, or (struct sevstr *)NULL if none was parsed.

 *

 * Arguments:

 *	ptr	char *

 *		References the string from which data is to be extracted.

 *		If (char *)NULL, continue where we left off.  Otherwise,

 *		start with the string referenced by ptr.

 *

 * Returns: struct sevstr *

 *	A pointer to a malloc'd structure containing the severity definition

 *	parsed from string, or (struct sevstr *)NULL if none.

 *

 * Notes:

 *    - This function is destructive to the string referenced by its argument.

 */

/* Static data */

static	char		*leftoff = (char *)NULL;

static	struct sevstr *

getauxsevs(char *ptr)

{

	char		*current;	/* Ptr to current sev def'n */

	char		*tokend;	/* Ptr to end of current sev def'n */

	char		*kywd;		/* Ptr to extracted kywd */

	char		*valstr;		/* Ptr to extracted sev value */

	char		*prstr;		/* Ptr to extracted print str */

	char		*p;		/* Temp pointer */

	int		val;		/* Converted severity value */

	int		done;		/* Flag, sev def'n found and ok? */

	struct sevstr  *rtnval;		/* Value to return */

	/* Start anew or start where we left off? */

	current = (ptr == (char *)NULL) ? leftoff : ptr;

	/* If nothing to parse, return (char *)NULL */

	if (current == (char *)NULL) {

		return ((struct sevstr *)NULL);

	}

	/*

	 * Look through the string "current" for a token of the form

	 * <kywd>,<sev>,<printstring> delimited by ':' or '\0'

	 */

	/* Loop initializations */

	done = FALSE;

	rtnval = (struct sevstr *)NULL;

	while (!done) {

		/* Eat leading junk */

		while (*(tokend = exttok(current, ":,")) == ':') {

			current = tokend + (ptrdiff_t)1;

		}

		/* If we've found a <kywd>,... */

		if (*tokend == ',') {

			kywd = current;

			*tokend = '\0';

			/* Look for <kywd>,<sev>,... */

			current = tokend + (ptrdiff_t)1;

			if (*(tokend = exttok(current, ":,")) == ',') {

				valstr = current;

				*tokend = '\0';

				current = tokend + (ptrdiff_t)1;

				prstr = current;

				/* Make sure <sev> > 4 */

				val = (int)strtol(noesc(valstr), &p, 0);

				if ((val > 4) && (p == tokend)) {

					/*

					 * Found <kywd>,<sev>,<printstring>.

					 * remember where we left off

					 */

					if (*(tokend =

						exttok(current, ":")) == ':') {

						*tokend = '\0';

						leftoff = tokend +

						    (ptrdiff_t)1;

					} else {

						leftoff = (char *)NULL;

					}

					/*

					 * Alloc structure to contain

					 * severity definition

					 */

					rtnval = libc_malloc(

					    sizeof (struct sevstr));

					if (rtnval != NULL) {

						/* Fill in structure */

						rtnval->sevkywd = noesc(kywd);

						rtnval->sevvalue = val;

						rtnval->sevprstr = noesc(prstr);

						rtnval->sevnext =

						    (struct sevstr *)NULL;

					}

					done = TRUE;

				} else {

					/*

					 * Invalid severity value,

					 * eat thru end of token

					 */

					current = tokend;

					if (*(tokend = exttok(prstr, ":")) ==

					    ':') {

						current++;

					}

				}

			} else {

				/*

				 * Invalid severity definition,

				 * eat thru end of token

				 */

				current = tokend;

				if (*tokend == ':')

					current++;

			}

		} else {

			/* End of string found */

			done = TRUE;

			leftoff = (char *)NULL;

		}

	} /* while (!done) */

	/* Finished */

	return (rtnval);

}

/*

 * void msgverbset()

 *

 *	Parces the argument of the MSGVERB environment variable and places

 *	a representation of the value of that value in "msgverb"

 *

 * Arguments:

 *	None:

 *

 * Returns: void

 *

 * Notes:

 */