Fix typos.
[kopensolaris-gnu/glibc.git] / 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);