]>
Commit | Line | Data |
---|---|---|
1 | /* error.c -- Functions for handling errors. */ | |
2 | ||
3 | /* Copyright (C) 1993-2009 Free Software Foundation, Inc. | |
4 | ||
5 | This file is part of GNU Bash, the Bourne Again SHell. | |
6 | ||
7 | Bash is free software: you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation, either version 3 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | Bash is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with Bash. If not, see <http://www.gnu.org/licenses/>. | |
19 | */ | |
20 | ||
21 | #include "config.h" | |
22 | ||
23 | #include "bashtypes.h" | |
24 | #include <fcntl.h> | |
25 | ||
26 | #if defined (HAVE_UNISTD_H) | |
27 | # include <unistd.h> | |
28 | #endif | |
29 | ||
30 | #if defined (PREFER_STDARG) | |
31 | # include <stdarg.h> | |
32 | #else | |
33 | # include <varargs.h> | |
34 | #endif | |
35 | ||
36 | #include <stdio.h> | |
37 | ||
38 | #include <errno.h> | |
39 | #if !defined (errno) | |
40 | extern int errno; | |
41 | #endif /* !errno */ | |
42 | ||
43 | #include "bashansi.h" | |
44 | #include "bashintl.h" | |
45 | ||
46 | #include "shell.h" | |
47 | #include "flags.h" | |
48 | #include "input.h" | |
49 | ||
50 | #if defined (HISTORY) | |
51 | # include "bashhist.h" | |
52 | #endif | |
53 | ||
54 | extern int executing_line_number __P((void)); | |
55 | ||
56 | extern int last_command_exit_value; | |
57 | extern char *shell_name; | |
58 | #if defined (JOB_CONTROL) | |
59 | extern pid_t shell_pgrp; | |
60 | extern int give_terminal_to __P((pid_t, int)); | |
61 | #endif /* JOB_CONTROL */ | |
62 | ||
63 | #if defined (ARRAY_VARS) | |
64 | extern const char * const bash_badsub_errmsg; | |
65 | #endif | |
66 | ||
67 | static void error_prolog __P((int)); | |
68 | ||
69 | /* The current maintainer of the shell. You change this in the | |
70 | Makefile. */ | |
71 | #if !defined (MAINTAINER) | |
72 | #define MAINTAINER "bash-maintainers@gnu.org" | |
73 | #endif | |
74 | ||
75 | const char * const the_current_maintainer = MAINTAINER; | |
76 | ||
77 | int gnu_error_format = 0; | |
78 | ||
79 | static void | |
80 | error_prolog (print_lineno) | |
81 | int print_lineno; | |
82 | { | |
83 | char *ename; | |
84 | int line; | |
85 | ||
86 | ename = get_name_for_error (); | |
87 | line = (print_lineno && interactive_shell == 0) ? executing_line_number () : -1; | |
88 | ||
89 | if (line > 0) | |
90 | fprintf (stderr, "%s:%s%d: ", ename, gnu_error_format ? "" : _(" line "), line); | |
91 | else | |
92 | fprintf (stderr, "%s: ", ename); | |
93 | } | |
94 | ||
95 | /* Return the name of the shell or the shell script for error reporting. */ | |
96 | char * | |
97 | get_name_for_error () | |
98 | { | |
99 | char *name; | |
100 | #if defined (ARRAY_VARS) | |
101 | SHELL_VAR *bash_source_v; | |
102 | ARRAY *bash_source_a; | |
103 | #endif | |
104 | ||
105 | name = (char *)NULL; | |
106 | if (interactive_shell == 0) | |
107 | { | |
108 | #if defined (ARRAY_VARS) | |
109 | bash_source_v = find_variable ("BASH_SOURCE"); | |
110 | if (bash_source_v && array_p (bash_source_v) && | |
111 | (bash_source_a = array_cell (bash_source_v))) | |
112 | name = array_reference (bash_source_a, 0); | |
113 | if (name == 0 || *name == '\0') /* XXX - was just name == 0 */ | |
114 | #endif | |
115 | name = dollar_vars[0]; | |
116 | } | |
117 | if (name == 0 && shell_name && *shell_name) | |
118 | name = base_pathname (shell_name); | |
119 | if (name == 0) | |
120 | #if defined (PROGRAM) | |
121 | name = PROGRAM; | |
122 | #else | |
123 | name = "bash"; | |
124 | #endif | |
125 | ||
126 | return (name); | |
127 | } | |
128 | ||
129 | /* Report an error having to do with FILENAME. This does not use | |
130 | sys_error so the filename is not interpreted as a printf-style | |
131 | format string. */ | |
132 | void | |
133 | file_error (filename) | |
134 | const char *filename; | |
135 | { | |
136 | report_error ("%s: %s", filename, strerror (errno)); | |
137 | } | |
138 | ||
139 | void | |
140 | #if defined (PREFER_STDARG) | |
141 | programming_error (const char *format, ...) | |
142 | #else | |
143 | programming_error (format, va_alist) | |
144 | const char *format; | |
145 | va_dcl | |
146 | #endif | |
147 | { | |
148 | va_list args; | |
149 | char *h; | |
150 | ||
151 | #if defined (JOB_CONTROL) | |
152 | give_terminal_to (shell_pgrp, 0); | |
153 | #endif /* JOB_CONTROL */ | |
154 | ||
155 | SH_VA_START (args, format); | |
156 | ||
157 | vfprintf (stderr, format, args); | |
158 | fprintf (stderr, "\n"); | |
159 | va_end (args); | |
160 | ||
161 | #if defined (HISTORY) | |
162 | if (remember_on_history) | |
163 | { | |
164 | h = last_history_line (); | |
165 | fprintf (stderr, _("last command: %s\n"), h ? h : "(null)"); | |
166 | } | |
167 | #endif | |
168 | ||
169 | #if 0 | |
170 | fprintf (stderr, "Report this to %s\n", the_current_maintainer); | |
171 | #endif | |
172 | ||
173 | fprintf (stderr, _("Aborting...")); | |
174 | fflush (stderr); | |
175 | ||
176 | abort (); | |
177 | } | |
178 | ||
179 | /* Print an error message and, if `set -e' has been executed, exit the | |
180 | shell. Used in this file by file_error and programming_error. Used | |
181 | outside this file mostly to report substitution and expansion errors, | |
182 | and for bad invocation options. */ | |
183 | void | |
184 | #if defined (PREFER_STDARG) | |
185 | report_error (const char *format, ...) | |
186 | #else | |
187 | report_error (format, va_alist) | |
188 | const char *format; | |
189 | va_dcl | |
190 | #endif | |
191 | { | |
192 | va_list args; | |
193 | ||
194 | error_prolog (1); | |
195 | ||
196 | SH_VA_START (args, format); | |
197 | ||
198 | vfprintf (stderr, format, args); | |
199 | fprintf (stderr, "\n"); | |
200 | ||
201 | va_end (args); | |
202 | if (exit_immediately_on_error) | |
203 | { | |
204 | if (last_command_exit_value == 0) | |
205 | last_command_exit_value = 1; | |
206 | exit_shell (last_command_exit_value); | |
207 | } | |
208 | } | |
209 | ||
210 | void | |
211 | #if defined (PREFER_STDARG) | |
212 | fatal_error (const char *format, ...) | |
213 | #else | |
214 | fatal_error (format, va_alist) | |
215 | const char *format; | |
216 | va_dcl | |
217 | #endif | |
218 | { | |
219 | va_list args; | |
220 | ||
221 | error_prolog (0); | |
222 | ||
223 | SH_VA_START (args, format); | |
224 | ||
225 | vfprintf (stderr, format, args); | |
226 | fprintf (stderr, "\n"); | |
227 | ||
228 | va_end (args); | |
229 | sh_exit (2); | |
230 | } | |
231 | ||
232 | void | |
233 | #if defined (PREFER_STDARG) | |
234 | internal_error (const char *format, ...) | |
235 | #else | |
236 | internal_error (format, va_alist) | |
237 | const char *format; | |
238 | va_dcl | |
239 | #endif | |
240 | { | |
241 | va_list args; | |
242 | ||
243 | error_prolog (1); | |
244 | ||
245 | SH_VA_START (args, format); | |
246 | ||
247 | vfprintf (stderr, format, args); | |
248 | fprintf (stderr, "\n"); | |
249 | ||
250 | va_end (args); | |
251 | } | |
252 | ||
253 | void | |
254 | #if defined (PREFER_STDARG) | |
255 | internal_warning (const char *format, ...) | |
256 | #else | |
257 | internal_warning (format, va_alist) | |
258 | const char *format; | |
259 | va_dcl | |
260 | #endif | |
261 | { | |
262 | va_list args; | |
263 | ||
264 | error_prolog (1); | |
265 | fprintf (stderr, _("warning: ")); | |
266 | ||
267 | SH_VA_START (args, format); | |
268 | ||
269 | vfprintf (stderr, format, args); | |
270 | fprintf (stderr, "\n"); | |
271 | ||
272 | va_end (args); | |
273 | } | |
274 | ||
275 | void | |
276 | #if defined (PREFER_STDARG) | |
277 | sys_error (const char *format, ...) | |
278 | #else | |
279 | sys_error (format, va_alist) | |
280 | const char *format; | |
281 | va_dcl | |
282 | #endif | |
283 | { | |
284 | int e; | |
285 | va_list args; | |
286 | ||
287 | e = errno; | |
288 | error_prolog (0); | |
289 | ||
290 | SH_VA_START (args, format); | |
291 | ||
292 | vfprintf (stderr, format, args); | |
293 | fprintf (stderr, ": %s\n", strerror (e)); | |
294 | ||
295 | va_end (args); | |
296 | } | |
297 | ||
298 | /* An error from the parser takes the general form | |
299 | ||
300 | shell_name: input file name: line number: message | |
301 | ||
302 | The input file name and line number are omitted if the shell is | |
303 | currently interactive. If the shell is not currently interactive, | |
304 | the input file name is inserted only if it is different from the | |
305 | shell name. */ | |
306 | void | |
307 | #if defined (PREFER_STDARG) | |
308 | parser_error (int lineno, const char *format, ...) | |
309 | #else | |
310 | parser_error (lineno, format, va_alist) | |
311 | int lineno; | |
312 | const char *format; | |
313 | va_dcl | |
314 | #endif | |
315 | { | |
316 | va_list args; | |
317 | char *ename, *iname; | |
318 | ||
319 | ename = get_name_for_error (); | |
320 | iname = yy_input_name (); | |
321 | ||
322 | if (interactive) | |
323 | fprintf (stderr, "%s: ", ename); | |
324 | else if (interactive_shell) | |
325 | fprintf (stderr, "%s: %s:%s%d: ", ename, iname, gnu_error_format ? "" : _(" line "), lineno); | |
326 | else if (STREQ (ename, iname)) | |
327 | fprintf (stderr, "%s:%s%d: ", ename, gnu_error_format ? "" : _(" line "), lineno); | |
328 | else | |
329 | fprintf (stderr, "%s: %s:%s%d: ", ename, iname, gnu_error_format ? "" : _(" line "), lineno); | |
330 | ||
331 | SH_VA_START (args, format); | |
332 | ||
333 | vfprintf (stderr, format, args); | |
334 | fprintf (stderr, "\n"); | |
335 | ||
336 | va_end (args); | |
337 | ||
338 | if (exit_immediately_on_error) | |
339 | exit_shell (last_command_exit_value = 2); | |
340 | } | |
341 | ||
342 | #ifdef DEBUG | |
343 | /* This assumes ASCII and is suitable only for debugging */ | |
344 | char * | |
345 | strescape (str) | |
346 | const char *str; | |
347 | { | |
348 | char *r, *result; | |
349 | unsigned char *s; | |
350 | ||
351 | r = result = (char *)xmalloc (strlen (str) * 2 + 1); | |
352 | ||
353 | for (s = (unsigned char *)str; s && *s; s++) | |
354 | { | |
355 | if (*s < ' ') | |
356 | { | |
357 | *r++ = '^'; | |
358 | *r++ = *s+64; | |
359 | } | |
360 | else if (*s == 127) | |
361 | { | |
362 | *r++ = '^'; | |
363 | *r++ = '?'; | |
364 | } | |
365 | else | |
366 | *r++ = *s; | |
367 | } | |
368 | ||
369 | *r = '\0'; | |
370 | return result; | |
371 | } | |
372 | ||
373 | void | |
374 | #if defined (PREFER_STDARG) | |
375 | itrace (const char *format, ...) | |
376 | #else | |
377 | itrace (format, va_alist) | |
378 | const char *format; | |
379 | va_dcl | |
380 | #endif | |
381 | { | |
382 | va_list args; | |
383 | ||
384 | fprintf(stderr, "TRACE: pid %ld: ", (long)getpid()); | |
385 | ||
386 | SH_VA_START (args, format); | |
387 | ||
388 | vfprintf (stderr, format, args); | |
389 | fprintf (stderr, "\n"); | |
390 | ||
391 | va_end (args); | |
392 | ||
393 | fflush(stderr); | |
394 | } | |
395 | ||
396 | /* A trace function for silent debugging -- doesn't require a control | |
397 | terminal. */ | |
398 | void | |
399 | #if defined (PREFER_STDARG) | |
400 | trace (const char *format, ...) | |
401 | #else | |
402 | trace (format, va_alist) | |
403 | const char *format; | |
404 | va_dcl | |
405 | #endif | |
406 | { | |
407 | va_list args; | |
408 | static FILE *tracefp = (FILE *)NULL; | |
409 | ||
410 | if (tracefp == NULL) | |
411 | tracefp = fopen("/tmp/bash-trace.log", "a+"); | |
412 | ||
413 | if (tracefp == NULL) | |
414 | tracefp = stderr; | |
415 | else | |
416 | fcntl (fileno (tracefp), F_SETFD, 1); /* close-on-exec */ | |
417 | ||
418 | fprintf(tracefp, "TRACE: pid %ld: ", (long)getpid()); | |
419 | ||
420 | SH_VA_START (args, format); | |
421 | ||
422 | vfprintf (tracefp, format, args); | |
423 | fprintf (tracefp, "\n"); | |
424 | ||
425 | va_end (args); | |
426 | ||
427 | fflush(tracefp); | |
428 | } | |
429 | ||
430 | #endif /* DEBUG */ | |
431 | ||
432 | /* **************************************************************** */ | |
433 | /* */ | |
434 | /* Common error reporting */ | |
435 | /* */ | |
436 | /* **************************************************************** */ | |
437 | ||
438 | ||
439 | static const char * const cmd_error_table[] = { | |
440 | N_("unknown command error"), /* CMDERR_DEFAULT */ | |
441 | N_("bad command type"), /* CMDERR_BADTYPE */ | |
442 | N_("bad connector"), /* CMDERR_BADCONN */ | |
443 | N_("bad jump"), /* CMDERR_BADJUMP */ | |
444 | 0 | |
445 | }; | |
446 | ||
447 | void | |
448 | command_error (func, code, e, flags) | |
449 | const char *func; | |
450 | int code, e, flags; /* flags currently unused */ | |
451 | { | |
452 | if (code > CMDERR_LAST) | |
453 | code = CMDERR_DEFAULT; | |
454 | ||
455 | programming_error ("%s: %s: %d", func, _(cmd_error_table[code]), e); | |
456 | } | |
457 | ||
458 | char * | |
459 | command_errstr (code) | |
460 | int code; | |
461 | { | |
462 | if (code > CMDERR_LAST) | |
463 | code = CMDERR_DEFAULT; | |
464 | ||
465 | return (_(cmd_error_table[code])); | |
466 | } | |
467 | ||
468 | #ifdef ARRAY_VARS | |
469 | void | |
470 | err_badarraysub (s) | |
471 | const char *s; | |
472 | { | |
473 | report_error ("%s: %s", s, _(bash_badsub_errmsg)); | |
474 | } | |
475 | #endif | |
476 | ||
477 | void | |
478 | err_unboundvar (s) | |
479 | const char *s; | |
480 | { | |
481 | report_error (_("%s: unbound variable"), s); | |
482 | } | |
483 | ||
484 | void | |
485 | err_readonly (s) | |
486 | const char *s; | |
487 | { | |
488 | report_error (_("%s: readonly variable"), s); | |
489 | } |