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