stdlib/fmtmsg.c

   1 /* Copyright (C) 1997-2024 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 #include <fmtmsg.h>
  19 #include <libc-lock.h>
  20 #include <stdio.h>
  21 #include <stdint.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/syslog.h>
  25 #include <wchar.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   uint32_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
  98
  99 int
 100 fmtmsg (long int classification, const char *label, int severity,
 101         const char *text, const char *action, const char *tag)
 102 {
 103   __libc_once_define (static, once);
 104   struct severity_info *severity_rec;
 105
 106   /* Make sure everything is initialized.  */
 107   __libc_once (once, init);
 108
 109   /* Start the real work.  First check whether the input is ok.  */
 110   if (label != MM_NULLLBL)
 111     {
 112       /* Must be two fields, separated by a colon.  */
 113       const char *cp = strchr (label, ':');
 114       if (cp == NULL)
 115         return MM_NOTOK;
 116
 117       /* The first field must not contain more than 10 bytes.  */
 118       if (cp - label > 10
 119           /* The second field must not have more than 14 bytes.  */
 120           || strlen (cp + 1) > 14)
 121         return MM_NOTOK;
 122     }
 123
 124   /* We do not want this call to be cut short by a thread
 125      cancellation.  Therefore disable cancellation for now.  */
 126   int state = PTHREAD_CANCEL_ENABLE;
 127   __pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &state);
 128
 129   __libc_lock_lock (lock);
 130
 131   for (severity_rec = severity_list; severity_rec != NULL;
 132        severity_rec = severity_rec->next)
 133     if (severity == severity_rec->severity)
 134       /* Bingo.  */
 135       break;
 136
 137   /* If we don't know anything about the severity level return an error.  */
 138   int result = MM_NOTOK;
 139   if (severity_rec != NULL)
 140     {
 141       result = MM_OK;
 142
 143       /* Now we can print.  */
 144       if (classification & MM_PRINT)
 145         {
 146           int do_label = (print & label_mask) && label != MM_NULLLBL;
 147           int do_severity = (print & severity_mask) && severity != MM_NULLSEV;
 148           int do_text = (print & text_mask) && text != MM_NULLTXT;
 149           int do_action = (print & action_mask) && action != MM_NULLACT;
 150           int do_tag = (print & tag_mask) && tag != MM_NULLTAG;
 151           int need_colon = (do_label
 152                             && (do_severity | do_text | do_action | do_tag));
 153
 154           if (__fxprintf (stderr, "%s%s%s%s%s%s%s%s%s%s\n",
 155                           do_label ? label : "",
 156                           need_colon ? ": " : "",
 157                           do_severity ? severity_rec->string : "",
 158                           do_severity && (do_text | do_action | do_tag)
 159                           ? ": " : "",
 160                           do_text ? text : "",
 161                           do_text && (do_action | do_tag) ? "\n" : "",
 162                           do_action ? "TO FIX: " : "",
 163                           do_action ? action : "",
 164                           do_action && do_tag ? "  " : "",
 165                           do_tag ? tag : "") < 0)
 166             /* Oh, oh.  An error occurred during the output.  */
 167             result = MM_NOMSG;
 168         }
 169
 170       if (classification & MM_CONSOLE)
 171         {
 172           int do_label = label != MM_NULLLBL;
 173           int do_severity = severity != MM_NULLSEV;
 174           int do_text = text != MM_NULLTXT;
 175           int do_action = action != MM_NULLACT;
 176           int do_tag = tag != MM_NULLTAG;
 177           int need_colon = (do_label
 178                             && (do_severity | do_text | do_action | do_tag));
 179
 180           syslog (LOG_ERR, "%s%s%s%s%s%s%s%s%s%s\n",
 181                   do_label ? label : "",
 182                   need_colon ? ": " : "",
 183                   do_severity ? severity_rec->string : "",
 184                   do_severity && (do_text | do_action | do_tag) ? ": " : "",
 185                   do_text ? text : "",
 186                   do_text && (do_action | do_tag) ? "\n" : "",
 187                   do_action ? "TO FIX: " : "",
 188                   do_action ? action : "",
 189                   do_action && do_tag ? "  " : "",
 190                   do_tag ? tag : "");
 191         }
 192     }
 193
 194   __libc_lock_unlock (lock);
 195
 196   __pthread_setcancelstate (state, NULL);
 197
 198   return result;
 199 }
 200
 201
 202 /* Initialize from environment variable content.  */
 203 static void
 204 init (void)
 205 {
 206   const char *msgverb_var = getenv ("MSGVERB");
 207   const char *sevlevel_var = getenv ("SEV_LEVEL");
 208
 209   if (msgverb_var != NULL && msgverb_var[0] != '\0')
 210     {
 211       /* Using this extra variable allows us to work without locking.  */
 212       do
 213         {
 214           size_t cnt;
 215
 216           for (cnt = 0; cnt < NKEYWORDS; ++cnt)
 217             if (memcmp (msgverb_var,
 218                         keywords[cnt].name, keywords[cnt].len) == 0
 219                 && (msgverb_var[keywords[cnt].len] == ':'
 220                     || msgverb_var[keywords[cnt].len] == '\0'))
 221               break;
 222
 223           if (cnt < NKEYWORDS)
 224             {
 225               print |= 1 << cnt;
 226
 227               msgverb_var += keywords[cnt].len;
 228               if (msgverb_var[0] == ':')
 229                 ++msgverb_var;
 230             }
 231           else
 232             {
 233               /* We found an illegal keyword in the environment
 234                  variable.  The specifications say that we print all
 235                  fields.  */
 236               print = all_mask;
 237               break;
 238             }
 239         }
 240       while (msgverb_var[0] != '\0');
 241     }
 242   else
 243     print = all_mask;
 244
 245
 246   if (sevlevel_var != NULL)
 247     {
 248       __libc_lock_lock (lock);
 249
 250       while (sevlevel_var[0] != '\0')
 251         {
 252           const char *end = __strchrnul (sevlevel_var, ':');
 253           int level;
 254
 255           /* First field: keyword.  This is not used here but it must be
 256              present.  */
 257           while (sevlevel_var < end)
 258             if (*sevlevel_var++ == ',')
 259               break;
 260
 261           if (sevlevel_var < end)
 262             {
 263               /* Second field: severity level, a number.  */
 264               char *cp;
 265
 266               level = strtol (sevlevel_var, &cp, 0);
 267               if (cp != sevlevel_var && cp < end && *cp++ == ','
 268                   && level > MM_INFO)
 269                 {
 270                   const char *new_string;
 271
 272                   new_string = __strndup (cp, end - cp);
 273
 274                   if (new_string != NULL
 275                       && (internal_addseverity (level, new_string)
 276                           != MM_OK))
 277                     free ((char *) new_string);
 278                 }
 279             }
 280
 281           sevlevel_var = end + (*end == ':' ? 1 : 0);
 282         }
 283
 284       __libc_lock_unlock (lock);
 285     }
 286 }
 287
 288
 289 /* Add the new entry to the list.  */
 290 static int
 291 internal_addseverity (int severity, const char *string)
 292 {
 293   struct severity_info *runp, *lastp;
 294   int result = MM_OK;
 295
 296   /* First see if there is already a record for the severity level.  */
 297   for (runp = severity_list, lastp = NULL; runp != NULL; runp = runp->next)
 298     if (runp->severity == severity)
 299       break;
 300     else
 301       lastp = runp;
 302
 303   if (runp != NULL)
 304     {
 305       if (string != NULL)
 306         /* Change the string.  */
 307         runp->string = string;
 308       else
 309         {
 310           /* Remove the severity class.  */
 311           if (lastp == NULL)
 312             severity_list = runp->next;
 313           else
 314             lastp->next = runp->next;
 315
 316           free (runp);
 317         }
 318     }
 319   else if (string != NULL)
 320     {
 321       runp = malloc (sizeof (*runp));
 322       if (runp == NULL)
 323         result = MM_NOTOK;
 324       else
 325         {
 326           runp->severity = severity;
 327           runp->next = severity_list;
 328           runp->string = string;
 329           severity_list = runp;
 330         }
 331     }
 332   else
 333     /* We tried to remove a non-existing severity class.  */
 334     result = MM_NOTOK;
 335
 336   return result;
 337 }
 338
 339
 340 /* Add new severity level or remove old one.  */
 341 int
 342 __addseverity (int severity, const char *string)
 343 {
 344   int result;
 345
 346   /* Prevent illegal SEVERITY values.  */
 347   if (severity <= MM_INFO)
 348     return MM_NOTOK;
 349
 350   /* Protect the global data.  */
 351   __libc_lock_lock (lock);
 352
 353   /* Do the real work.  */
 354   result = internal_addseverity (severity, string);
 355
 356   /* Release the lock.  */
 357   __libc_lock_unlock (lock);
 358
 359   return result;
 360 }
 361 weak_alias (__addseverity, addseverity)
 362
 363
 364 void
 365 __libc_fmtmsg_freemem (void)
 366 {
 367   struct severity_info *runp = severity_list;
 368
 369   while (runp != NULL)
 370     if (runp->severity > MM_INFO)
 371       {
 372         /* This is data we have to release.  */
 373         struct severity_info *here = runp;
 374         runp = runp->next;
 375         free (here);
 376       }
 377     else
 378       runp = runp->next;
 379 }