libc: Fix -Wunused-parameter.
[dragonfly.git] / lib / libc / gen / fmtmsg.c
1 /*-
2  * Copyright (c) 2002 Mike Barcroft <mike@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/lib/libc/gen/fmtmsg.c,v 1.5 2003/05/01 19:03:13 nectar Exp $
27  */
28
29 #include <fmtmsg.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33
34 /* Default value for MSGVERB. */
35 #define DFLT_MSGVERB    "label:severity:text:action:tag"
36
37 /* Maximum valid size for a MSGVERB. */
38 #define MAX_MSGVERB     sizeof(DFLT_MSGVERB)
39
40 static char     *printfmt(char *, long, const char *, int, const char *,
41                     const char *, const char *);
42 static char     *nextcomp(const char *);
43 static const char
44                 *sevinfo(int);
45 static int       validmsgverb(const char *);
46
47 static const char *validlist[] = {
48         "label", "severity", "text", "action", "tag", NULL
49 };
50
51 int
52 fmtmsg(long class, const char *label, int sev, const char *text,
53     const char *action, const char *tag)
54 {
55         FILE *fp;
56         char *env, *msgverb, *output;
57
58         if (class & MM_PRINT) {
59                 if ((env = getenv("MSGVERB")) != NULL && *env != '\0' &&
60                     strlen(env) <= strlen(DFLT_MSGVERB)) {
61                         if ((msgverb = strdup(env)) == NULL)
62                                 return (MM_NOTOK);
63                         else if (validmsgverb(msgverb) == 0) {
64                                 free(msgverb);
65                                 goto def;
66                         }
67                 } else {
68 def:
69                         if ((msgverb = strdup(DFLT_MSGVERB)) == NULL)
70                                 return (MM_NOTOK);
71                 }
72                 output = printfmt(msgverb, class, label, sev, text, action,
73                     tag);
74                 if (output == NULL) {
75                         free(msgverb);
76                         return (MM_NOTOK);
77                 }
78                 if (*output != '\0')
79                         fprintf(stderr, "%s", output);
80                 free(msgverb);
81                 free(output);
82         }
83         if (class & MM_CONSOLE) {
84                 output = printfmt(DFLT_MSGVERB, class, label, sev, text,
85                     action, tag);
86                 if (output == NULL)
87                         return (MM_NOCON);
88                 if (*output != '\0') {
89                         if ((fp = fopen("/dev/console", "a")) == NULL) {
90                                 free(output);
91                                 return (MM_NOCON);
92                         }
93                         fprintf(fp, "%s", output);
94                         fclose(fp);
95                 }
96                 free(output);
97         }
98         return (MM_OK);
99 }
100
101 #define INSERT_COLON                                                    \
102         if (*output != '\0')                                            \
103                 strlcat(output, ": ", size)
104 #define INSERT_NEWLINE                                                  \
105         if (*output != '\0')                                            \
106                 strlcat(output, "\n", size)
107 #define INSERT_SPACE                                                    \
108         if (*output != '\0')                                            \
109                 strlcat(output, " ", size)
110
111 /*
112  * Returns NULL on memory allocation failure, otherwise returns a pointer to
113  * a newly malloc()'d output buffer.
114  */
115 static char *
116 printfmt(char *msgverb, long class __unused, const char *label, int sev,
117     const char *text, const char *act, const char *tag)
118 {
119         size_t size;
120         char *comp, *output;
121         const char *sevname;
122
123         size = 32;
124         if (label != MM_NULLLBL)
125                 size += strlen(label);
126         if ((sevname = sevinfo(sev)) != NULL)
127                 size += strlen(sevname);
128         if (text != MM_NULLTXT)
129                 size += strlen(text);
130         if (text != MM_NULLACT)
131                 size += strlen(act);
132         if (tag != MM_NULLTAG)
133                 size += strlen(tag);
134
135         if ((output = malloc(size)) == NULL)
136                 return (NULL);
137         *output = '\0';
138         while ((comp = nextcomp(msgverb)) != NULL) {
139                 if (strcmp(comp, "label") == 0 && label != MM_NULLLBL) {
140                         INSERT_COLON;
141                         strlcat(output, label, size);
142                 } else if (strcmp(comp, "severity") == 0 && sevname != NULL) {
143                         INSERT_COLON;
144                         strlcat(output, sevinfo(sev), size);
145                 } else if (strcmp(comp, "text") == 0 && text != MM_NULLTXT) {
146                         INSERT_COLON;
147                         strlcat(output, text, size);
148                 } else if (strcmp(comp, "action") == 0 && act != MM_NULLACT) {
149                         INSERT_NEWLINE;
150                         strlcat(output, "TO FIX: ", size);
151                         strlcat(output, act, size);
152                 } else if (strcmp(comp, "tag") == 0 && tag != MM_NULLTAG) {
153                         INSERT_SPACE;
154                         strlcat(output, tag, size);
155                 }
156         }
157         INSERT_NEWLINE;
158         return (output);
159 }
160
161 /*
162  * Returns a component of a colon delimited string.  NULL is returned to
163  * indicate that there are no remaining components.  This function must be
164  * called until it returns NULL in order for the local state to be cleared.
165  */
166 static char *
167 nextcomp(const char *msgverb)
168 {
169         static char lmsgverb[MAX_MSGVERB], *state;
170         char *retval;
171         
172         if (*lmsgverb == '\0') {
173                 strlcpy(lmsgverb, msgverb, sizeof(lmsgverb));
174                 retval = strtok_r(lmsgverb, ":", &state);
175         } else {
176                 retval = strtok_r(NULL, ":", &state);
177         }
178         if (retval == NULL)
179                 *lmsgverb = '\0';
180         return (retval);
181 }
182
183 static const char *
184 sevinfo(int sev)
185 {
186
187         switch (sev) {
188         case MM_HALT:
189                 return ("HALT");
190         case MM_ERROR:
191                 return ("ERROR");
192         case MM_WARNING:
193                 return ("WARNING");
194         case MM_INFO:
195                 return ("INFO");
196         default:
197                 return (NULL);
198         }
199 }
200
201 /*
202  * Returns 1 if the msgverb list is valid, otherwise 0.
203  */
204 static int
205 validmsgverb(const char *msgverb)
206 {
207         char *msgcomp;
208         int i, equality;
209
210         equality = 0;
211         while ((msgcomp = nextcomp(msgverb)) != NULL) {
212                 equality--;
213                 for (i = 0; validlist[i] != NULL; i++) {
214                         if (strcmp(msgcomp, validlist[i]) == 0)
215                                 equality++;
216                 }
217         }
218         return (!equality);
219 }