stdlib/fmtmsg.c

   1 /* Copyright (C) 1997, 1999 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #include <fmtmsg.h>
  21 #include <bits/libc-lock.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <sys/syslog.h>
  26
  27
  28 /* We have global data, protect the modification.  */
  29 __libc_lock_define_initialized (static, lock)
  30
  31
  32 enum
  33 {
  34   label_mask = 0x01,
  35   severity_mask = 0x02,
  36   text_mask = 0x04,
  37   action_mask = 0x08,
  38   tag_mask = 0x10,
  39   all_mask = label_mask | severity_mask | text_mask | action_mask | tag_mask
  40 };
  41
  42 static const struct
  43 {
  44   size_t len;
  45   /* Adjust the size if new elements are added.  */
  46   const char name[12];
  47 } keywords[] =
  48   {
  49     { 5, "label" },
  50     { 8, "severity" },
  51     { 4, "text" },
  52     { 6, "action"},
  53     { 3, "tag" }
  54   };
  55 #define NKEYWORDS (sizeof( keywords) / sizeof (keywords[0]))
  56
  57
  58 struct severity_info
  59 {
  60   int severity;
  61   const char *string;
  62   struct severity_info *next;
  63 };
  64
  65
  66 /* List of known severities.  */
  67 static const struct severity_info nosev =
  68 {
  69   MM_NOSEV, "", NULL
  70 };
  71 static const struct severity_info haltsev =
  72 {
  73   MM_HALT, "HALT", (struct severity_info *) &nosev
  74 };
  75 static const struct severity_info errorsev =
  76 {
  77   MM_ERROR, "ERROR", (struct severity_info *) &haltsev
  78 };
  79 static const struct severity_info warningsev =
  80 {
  81   MM_WARNING, "WARNING", (struct severity_info *) &errorsev
  82 };
  83 static const struct severity_info infosev =
  84 {
  85   MM_INFO, "INFO", (struct severity_info *) &warningsev
  86 };
  87
  88 /* Start of the list.  */
  89 static struct severity_info *severity_list = (struct severity_info *) &infosev;
  90
  91 /* Mask of values we will print.  */
  92 static int print;
  93
  94 /* Prototypes for local functions.  */
  95 static void init (void);
  96 static int internal_addseverity (int severity, const char *string)
  97      internal_function;
  98
  99
 100 int
 101 fmtmsg (long int classification, const char *label, int severity,
 102         const char *text, const char *action, const char *tag)
 103 {
 104   __libc_once_define (static, once);
 105   int result = MM_OK;
 106   struct severity_info *severity_rec;
 107
 108   /* make sure everything is initialized.  */
 109   __libc_once (once, init);
 110
 111   /* Start the real work.  First check whether the input is ok.  */
 112   if (label != MM_NULLLBL)
 113     {
 114       /* Must be two fields, separated by a colon.  */
 115       const char *cp = strchr (label, ':');
 116       if (cp == NULL)
 117         return MM_NOTOK;
 118
 119       /* The first field must not contain more then 10 bytes.  */
 120       if (cp - label > 10
 121           /* The second field must not have more then 14 bytes.  */
 122           || strlen (cp + 1) > 14)
 123         return MM_NOTOK;
 124     }
 125
 126   for (severity_rec = severity_list; severity_rec != NULL;
 127        severity_rec = severity_rec->next)
 128     if (severity == severity_rec->severity)
 129       /* Bingo.  */
 130       break;
 131
 132   /* If we don't know anything about the severity level return an error.  */
 133   if (severity_rec == NULL)
 134     return MM_NOTOK;
 135
 136
 137   /* Now we can print.  */
 138   if (classification & MM_PRINT)
 139     {
 140       int do_label = (print & label_mask) && label != MM_NULLLBL;
 141       int do_severity = (print & severity_mask) && severity != MM_NULLSEV;
 142       int do_text = (print & text_mask) && text != MM_NULLTXT;
 143       int do_action = (print & action_mask) && action != MM_NULLACT;
 144       int do_tag = (print & tag_mask) && tag != MM_NULLTAG;
 145
 146       if (fprintf (stderr, "%s%s%s%s%s%s%s%s%s%s\n",
 147                    do_label ? label : "",
 148                    do_label && (do_severity | do_text) ? ": " : "",
 149                    do_severity ? severity_rec->string : "",
 150                    do_severity && do_text ? ": " : "",
 151                    do_text ? text : "",
 152                    (do_label | do_severity | do_text) && (do_action | do_tag)
 153                    ? "\n" : "",
 154                    do_action ? "TO FIX: " : "",
 155                    do_action ? action : "",
 156                    do_action && do_tag ? " " : "",
 157                    do_tag ? tag : "") == EOF)
 158         /* Oh, oh.  An error occurred during the output.  */
 159         result = MM_NOMSG;
 160     }
 161
 162   if (classification & MM_CONSOLE)
 163     {
 164       int do_label = label != MM_NULLLBL;
 165       int do_severity = severity != MM_NULLSEV;
 166       int do_text = text != MM_NULLTXT;
 167       int do_action = action != MM_NULLACT;
 168       int do_tag = tag != MM_NULLTAG;
 169
 170       syslog (LOG_ERR, "%s%s%s%s%s%s%s%s%s%s\n",
 171               do_label ? label : "",
 172               do_label && (do_severity | do_text) ? ": " : "",
 173               do_severity ? severity_rec->string : "",
 174               do_severity && do_text ? ": " : "",
 175               do_text ? text : "",
 176               (do_label | do_severity | do_text) && (do_action | do_tag)
 177               ? "\n" : "",
 178               do_action ? "TO FIX: " : "",
 179               do_action ? action : "",
 180               do_action && do_tag ? " " : "",
 181               do_tag ? tag : "");
 182     }
 183
 184   return result;
 185 }
 186
 187
 188 /* Initialize from environment variable content.  */
 189 static void
 190 init (void)
 191 {
 192   const char *msgverb_var = getenv ("MSGVERB");
 193   const char *sevlevel_var = getenv ("SEV_LEVEL");
 194
 195   if (msgverb_var != NULL && msgverb_var[0] != '\0')
 196     {
 197       /* Using this extra variable allows us to work without locking.  */
 198       do
 199         {
 200           size_t cnt;
 201
 202           for (cnt = 0; cnt < NKEYWORDS; ++cnt)
 203             if (memcmp (msgverb_var,
 204                         keywords[cnt].name, keywords[cnt].len) == 0
 205                 && (msgverb_var[keywords[cnt].len] == ':'
 206                     || msgverb_var[keywords[cnt].len] == '\0'))
 207               break;
 208
 209           if (cnt < NKEYWORDS)
 210             {
 211               print |= 1 << cnt;
 212
 213               msgverb_var += keywords[cnt].len;
 214               if (msgverb_var[0] == ':')
 215                 ++msgverb_var;
 216             }
 217           else
 218             {
 219               /* We found an illegal keyword in the environment
 220                  variable.  The specifications say that we print all
 221                  fields.  */
 222               print = all_mask;
 223               break;
 224             }
 225         }
 226       while (msgverb_var[0] != '\0');
 227     }
 228   else
 229     print = all_mask;
 230
 231
 232   if (sevlevel_var != NULL)
 233     {
 234       __libc_lock_lock (lock);
 235
 236       while (sevlevel_var[0] != '\0')
 237         {
 238           const char *end = __strchrnul (sevlevel_var, ':');
 239           int level;
 240
 241           /* First field: keyword.  This is not used here but it must be
 242              present.  */
 243           while (sevlevel_var < end)
 244             if (*sevlevel_var++ == ',')
 245               break;
 246
 247           if (sevlevel_var < end)
 248             {
 249               /* Second field: severity level, a number.  */
 250               char *cp;
 251
 252               level = strtol (sevlevel_var, &cp, 0);
 253               if (cp != sevlevel_var && cp < end && *cp++ == ','
 254                   && level > MM_INFO)
 255                 {
 256                   const char *new_string;
 257
 258                   new_string = __strndup (cp, end - cp);
 259
 260                   if (new_string != NULL
 261                       && (internal_addseverity (level, new_string)
 262                           != MM_OK))
 263                     free ((char *) new_string);
 264                 }
 265             }
 266
 267           sevlevel_var = end + (*end == ':' ? 1 : 0);
 268         }
 269     }
 270 }
 271
 272
 273 /* Add the new entry to the list.  */
 274 static int
 275 internal_function
 276 internal_addseverity (int severity, const char *string)
 277 {
 278   struct severity_info *runp, *lastp;
 279   int result = MM_OK;
 280
 281   /* First see if there is already a record for the severity level.  */
 282   for (runp = severity_list, lastp = NULL; runp != NULL; runp = runp-> next)
 283     if (runp->severity == severity)
 284       break;
 285     else
 286       lastp = runp;
 287
 288   if (runp != NULL)
 289     {
 290       /* Release old string.  */
 291       free ((char *) runp->string);
 292
 293       if (string != NULL)
 294         /* Change the string.  */
 295         runp->string = string;
 296       else
 297         {
 298           /* Remove the severity class.  */
 299           if (lastp == NULL)
 300             severity_list = runp->next;
 301           else
 302             lastp->next = runp->next;
 303
 304           free (runp);
 305         }
 306     }
 307   else if (string != NULL)
 308     {
 309       runp = malloc (sizeof (*runp));
 310       if (runp == NULL)
 311         result = MM_NOTOK;
 312       else
 313         {
 314           runp->severity = severity;
 315           runp->next = severity_list;
 316           runp->string = string;
 317           severity_list = runp;
 318         }
 319     }
 320   else
 321     /* We tried to remove a non-existing severity class.  */
 322     result = MM_NOTOK;
 323
 324   return result;
 325 }
 326
 327
 328 /* Add new severity level or remove old one.  */
 329 int
 330 addseverity (int severity, const char *string)
 331 {
 332   int result;
 333   const char *new_string;
 334
 335   /* Prevent illegal SEVERITY values.  */
 336   if (severity <= MM_INFO)
 337     return MM_NOTOK;
 338
 339   if (string == NULL)
 340     /* We want to remove the severity class.  */
 341     new_string = NULL;
 342   else
 343     {
 344       new_string = __strdup (string);
 345
 346       if (new_string == NULL)
 347         /* Allocation failed or illegal value.  */
 348         return MM_NOTOK;
 349     }
 350
 351   /* Protect the global data.  */
 352   __libc_lock_lock (lock);
 353
 354   /* Do the real work.  */
 355   result = internal_addseverity (severity, string);
 356
 357   if (result != MM_OK)
 358     /* Free the allocated string.  */
 359     free ((char *) new_string);
 360
 361   /* Release the lock.  */
 362   __libc_lock_unlock (lock);
 363
 364   return result;
 365 }
 366
 367
 368 static void __attribute__ ((unused))
 369 free_mem (void)
 370 {
 371   struct severity_info *runp = severity_list;
 372
 373   while (runp != NULL)
 374     if (runp->severity > MM_INFO)
 375       {
 376         /* This is data we have to release.  */
 377         struct severity_info *here = runp;
 378         free ((char *) runp->string);
 379         runp = runp->next;
 380         free (here);
 381       }
 382     else
 383       runp = runp->next;
 384 }
 385 text_set_element (__libc_subfreeres, free_mem);