xref: /titanic_50/usr/src/cmd/fmtmsg/main.c (revision c13de8f6a88563211bd4432ca11ca38ed3bf0fc0)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 
23 /*
24  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
25  * Use is subject to license terms.
26  */
27 
28 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
29 /*	  All Rights Reserved  	*/
30 
31 #pragma ident	"%Z%%M%	%I%	%E% SMI"
32 
33 
34 /*
35  * fmtmsg.c
36  *
37  * Contains:
38  *	fmtmsg		Command that writes a message in the standard
39  *			message format.  May in future make these
40  *			messages available for logging.
41  */
42 
43 
44 /*
45  * Header files used:
46  *	<stdio.h>	C Standard I/O function definitions
47  *	<string.h>	C string-handling definitions
48  *	<errno.h>	UNIX error-code "errno" definitions
49  *	<fmtmsg.h>	Standard Message definitions
50  */
51 
52 #include	<stdio.h>
53 #include	<string.h>
54 #include	<errno.h>
55 #include	<fmtmsg.h>
56 
57 
58 /*
59  * Externals referenced:
60  *	strtol		Function that converts char strings to "long"
61  *	fmtmsg		Function that writes a message in standard format
62  *	getenv		Function that extracts an environment variable's
63  *			value
64  *	malloc		Allocate memory from the memory pool
65  *	free		Frees allocated memory
66  *	getopt		Function that extracts arguments from the command-
67  *	optarg		Points to option's argument (from getopt())
68  *	optind		Option's argument index (from getopt())
69  *	opterr		FLAG, write error if invalid option (for getopt())
70  *			line.
71  *	exit		Exits the command
72  */
73 
74 extern	long		strtol();
75 extern	int		fmtmsg();
76 extern	char	       *getenv();
77 extern	void	       *malloc();
78 extern	void		free();
79 extern	int		getopt();
80 extern	char	       *optarg;
81 extern	int		optind;
82 extern	int		opterr;
83 extern	void		exit();
84 
85 /*
86  * Local definitions
87  */
88 
89 /*
90  * Local constants
91  */
92 
93 
94 /*
95  * Boolean constants
96  *	TRUE	Boolean value for "true" (any bits on)
97  *	FALSE	Boolean value for "false" (all bits off)
98  */
99 
100 #ifndef	FALSE
101 #define	FALSE		(0)
102 #endif
103 
104 #ifndef TRUE
105 #define	TRUE		(1)
106 #endif
107 
108 
109 #define	CLASS		(MM_PRINT|MM_SOFT|MM_NRECOV|MM_UTIL)
110 #define BIGUSAGE	"fmtmsg [-a action] [-c class] [-l label] [-s severity] [-t tag]\n       [-u subclass[,subclass[,...]]] [text]\n"
111 
112 
113 /*
114  * Local data-type definitions
115  */
116 
117 /*
118  * Structure used for tables containing keywords and integer values
119  */
120 
121 struct sev_info {
122 	char   *keyword;
123 	int	value;
124 };
125 
126 
127 /*
128  * Structure used for tables containing keywords, long values
129  */
130 
131 struct class_info {
132 	char   *keyword;
133 	long	value;
134 	long	conflict;
135 };
136 
137 
138 /*
139  * Severity string structure
140  *
141  *	struct sevstr
142  *		sevvalue	Value of the severity-level being defined
143  *		sevkywd		Keyword identifying the severity
144  *		sevprptr	Pointer to the string associated with the value
145  *		sevnext		Pointer to the next value in the list.
146  */
147 
148 struct sevstr {
149 	int		sevvalue;
150 	char           *sevkywd;
151 	char	       *sevprstr;
152 	struct sevstr  *sevnext;
153 };
154 
155 
156 /*
157  * Local static data
158  */
159 
160 
161 /*
162  * Table contains the keywords for the classes of a message
163  */
164 
165 static	struct class_info	classes[] = {
166 
167 	{"hard", 	MM_HARD,	MM_SOFT|MM_FIRM},	/* hardware */
168 	{"soft", 	MM_SOFT,	MM_HARD|MM_FIRM},	/* software */
169 	{"firm", 	MM_FIRM,	MM_SOFT|MM_FIRM},	/* firmware */
170 
171 	{(char *) NULL,	0L,		0L}			/* end of list */
172 
173 };
174 
175 
176 /*
177  * Table contains the keywords for the subclasses for a message
178  */
179 
180 static	struct class_info	subclasses[] = 	{
181 
182 	{"appl",     	MM_APPL,	MM_UTIL|MM_OPSYS},	/* Application */
183 	{"util",     	MM_UTIL,	MM_APPL|MM_OPSYS},	/* Utility */
184 	{"opsys",    	MM_OPSYS,	MM_APPL|MM_UTIL},	/* Operating System */
185 
186 	{"recov",    	MM_RECOVER,	MM_NRECOV},		/* Recoverable */
187 	{"nrecov",   	MM_NRECOV,	MM_RECOVER},		/* Non-recoverable */
188 
189 	{"print",    	MM_PRINT,	0L}, 			/* Write message to stderr */
190 	{"console",  	MM_CONSOLE,	0L},			/* Write message on /dev/console */
191 	{(char *) NULL,	0L,		0L}			/* End of list */
192 
193 };
194 
195 
196 /*
197  * Table contains the keywords for the standard severities of a message.
198  * User may supply more through the SEV_LEVEL environment variable.
199  */
200 
201 static  struct sev_info		severities[] =  {
202 	{"halt",	MM_HALT},	/* halt */
203 	{"error",	MM_ERROR},	/* error */
204 	{"warn",	MM_WARNING},	/* warn */
205 	{"info",	MM_INFO},	/* info */
206 	{(char *) NULL,	0}		/* end of list */
207 };
208 
209 
210 /*
211  * Buffers used by the command
212  */
213 
214 static	char	labelbuf[128];		/* Buf for message label */
215 static	char	msgbuf[256];		/* Buf for messages */
216 
217 /*
218  * static char *exttok(str, delims)
219  *	char   *str
220  *	char   *delims
221  *
222  *	This function examines the string pointed to by "str", looking
223  *	for the first occurrence of any of the characters in the string
224  *	whose address is "delims".  It returns the address of that
225  *	character or (char *) NULL if there was nothing to search.
226  *
227  * Arguments:
228  *	str	Address of the string to search
229  *	delims	Address of the string containing delimiters
230  *
231  * Returns:  char *
232  *	Returns the address of the first occurrence of any of the characters
233  *	in "delim" in the string "str" (incl '\0').  If there was nothing
234  *	to search, the function returns (char *) NULL.
235  *
236  * Notes:
237  *    - This function is needed because strtok() can't be used inside a
238  *	function.  Besides, strtok() is destructive in the string, which
239  *	is undesirable in many circumstances.
240  *    - This function understands escaped delimiters as non-delimiters.
241  *	Delimiters are escaped by preceding them with '\' characters.
242  *	The '\' character also must be escaped.
243  */
244 
245 static char *
246 exttok(tok, delims)
247 	char   *tok;		/* Ptr to the token we're parsing */
248 	char   *delims;		/* Ptr to string with delimiters */
249 {
250 
251 	/* Automatic Data */
252 	char   *tokend;		/* Ptr to the end of the token */
253 	char   *p, *q;	 	/* Temp pointers */
254 
255 
256 	/* Algorithm:
257 	 *    1.  Get the starting address (new string or where we
258 	 *	  left off).  If nothing to search, return (char *) NULL
259 	 *    2.  Find the end of the string
260 	 *    3.  Look for the first unescaped delimiter closest to the
261 	 *	  beginning of the string
262 	 *    4.  Remember where we left off
263 	 *    5.  Return a pointer to the delimiter we found
264 	 */
265 
266 	/* Begin at the beginning, if any */
267 	if (tok == (char *) NULL) {
268 	    return ((char *) NULL);
269 	}
270 
271 	/* Find end of the token string */
272 	tokend = tok + strlen(tok);
273 
274 	/* Look for the 1st occurrence of any delimiter */
275 	for (p = delims ; *p != '\0' ; p++) {
276 	    for (q = strchr(tok, *p) ; q && (q != tok) && (*(q-1) == '\\') ; q = strchr(q+1, *p)) ;
277 	    if (q && (q < tokend)) tokend = q;
278 	}
279 
280 	/* Done */
281 	return(tokend);
282 }
283 
284 /*
285  * char *noesc(str)
286  *
287  *	This function squeezes out all of the escaped character sequences
288  *	from the string <str>.  It returns a pointer to that string.
289  *
290  *  Arguments:
291  *	str	char *
292  *		The string that is to have its escaped characters removed.
293  *
294  *  Returns:  char *
295  *	This function returns its argument <str> always.
296  *
297  *  Notes:
298  *	This function potentially modifies the string it is given.
299  */
300 
301 char *
302 noesc(str)
303 	char   *str;		/* String to remove escaped characters from */
304 {
305 	char   *p;		/* Temp string pointer */
306 	char   *q;		/* Temp string pointer */
307 
308 	/* Look for an escaped character */
309 	p = str;
310 	while (*p && (*p != '\\')) p++;
311 
312 
313 	/*
314 	 * If there was at least one, squeeze them out
315 	 * Otherwise, don't touch the argument string
316 	 */
317 
318 	if (*p) {
319 	    q = p++;
320 	    while (*q++ = *p++) if (*p == '\\') p++;
321 	}
322 
323 	/* Finished.  Return our argument */
324 	return(str);
325 }
326 
327 /*
328  * struct sevstr *getauxsevs(ptr)
329  *
330  *	Parses a string that is in the format of the severity definitions.
331  *	Returns a pointer to a (malloc'd) structure that contains the
332  *	definition, or (struct sevstr *) NULL if none was parsed.
333  *
334  * Arguments:
335  *	ptr	char *
336  *		References the string from which data is to be extracted.
337  *		If (char *) NULL, continue where we left off.  Otherwise,
338  *		start with the string referenced by ptr.
339  *
340  * Returns: struct sevstr *
341  *	A pointer to a malloc'd structure containing the severity definition
342  *	parsed from string, or (struct sevstr *) NULL if none.
343  *
344  * Notes:
345  *    - This function is destructive to the string referenced by its argument.
346  */
347 
348 
349 /* Static data */
350 static	char	       *leftoff = (char *) NULL;
351 
352 static	struct sevstr *
353 getauxsevs(ptr)
354 	char   *ptr;
355 {
356 
357 	/* Automatic data */
358 	char	       *current;	/* Ptr to current sev def'n */
359 	char	       *tokend;		/* Ptr to end of current sev def'n */
360 	char	       *kywd;		/* Ptr to extracted kywd */
361 	char	       *valstr;		/* Ptr to extracted sev value */
362 	char	       *prstr;		/* Ptr to extracted print str */
363 	char	       *p;		/* Temp pointer */
364 	int		val;		/* Converted severity value */
365 	int		done;		/* Flag, sev def'n found and ok? */
366 	struct sevstr  *rtnval;		/* Value to return */
367 
368 
369 	/* Start anew or start where we left off? */
370 	current = (ptr == (char *) NULL) ? leftoff : ptr;
371 
372 
373 	/* If nothing to parse, return (char *) NULL */
374 	if (current == (char *) NULL) {
375 	    return ((struct sevstr *) NULL);
376 	}
377 
378 
379 	/*
380 	 * Look through the string "current" for a token of the form
381 	 * <kywd>,<sev>,<printstring> delimited by ':' or '\0'
382 	 */
383 
384 	/* Loop initializations */
385 	done = FALSE;
386 	rtnval = (struct sevstr *) NULL;
387 	while (!done) {
388 
389 	    /* Eat leading junk */
390 	    while (*(tokend = exttok(current, ":,")) == ':') {
391 		current = tokend + 1;
392 	    }
393 
394 	    /* If we've found a <kywd>,... */
395 	    if (*tokend == ',') {
396 		kywd = current;
397 		*tokend = '\0';
398 
399 		/* Look for <kywd>,<sev>,... */
400 		current = tokend + 1;
401 		if (*(tokend = exttok(current, ":,")) == ',') {
402 		    valstr = current;
403 		    *tokend = '\0';
404 		    current = tokend+1;
405 		    prstr = current;
406 
407 		    /* Make sure <sev> > 4 */
408 		    val = (int) strtol(noesc(valstr), &p, 0);
409 		    if ((val > 4) && (p == tokend)) {
410 
411 			/*
412 			 * Found <kywd>,<sev>,<printstring>.
413 			 * remember where we left off
414 			 */
415 
416 		        if (*(tokend = exttok(current, ":")) == ':') {
417 			    *tokend = '\0';
418 			    leftoff = tokend + 1;
419 			} else leftoff = (char *) NULL;
420 
421 			/* Alloc structure to contain severity definition */
422 			if (rtnval = (struct sevstr *) malloc(sizeof(struct sevstr))) {
423 
424 			    /* Fill in structure */
425 			    rtnval->sevkywd = noesc(kywd);
426 			    rtnval->sevvalue = val;
427 			    rtnval->sevprstr = noesc(prstr);
428 			    rtnval->sevnext = (struct sevstr *) NULL;
429 			}
430 
431 			done = TRUE;
432 
433 		    } else {
434 
435 			/* Invalid severity value, eat thru end of token */
436 			current = tokend;
437 			if (*(tokend = exttok(prstr, ":")) == ':')
438 			    current++;
439 		    }
440 
441 		} else {
442 
443 		    /* Invalid severity definition, eat thru end of token */
444 		    current = tokend;
445 		    if (*tokend == ':')
446 			current++;
447 		}
448 
449 	    } else {
450 
451 		/* End of string found */
452 		done = TRUE;
453 		leftoff = (char *) NULL;
454 	    }
455 
456 	} /* while (!done) */
457 
458 	/* Finished */
459 	return(rtnval);
460 }
461 
462 /*
463  * fmtmsg [-a action] [-c classification] [-l label] [-s severity] [-t tag]
464  *        [-u subclass[,subclass[,...]]] [text]
465  *
466  * Function:
467  *	Writes a message in the standard format.  Typically used by shell
468  *	scripts to write error messages to the user.
469  *
470  * Arguments:
471  *	text		String that is the text of the message
472  *
473  * Options:
474  *   -a action		String that describes user action to take to
475  *			correct the situation
476  *   -c classification	Keyword that identifies the type of the message
477  *   -l label		String that identifies the source of the message
478  *   -s severity	Keyword that identifies the severity of the message
479  *   -t tag		String that identifies the message (use unclear)
480  *   -u sub_classes	Comma-list of keywords that refines the type of
481  *			the message
482  *
483  * Environment Variables Used:
484  *	MSGVERB		Defines the pieces of a message the user expects
485  *			to see.  It is a list of keywords separated by
486  *			colons (':').
487  *	SEV_LEVEL	Defines a list of auxiliary severity keywords, values,
488  *			and print-strings.  It is a list of fields separated
489  *			by colons (':').  Each field consists of three
490  *			elements, keyword, value (in octal, hex, or decimal),
491  *			and print-string, separated by commas (',').
492  *
493  * Needs:
494  *
495  * Open Issues:
496  */
497 
498 int
499 main(int argc, char **argv)
500 {
501 
502 	/* Local automatic data */
503 
504 	long			class;		/* Classification (built) */
505 
506 	int			severity;	/* User specified severity */
507 	int			msgrtn;		/* Value returned by fmtmsg() */
508 	int			optchar;	/* Opt char on cmdline */
509 	int			exitval;	/* Value to return */
510 
511 	int			found;		/* FLAG, kywd found yet? */
512 	int			errflg;		/* FLAG, error seen in cmd */
513 	int			a_seen;		/* FLAG, -a option seen */
514 	int			c_seen;		/* FLAG, -c option seen */
515 	int			l_seen;		/* FLAG, -l option seen */
516 	int			s_seen;		/* FLAG, -s option seen */
517 	int			t_seen;		/* FLAG, -t option seen */
518 	int			u_seen;		/* FLAG, -u option seen */
519 	int			text_seen;	/* FLAG, text seen */
520 
521 	char		       *text;		/* Ptr to user's text */
522 	char		       *label;		/* Ptr to user's label */
523 	char		       *tag;		/* Ptr to user's tag */
524 	char		       *action;		/* Ptr to user's action str */
525 	char		       *sstr;		/* Ptr to -s (severity) arg */
526 	char		       *ustr;		/* Ptr to -u (subclass) arg */
527 	char		       *cstr;		/* Ptr to -c (class) arg */
528 	char		       *sevstrval;	/* Ptr to SEV_LEVEL argument */
529 	char		       *sevval;		/* Ptr to temp SEV_LEVEL arg */
530 	char		       *tokenptr;	/* Ptr to current token */
531 	char		       *cmdname;	/* Ptr to base command name */
532 	char		       *p;		/* Multipurpose ptr */
533 
534 	struct class_info      *class_info;	/* Ptr to class/subclass info structure */
535 	struct sev_info	       *sev_info;	/* Ptr to severity info struct */
536 	struct sevstr	       *penvsev;	/* Ptr to SEV_LEVEL values */
537 
538 
539 
540 	/*
541 	 * fmtmsg
542 	 */
543 
544 
545 	/* Initializations */
546 
547 
548 	/* Extract the base command name from the command */
549 	if ((p = strrchr(argv[0], '/')) == (char *) NULL)
550 	    cmdname = argv[0];
551 	else
552 	    cmdname = p+1;
553 
554 	/* Build the label for messages from "fmtmsg" */
555 	(void) snprintf(labelbuf, sizeof (labelbuf), "UX:%s", cmdname);
556 
557 
558 	/*
559 	 * Extract arguments from the command line
560 	 */
561 
562 	/* Initializations */
563 
564 	opterr = 0;			/* Disable messages from getopt() */
565 	errflg = FALSE;			/* No errors seen yet */
566 
567 	a_seen = FALSE;			/* No action (-a) text seen yet */
568 	c_seen = FALSE;			/* No classification (-c) seen yet */
569 	l_seen = FALSE;			/* No label (-l) seen yet */
570 	s_seen = FALSE;			/* No severity (-s) seen yet */
571 	t_seen = FALSE;			/* No tag (-t) seen yet */
572 	u_seen = FALSE;			/* No subclass (-u) seen yet */
573 	text_seen = FALSE;		/* No text seen yet */
574 
575 
576 	/*
577 	 * If only the command name was used, write out a usage string to
578 	 * the standard output file.
579 	 */
580 
581 	if (argc == 1) {
582 	    (void) fputs(BIGUSAGE, stderr);
583 	    exit(0);
584 	}
585 
586 
587 	/* Parce command line */
588 	while (((optchar = getopt(argc, argv, "a:c:l:s:t:u:")) != EOF) &&
589 	       !errflg) {
590 
591 	    switch(optchar) {
592 
593 	    case 'a':		/* -a actiontext */
594 		if (!a_seen) {
595 		    action = optarg;
596 		    a_seen = TRUE;
597 		} else errflg = TRUE;
598 		break;
599 
600 	    case 'c':		/* -c classification */
601 		if (!c_seen) {
602 		    cstr = optarg;
603 		    c_seen = TRUE;
604 		} else errflg = TRUE;
605 		break;
606 
607 	    case 'l':		/* -l label */
608 		if (!l_seen) {
609 		    label = optarg;
610 		    l_seen = TRUE;
611 		} else errflg = TRUE;
612 		break;
613 
614 	    case 's':		/* -s severity */
615 		if (!s_seen) {
616 		    sstr = optarg;
617 		    s_seen = TRUE;
618 		} else errflg = TRUE;
619 		break;
620 
621 	    case 't':		/* -t tag */
622 		if (!t_seen) {
623 		    tag = optarg;
624 		    t_seen = TRUE;
625 		} else errflg = TRUE;
626 		break;
627 
628 	    case 'u':		/* -u subclasslist */
629 		if (!u_seen) {
630 		    ustr = optarg;
631 		    u_seen = TRUE;
632 		} else errflg = TRUE;
633 		break;
634 
635 	    case '?':		/* -? or unknown option */
636 	    default:
637 		errflg = TRUE;
638 		break;
639 
640 	    } /* esac */
641 	}
642 
643 
644 	/* Get the text */
645 	if (!errflg) {
646 	    if (argc == (optind+1)) {
647 		text = argv[optind];
648 		text_seen = TRUE;
649 	    }
650 	    else if (argc != optind) {
651 		errflg = TRUE;
652 	    }
653 	}
654 
655 
656 	/* Report syntax errors */
657 	if (errflg) {
658 	    (void) fputs(BIGUSAGE, stderr);
659 	    exit(1);
660 	}
661 
662 
663 	/*
664 	 * Classification.
665 	 */
666 
667 	class = 0L;
668 	if (c_seen) {
669 
670 	    /* Search for keyword in list */
671 	    for (class_info = &classes[0] ;
672 		 (class_info->keyword != (char *) NULL) &&
673 		 (strcmp(cstr, class_info->keyword)) ;
674 		 class_info++) ;
675 
676 	    /* If invalid (keyword unknown), write a message and exit */
677 	    if (class_info->keyword == (char *) NULL) {
678 		(void) snprintf(msgbuf, sizeof (msgbuf),
679 			"Invalid class: %s", cstr);
680 		(void) fmtmsg(CLASS, labelbuf, MM_ERROR, msgbuf,
681 		              MM_NULLACT, MM_NULLTAG);
682 		exit(1);
683 	    }
684 
685 	    /* Save classification */
686 	    class = class_info->value;
687 
688 	}
689 
690 
691 	/*
692 	 * Subclassification.
693 	 */
694 
695 	if (u_seen) {
696 
697 	    errflg = FALSE;
698 	    p = strcpy(malloc((unsigned int) strlen(ustr)+1), ustr);
699 	    if ((tokenptr = strtok(p, ",")) == (char *) NULL) errflg = TRUE;
700 	    else do {
701 
702 		/* Got a keyword.  Look for it in keyword list */
703 		for (class_info = subclasses ;
704 		     (class_info->keyword != (char *) NULL) &&
705 		     (strcmp(tokenptr, class_info->keyword) != 0) ;
706 		     class_info++) ;
707 
708 		/* If found in list and no conflict, remember in class */
709 		if ((class_info->keyword != (char *) NULL) && ((class & class_info->conflict) == 0L))
710 		    class |= class_info->value;
711 		else
712 		    errflg = TRUE;
713 
714 	    } while (!errflg && ((tokenptr = strtok((char *) NULL, ",")) != (char *) NULL)) ;
715 
716 	    if (errflg) {
717 		(void) snprintf(msgbuf, sizeof (msgbuf),
718 			"Invalid subclass: %s", ustr);
719 		(void) fmtmsg(CLASS, labelbuf, MM_ERROR, msgbuf,
720 		              MM_NULLACT, MM_NULLTAG);
721 		exit(1);
722 	    }
723 
724 	}
725 
726 	if (!c_seen & !u_seen) class = MM_NULLMC;
727 
728 
729 
730 	/*
731 	 * Severity.
732 	 */
733 
734 	if (s_seen) {
735 
736 	    /* If the severity is specified as a number, use that value */
737 	    severity = strtol(sstr, &p, 10);
738 	    if (*p || (strlen(sstr) == 0)) {
739 
740 		/* Look for the standard severities */
741 		for (sev_info = severities ;
742 		     (sev_info->keyword != (char *) NULL) &&
743 		     (strcmp(sstr, sev_info->keyword)) ;
744 		     sev_info++) ;
745 
746 		/*
747 		 * If the "severity" argument is one of the standard keywords,
748 		 * remember it for fmtmsg().  Otherwise, look at the SEV_LEVEL
749 		 * environment variable for severity extensions.
750 		 */
751 
752 		/* If the keyword is one of the standard ones, save severity */
753 		if (sev_info->keyword != (char *) NULL) severity = sev_info->value;
754 
755 		else {
756 
757 		    /*
758 		     * Severity keyword may be one of the extended set, if any.
759 		     */
760 
761 		    /* Get the value of the SEV_LEVEL environment variable */
762 		    found = FALSE;
763 		    if ((sevstrval = getenv(SEV_LEVEL)) != (char *) NULL) {
764 			sevval = (char *) malloc((unsigned int) strlen(sevstrval)+1);
765 			penvsev = getauxsevs(strcpy(sevval, sevstrval));
766 			if (penvsev != (struct sevstr *) NULL) do {
767 			    if (strcmp(penvsev->sevkywd, sstr) == 0) {
768 				severity = penvsev->sevvalue;
769 				found = TRUE;
770 			    }
771 			    else {
772 				free(penvsev);
773 				penvsev = getauxsevs((char *) NULL);
774 			    }
775 			} while (!found && (penvsev != (struct sevstr *) NULL));
776 
777 			if (found) free(penvsev);
778 			free(sevval);
779 		    }
780 
781 		    if (!found) {
782 			(void) snprintf(msgbuf, sizeof (msgbuf),
783 				"Invalid severity: %s", sstr);
784 			(void) fmtmsg(CLASS, labelbuf, MM_ERROR, msgbuf,
785 				      MM_NULLACT, MM_NULLTAG);
786 			exit(1);
787 		    }
788 
789 		}  /* <severity> is not one of the standard severities */
790 
791 	    }  /* <severity> is not numeric */
792 
793 	}  /* if (s_seen) */
794 
795 	else severity = MM_NULLSEV;
796 
797 
798 	/*
799 	 * Other options
800 	 */
801 
802 	if (!a_seen) action = MM_NULLACT;
803 	if (!l_seen) label = MM_NULLLBL;
804 	if (!t_seen) tag = MM_NULLTAG;
805 	if (!text_seen) text = MM_NULLTXT;
806 
807 
808 	/*
809 	 * Write the message
810 	 */
811 
812 	msgrtn = fmtmsg(class, label, severity, text, action ,tag);
813 
814 
815 	/*
816 	 * Return appropriate value to the shell (or wherever)
817 	 */
818 
819 	exitval = 0;
820 	if (msgrtn == MM_NOTOK) exitval = 32;
821 	else {
822 	    if (msgrtn & MM_NOMSG) exitval += 2;
823 	    if (msgrtn & MM_NOCON) exitval += 4;
824 	}
825 
826 	return(exitval);
827 }
828