usr/src/cmd/fmtmsg/main.c

   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 \f
  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 \f
 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 \f
 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 \f
 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 \f
 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 }