also add -fwrapv to CFLAGS (addresses #698908)
[alioth/cvs.git] / src / error.c
1 /* error.c -- error handler for noninteractive utilities
2    Copyright (C) 1990-1992 Free Software Foundation, Inc.
3
4    This program is free software; you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation; either version 2, or (at your option)
7    any later version.
8
9    This program 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
12    GNU General Public License for more details.  */
13
14 /* David MacKenzie */
15 /* Brian Berliner added support for CVS */
16
17 #include "cvs.h"
18 #include "vasnprintf.h"
19
20 /* Out of memory errors which could not be forwarded to the client are sent to
21  * the syslog when it is available.
22  */
23 #ifdef HAVE_SYSLOG_H
24 # include <syslog.h>
25 # ifndef LOG_DAEMON   /* for ancient syslogs */
26 #   define LOG_DAEMON 0
27 # endif
28 #endif /* HAVE_SYSLOG_H */
29
30
31
32 /* If non-zero, error will use the CVS protocol to stdout to report error
33  * messages.  This will only be set in the CVS server parent process.
34  *
35  * Most other code is run via do_cvs_command, which forks off a child
36  * process and packages up its stderr in the protocol.
37  */
38 int error_use_protocol; 
39
40 #ifndef strerror
41 extern char *strerror (int);
42 #endif
43
44
45
46 /* Print the program name and error message MESSAGE, which is a printf-style
47  * format string with optional args, like:
48  *
49  *   PROGRAM_NAME CVS_CMD_NAME: MESSAGE: ERRNUM
50  *
51  * or, when STATUS is non-zero:
52  *
53  *   PROGRAM_NAME [CVS_CMD_NAME aborted]: MESSAGE: ERRNUM
54  *
55  * CVS_CMD_NAME & ERRMSG may or may not appear in the output (the `:' before
56  * ERRMSG will disappear as well when ERRNUM is not present).  ERRMSG
57  * represents the system dependent message returned by strerror (ERRNUM), when
58  * ERRNUM is non-zero.
59  *
60  * Exit with status EXIT_FAILURE if STATUS is nonzero.
61  *
62  * If this function fails to get any memory it might request, it attempts to
63  * log a "memory exhausted" message to the syslog, when syslog is available,
64  * without any further attempts to allocate memory, before exiting.  See NOTES
65  * below for more information on this functions memory allocation.
66  *
67  * INPUTS
68  *   status     When non-zero, exit with EXIT_FAILURE rather than returning.
69  *   errnum     When non-zero, interpret as global ERRNO for the purpose of
70  *              generating additional error text.
71  *   message    A printf style format string.
72  *   ...        Variable number of args, as printf.
73  *
74  * GLOBALS
75  *   program_name       The name of this executable, for the output message.
76  *   cvs_cmd_name       Output in the error message, when it exists.
77  *   errno              Accessed simply to save and restore it before
78  *                      returning.
79  *
80  * NOTES
81  *   This function goes to fairly great lengths to avoid allocating memory so
82  *   that it can relay out-of-memory error messages to the client.  Any error
83  *   messages which fit in under 256 characters (after expanding MESSAGE with
84  *   ARGS but before adding any ERRNUM text) should not require memory
85  *   allocation before they are sent on to cvs_outerr().  Unfortunately,
86  *   cvs_outerr() and the buffer functions it uses to send messages to the
87  *   client still don't make this same sort of effort, so in local mode
88  *   out-of-memory errors will probably get printed properly to stderr but if a
89  *   memory outage happens on the server, the admin will need to consult the
90  *   syslog to find out what went wrong.
91  *
92  *   I think this is largely cleaned up to the point where it does the right
93  *   thing for the server, whether the normal server_active (child process)
94  *   case or the error_use_protocol (parent process) case.  The one exception
95  *   is that STATUS nonzero for error_use_protocol probably doesn't work yet;
96  *   in that case still need to use the pending_error machinery in server.c.
97  *
98  *   error() does not molest errno; some code (e.g. Entries_Open) depends
99  *   on being able to say something like:
100  *
101  *      error (0, 0, "foo");
102  *      error (0, errno, "bar");
103  *
104  * RETURNS
105  *   Sometimes.  ;)
106  */
107 void
108 error (int status, int errnum, const char *message, ...)
109 {
110     va_list args;
111     int save_errno = errno;
112
113     /* Various buffers we attempt to use to generate the error message.  */
114     char statbuf[256];
115     char *buf;
116     size_t length;
117     char statbuf2[384];
118     char *buf2;
119     char statcmdbuf[32];
120     char *cmdbuf;
121     char *emptybuf = "";
122
123     static const char *last_message = NULL;
124     static int last_status;
125     static int last_errnum;
126
127     /* Initialize these to avoid a lot of special case error handling.  */
128     buf = statbuf;
129     buf2 = statbuf2;
130     cmdbuf = emptybuf;
131
132     /* Expand the message the user passed us.  */
133     length = sizeof (statbuf);
134     va_start (args, message);
135     buf = vasnprintf (statbuf, &length, message, args);
136     va_end (args);
137     if (!buf) goto memerror;
138
139     /* Expand the cvs commmand name to <cmd> or [<cmd> aborted].
140      *
141      * I could squeeze this into the buf2 printf below, but this makes the code
142      * easier to read and I don't think error messages are printed often enough
143      * to make this a major performance hit.  I think the memory cost is about
144      * 40 bytes.
145      */
146     if (cvs_cmd_name)
147     {
148         length = sizeof (statcmdbuf);
149         cmdbuf = asnprintf (statcmdbuf, &length, " %s%s%s",
150                             status ? "[" : "",
151                             cvs_cmd_name,
152                             status ? " aborted]" : "");
153         /* Else cmdbuf still = emptybuf.  */
154         if (!cmdbuf) goto memerror;
155     }
156     /* Else cmdbuf still = emptybuf.  */
157
158     /* Now put it all together.  */
159     length = sizeof (statbuf2);
160     buf2 = asnprintf (statbuf2, &length, "%s%s: %s%s%s\n",
161                       program_name, cmdbuf, buf,
162                       errnum ? ": " : "", errnum ? strerror (errnum) : "");
163     if (!buf2) goto memerror;
164
165     /* Send the final message to the client or log it.
166      *
167      * Set this recursion block first since this is the only function called
168      * here which can cause error() to be called a second time.
169      */
170     if (last_message) goto recursion_error;
171     last_message = buf2;
172     last_status = status;
173     last_errnum = errnum;
174     cvs_outerr (buf2, length);
175
176     /* Reset our recursion lock.  This needs to be done before the call to
177      * exit() to allow the exit handlers to make calls to error().
178      */
179     last_message = NULL;
180
181     /* Done, if we're exiting.  */
182     if (status)
183         exit (EXIT_FAILURE);
184
185     /* Free anything we may have allocated.  */
186     if (buf != statbuf) free (buf);
187     if (buf2 != statbuf2) free (buf2);
188     if (cmdbuf != statcmdbuf && cmdbuf != emptybuf) free (cmdbuf);
189
190     /* Restore errno per our charter.  */
191     errno = save_errno;
192
193     /* Done.  */
194     return;
195
196 memerror:
197     /* Make one last attempt to log the problem in the syslog since that
198      * should not require new memory, then abort.
199      *
200      * No second attempt is made to send the information to the client - if we
201      * got here then that already failed once and this prevents us from
202      * entering an infinite loop.
203      *
204      * FIXME
205      *   If the buffer routines can be altered in such a way that a single,
206      *   short, statically allocated message could be sent without needing to
207      *   allocate new memory, then it would still be safe to call cvs_outerr
208      *   with the message here.
209      */
210 #if HAVE_SYSLOG_H
211     syslog (LOG_DAEMON | LOG_CRIT, "Memory exhausted.  Aborting.");
212 #endif /* HAVE_SYSLOG_H */
213
214     goto sidestep_done;
215
216 recursion_error:
217 #if HAVE_SYSLOG_H
218     /* Syslog the problem since recursion probably means that we encountered an
219      * error while attempting to send the last error message to the client.
220      */
221
222     syslog (LOG_DAEMON | LOG_ALERT,
223             "error (%d, %d) called recursively.  Original message was:",
224             last_status, last_errnum);
225     syslog (LOG_DAEMON | LOG_ALERT, "%s", last_message);
226
227
228     syslog (LOG_DAEMON | LOG_ALERT,
229             "error (%d, %d) called recursively.  Second message was:",
230             status, errnum);
231     syslog (LOG_DAEMON | LOG_ALERT, "%s", buf2);
232
233     syslog (LOG_DAEMON | LOG_ALERT, "Aborting.");
234 #endif /* HAVE_SYSLOG_H */
235
236 sidestep_done:
237     /* Reset our recursion lock.  This needs to be done before the call to
238      * exit() to allow the exit handlers to make calls to error().
239      */
240     last_message = NULL;
241
242     exit (EXIT_FAILURE);
243 }
244
245
246
247 /* Print the program name and error message MESSAGE, which is a printf-style
248    format string with optional args to the file specified by FP.
249    If ERRNUM is nonzero, print its corresponding system error message.
250    Exit with status EXIT_FAILURE if STATUS is nonzero.  */
251 /* VARARGS */
252 void
253 fperrmsg (FILE *fp, int status, int errnum, char *message, ...)
254 {
255     va_list args;
256
257     fprintf (fp, "%s: ", program_name);
258     va_start (args, message);
259     vfprintf (fp, message, args);
260     va_end (args);
261     if (errnum)
262         fprintf (fp, ": %s", strerror (errnum));
263     putc ('\n', fp);
264     fflush (fp);
265     if (status)
266         exit (EXIT_FAILURE);
267 }