| /* Copyright (C) 1997-2018 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include <fmtmsg.h> |
| #include <libc-lock.h> |
| #include <stdio.h> |
| #include <stdint.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/syslog.h> |
| #include <wchar.h> |
| |
| |
| /* We have global data, protect the modification. */ |
| __libc_lock_define_initialized (static, lock) |
| |
| |
| enum |
| { |
| label_mask = 0x01, |
| severity_mask = 0x02, |
| text_mask = 0x04, |
| action_mask = 0x08, |
| tag_mask = 0x10, |
| all_mask = label_mask | severity_mask | text_mask | action_mask | tag_mask |
| }; |
| |
| static const struct |
| { |
| uint32_t len; |
| /* Adjust the size if new elements are added. */ |
| const char name[12]; |
| } keywords[] = |
| { |
| { 5, "label" }, |
| { 8, "severity" }, |
| { 4, "text" }, |
| { 6, "action"}, |
| { 3, "tag" } |
| }; |
| #define NKEYWORDS (sizeof( keywords) / sizeof (keywords[0])) |
| |
| |
| struct severity_info |
| { |
| int severity; |
| const char *string; |
| struct severity_info *next; |
| }; |
| |
| |
| /* List of known severities. */ |
| static const struct severity_info nosev = |
| { |
| MM_NOSEV, "", NULL |
| }; |
| static const struct severity_info haltsev = |
| { |
| MM_HALT, "HALT", (struct severity_info *) &nosev |
| }; |
| static const struct severity_info errorsev = |
| { |
| MM_ERROR, "ERROR", (struct severity_info *) &haltsev |
| }; |
| static const struct severity_info warningsev = |
| { |
| MM_WARNING, "WARNING", (struct severity_info *) &errorsev |
| }; |
| static const struct severity_info infosev = |
| { |
| MM_INFO, "INFO", (struct severity_info *) &warningsev |
| }; |
| |
| /* Start of the list. */ |
| static struct severity_info *severity_list = (struct severity_info *) &infosev; |
| |
| /* Mask of values we will print. */ |
| static int print; |
| |
| /* Prototypes for local functions. */ |
| static void init (void); |
| static int internal_addseverity (int severity, const char *string); |
| |
| |
| int |
| fmtmsg (long int classification, const char *label, int severity, |
| const char *text, const char *action, const char *tag) |
| { |
| __libc_once_define (static, once); |
| struct severity_info *severity_rec; |
| |
| /* Make sure everything is initialized. */ |
| __libc_once (once, init); |
| |
| /* Start the real work. First check whether the input is ok. */ |
| if (label != MM_NULLLBL) |
| { |
| /* Must be two fields, separated by a colon. */ |
| const char *cp = strchr (label, ':'); |
| if (cp == NULL) |
| return MM_NOTOK; |
| |
| /* The first field must not contain more than 10 bytes. */ |
| if (cp - label > 10 |
| /* The second field must not have more than 14 bytes. */ |
| || strlen (cp + 1) > 14) |
| return MM_NOTOK; |
| } |
| |
| #ifdef __libc_ptf_call |
| /* We do not want this call to be cut short by a thread |
| cancellation. Therefore disable cancellation for now. */ |
| int state = PTHREAD_CANCEL_ENABLE; |
| __libc_ptf_call (__pthread_setcancelstate, |
| (PTHREAD_CANCEL_DISABLE, &state), 0); |
| #endif |
| |
| __libc_lock_lock (lock); |
| |
| for (severity_rec = severity_list; severity_rec != NULL; |
| severity_rec = severity_rec->next) |
| if (severity == severity_rec->severity) |
| /* Bingo. */ |
| break; |
| |
| /* If we don't know anything about the severity level return an error. */ |
| int result = MM_NOTOK; |
| if (severity_rec != NULL) |
| { |
| result = MM_OK; |
| |
| /* Now we can print. */ |
| if (classification & MM_PRINT) |
| { |
| int do_label = (print & label_mask) && label != MM_NULLLBL; |
| int do_severity = (print & severity_mask) && severity != MM_NULLSEV; |
| int do_text = (print & text_mask) && text != MM_NULLTXT; |
| int do_action = (print & action_mask) && action != MM_NULLACT; |
| int do_tag = (print & tag_mask) && tag != MM_NULLTAG; |
| int need_colon = (do_label |
| && (do_severity | do_text | do_action | do_tag)); |
| |
| if (__fxprintf (stderr, "%s%s%s%s%s%s%s%s%s%s\n", |
| do_label ? label : "", |
| need_colon ? ": " : "", |
| do_severity ? severity_rec->string : "", |
| do_severity && (do_text | do_action | do_tag) |
| ? ": " : "", |
| do_text ? text : "", |
| do_text && (do_action | do_tag) ? "\n" : "", |
| do_action ? "TO FIX: " : "", |
| do_action ? action : "", |
| do_action && do_tag ? " " : "", |
| do_tag ? tag : "") < 0) |
| /* Oh, oh. An error occurred during the output. */ |
| result = MM_NOMSG; |
| } |
| |
| if (classification & MM_CONSOLE) |
| { |
| int do_label = label != MM_NULLLBL; |
| int do_severity = severity != MM_NULLSEV; |
| int do_text = text != MM_NULLTXT; |
| int do_action = action != MM_NULLACT; |
| int do_tag = tag != MM_NULLTAG; |
| int need_colon = (do_label |
| && (do_severity | do_text | do_action | do_tag)); |
| |
| syslog (LOG_ERR, "%s%s%s%s%s%s%s%s%s%s\n", |
| do_label ? label : "", |
| need_colon ? ": " : "", |
| do_severity ? severity_rec->string : "", |
| do_severity && (do_text | do_action | do_tag) ? ": " : "", |
| do_text ? text : "", |
| do_text && (do_action | do_tag) ? "\n" : "", |
| do_action ? "TO FIX: " : "", |
| do_action ? action : "", |
| do_action && do_tag ? " " : "", |
| do_tag ? tag : ""); |
| } |
| } |
| |
| __libc_lock_unlock (lock); |
| |
| #ifdef __libc_ptf_call |
| __libc_ptf_call (__pthread_setcancelstate, (state, NULL), 0); |
| #endif |
| |
| return result; |
| } |
| |
| |
| /* Initialize from environment variable content. */ |
| static void |
| init (void) |
| { |
| const char *msgverb_var = getenv ("MSGVERB"); |
| const char *sevlevel_var = getenv ("SEV_LEVEL"); |
| |
| if (msgverb_var != NULL && msgverb_var[0] != '\0') |
| { |
| /* Using this extra variable allows us to work without locking. */ |
| do |
| { |
| size_t cnt; |
| |
| for (cnt = 0; cnt < NKEYWORDS; ++cnt) |
| if (memcmp (msgverb_var, |
| keywords[cnt].name, keywords[cnt].len) == 0 |
| && (msgverb_var[keywords[cnt].len] == ':' |
| || msgverb_var[keywords[cnt].len] == '\0')) |
| break; |
| |
| if (cnt < NKEYWORDS) |
| { |
| print |= 1 << cnt; |
| |
| msgverb_var += keywords[cnt].len; |
| if (msgverb_var[0] == ':') |
| ++msgverb_var; |
| } |
| else |
| { |
| /* We found an illegal keyword in the environment |
| variable. The specifications say that we print all |
| fields. */ |
| print = all_mask; |
| break; |
| } |
| } |
| while (msgverb_var[0] != '\0'); |
| } |
| else |
| print = all_mask; |
| |
| |
| if (sevlevel_var != NULL) |
| { |
| __libc_lock_lock (lock); |
| |
| while (sevlevel_var[0] != '\0') |
| { |
| const char *end = __strchrnul (sevlevel_var, ':'); |
| int level; |
| |
| /* First field: keyword. This is not used here but it must be |
| present. */ |
| while (sevlevel_var < end) |
| if (*sevlevel_var++ == ',') |
| break; |
| |
| if (sevlevel_var < end) |
| { |
| /* Second field: severity level, a number. */ |
| char *cp; |
| |
| level = strtol (sevlevel_var, &cp, 0); |
| if (cp != sevlevel_var && cp < end && *cp++ == ',' |
| && level > MM_INFO) |
| { |
| const char *new_string; |
| |
| new_string = __strndup (cp, end - cp); |
| |
| if (new_string != NULL |
| && (internal_addseverity (level, new_string) |
| != MM_OK)) |
| free ((char *) new_string); |
| } |
| } |
| |
| sevlevel_var = end + (*end == ':' ? 1 : 0); |
| } |
| |
| __libc_lock_unlock (lock); |
| } |
| } |
| |
| |
| /* Add the new entry to the list. */ |
| static int |
| internal_addseverity (int severity, const char *string) |
| { |
| struct severity_info *runp, *lastp; |
| int result = MM_OK; |
| |
| /* First see if there is already a record for the severity level. */ |
| for (runp = severity_list, lastp = NULL; runp != NULL; runp = runp->next) |
| if (runp->severity == severity) |
| break; |
| else |
| lastp = runp; |
| |
| if (runp != NULL) |
| { |
| if (string != NULL) |
| /* Change the string. */ |
| runp->string = string; |
| else |
| { |
| /* Remove the severity class. */ |
| if (lastp == NULL) |
| severity_list = runp->next; |
| else |
| lastp->next = runp->next; |
| |
| free (runp); |
| } |
| } |
| else if (string != NULL) |
| { |
| runp = malloc (sizeof (*runp)); |
| if (runp == NULL) |
| result = MM_NOTOK; |
| else |
| { |
| runp->severity = severity; |
| runp->next = severity_list; |
| runp->string = string; |
| severity_list = runp; |
| } |
| } |
| else |
| /* We tried to remove a non-existing severity class. */ |
| result = MM_NOTOK; |
| |
| return result; |
| } |
| |
| |
| /* Add new severity level or remove old one. */ |
| int |
| __addseverity (int severity, const char *string) |
| { |
| int result; |
| |
| /* Prevent illegal SEVERITY values. */ |
| if (severity <= MM_INFO) |
| return MM_NOTOK; |
| |
| /* Protect the global data. */ |
| __libc_lock_lock (lock); |
| |
| /* Do the real work. */ |
| result = internal_addseverity (severity, string); |
| |
| /* Release the lock. */ |
| __libc_lock_unlock (lock); |
| |
| return result; |
| } |
| weak_alias (__addseverity, addseverity) |
| |
| |
| libc_freeres_fn (free_mem) |
| { |
| struct severity_info *runp = severity_list; |
| |
| while (runp != NULL) |
| if (runp->severity > MM_INFO) |
| { |
| /* This is data we have to release. */ |
| struct severity_info *here = runp; |
| runp = runp->next; |
| free (here); |
| } |
| else |
| runp = runp->next; |
| } |