2 * Copyright (c) 2000-2002 Sendmail, Inc. and its suppliers.
5 * By using this file, you agree to the terms and conditions set
6 * forth in the LICENSE file which can be found at the top level of
7 * the sendmail distribution.
12 SM_RCSID("@(#)$Id: exc.c,v 1.49 2006/12/19 19:28:09 ca Exp $")
16 ** For documentation, see exc.html
22 #include <sm/errstring.h>
25 #include <sm/string.h>
26 #include <sm/varargs.h>
29 const char SmExcMagic[] = "sm_exc";
30 const char SmExcTypeMagic[] = "sm_exc_type";
33 ** SM_ETYPE_PRINTF -- printf for exception types.
37 ** stream -- file for output.
44 ** A simple formatted print function that can be used as the print function
45 ** by most exception types. It prints the printcontext string, interpreting
46 ** occurrences of %0 through %9 as references to the argument vector.
47 ** If exception argument 3 is an int or long, then %3 will print the
48 ** argument in decimal, and %o3 or %x3 will print it in octal or hex.
52 sm_etype_printf(exc, stream)
56 size_t n = strlen(exc->exc_type->etype_argformat);
60 for (p = exc->exc_type->etype_printcontext; *p != '\0'; ++p)
64 (void) sm_io_putc(stream, SM_TIME_DEFAULT, *p);
70 (void) sm_io_putc(stream, SM_TIME_DEFAULT, '%');
75 (void) sm_io_putc(stream, SM_TIME_DEFAULT, '%');
84 (void) sm_io_putc(stream, SM_TIME_DEFAULT, '%');
85 (void) sm_io_putc(stream, SM_TIME_DEFAULT,
95 switch (exc->exc_type->etype_argformat[i])
99 s = exc->exc_argv[i].v_str;
102 sm_io_fputs(stream, SM_TIME_DEFAULT, s);
105 sm_io_fprintf(stream,
108 : format == 'x' ? "%x"
110 exc->exc_argv[i].v_int);
113 sm_io_fprintf(stream,
115 format == 'o' ? "%lo"
116 : format == 'x' ? "%lx"
118 exc->exc_argv[i].v_long);
121 sm_exc_write(exc->exc_argv[i].v_exc,
127 (void) sm_io_putc(stream, SM_TIME_DEFAULT, '%');
129 (void) sm_io_putc(stream, SM_TIME_DEFAULT, format);
130 (void) sm_io_putc(stream, SM_TIME_DEFAULT, *p);
135 ** Standard exception types.
139 ** SM_ETYPE_OS_PRINT -- Print OS related exception.
143 ** stream -- file for output.
150 sm_etype_os_print __P((
155 sm_etype_os_print(exc, stream)
159 int err = exc->exc_argv[0].v_int;
160 char *syscall = exc->exc_argv[1].v_str;
161 char *sysargs = exc->exc_argv[2].v_str;
164 sm_io_fprintf(stream, SM_TIME_DEFAULT, "%s: %s failed: %s",
165 sysargs, syscall, sm_errstring(err));
167 sm_io_fprintf(stream, SM_TIME_DEFAULT, "%s failed: %s", syscall,
172 ** SmEtypeOs represents the failure of a Unix system call.
173 ** The three arguments are:
174 ** int errno (eg, ENOENT)
175 ** char *syscall (eg, "open")
176 ** char *sysargs (eg, NULL or "/etc/mail/sendmail.cf")
179 const SM_EXC_TYPE_T SmEtypeOs =
189 ** SmEtypeErr is a completely generic error which should only be
190 ** used in applications and test programs. Libraries should use
191 ** more specific exception codes.
194 const SM_EXC_TYPE_T SmEtypeErr =
204 ** SM_EXC_VNEW_X -- Construct a new exception object.
207 ** etype -- type of exception.
211 ** pointer to exception object.
215 ** This is an auxiliary function called by sm_exc_new_x and sm_exc_raisenew_x.
217 ** If an exception is raised, then to avoid a storage leak, we must:
218 ** (a) Free all storage we have allocated.
219 ** (b) Free all exception arguments in the varargs list.
220 ** Getting this right is tricky.
222 ** To see why (b) is required, consider the code fragment
223 ** SM_EXCEPT(exc, "*")
224 ** sm_exc_raisenew_x(&MyEtype, exc);
226 ** In the normal case, sm_exc_raisenew_x will allocate and raise a new
227 ** exception E that owns exc. When E is eventually freed, exc is also freed.
228 ** In the exceptional case, sm_exc_raisenew_x must free exc before raising
229 ** an out-of-memory exception so that exc is not leaked.
232 static SM_EXC_T *sm_exc_vnew_x __P((const SM_EXC_TYPE_T *, va_list SM_NONVOLATILE));
235 sm_exc_vnew_x(etype, ap)
236 const SM_EXC_TYPE_T *etype;
237 va_list SM_NONVOLATILE ap;
240 ** All variables that are modified in the SM_TRY clause and
241 ** referenced in the SM_EXCEPT clause must be declared volatile.
244 /* NOTE: Type of si, i, and argc *must* match */
245 SM_EXC_T * volatile exc = NULL;
247 SM_VAL_T * volatile argv = NULL;
250 SM_REQUIRE_ISA(etype, SmExcTypeMagic);
251 argc = strlen(etype->etype_argformat);
255 ** Step 1. Allocate the exception structure.
256 ** On failure, scan the varargs list and free all
257 ** exception arguments.
260 exc = sm_malloc_x(sizeof(SM_EXC_T));
261 exc->sm_magic = SmExcMagic;
262 exc->exc_refcount = 1;
263 exc->exc_type = etype;
264 exc->exc_argv = NULL;
267 ** Step 2. Allocate the argument vector.
268 ** On failure, free exc, scan the varargs list and free all
269 ** exception arguments. On success, scan the varargs list,
270 ** and copy the arguments into argv.
273 argv = sm_malloc_x(argc * sizeof(SM_VAL_T));
274 exc->exc_argv = argv;
275 for (i = 0; i < argc; ++i)
277 switch (etype->etype_argformat[i])
280 argv[i].v_int = SM_VA_ARG(ap, int);
283 argv[i].v_long = SM_VA_ARG(ap, long);
286 argv[i].v_exc = SM_VA_ARG(ap, SM_EXC_T*);
289 argv[i].v_str = SM_VA_ARG(ap, char*);
292 SM_REQUIRE(etype->etype_argformat[i+1] == '\0');
293 argv[i].v_str = SM_VA_ARG(ap, char*);
296 sm_abort("sm_exc_vnew_x: bad argformat '%c'",
297 etype->etype_argformat[i]);
302 ** Step 3. Scan argv, and allocate space for all
303 ** string arguments. si is the number of elements
304 ** of argv that have been processed so far.
305 ** On failure, free exc, argv, all the exception arguments
306 ** and all of the strings that have been copied.
309 for (si = 0; si < argc; ++si)
311 switch (etype->etype_argformat[si])
315 char *str = argv[si].v_str;
317 argv[si].v_str = sm_strdup_x(str);
322 char *fmt = argv[si].v_str;
324 argv[si].v_str = sm_vstringf_x(fmt, ap);
332 if (exc == NULL || argv == NULL)
335 ** Failure in step 1 or step 2.
336 ** Scan ap and free all exception arguments.
339 for (i = 0; i < argc; ++i)
341 switch (etype->etype_argformat[i])
344 (void) SM_VA_ARG(ap, int);
347 (void) SM_VA_ARG(ap, long);
350 sm_exc_free(SM_VA_ARG(ap, SM_EXC_T*));
354 (void) SM_VA_ARG(ap, char*);
362 ** Failure in step 3. Scan argv and free
363 ** all exception arguments and all string
364 ** arguments that have been duplicated.
368 for (i = 0; i < argc; ++i)
370 switch (etype->etype_argformat[i])
373 sm_exc_free(argv[i].v_exc);
378 sm_free(argv[i].v_str);
393 ** SM_EXC_NEW_X -- Construct a new exception object.
396 ** etype -- type of exception.
400 ** pointer to exception object.
406 const SM_EXC_TYPE_T *etype,
408 #else /* SM_VA_STD */
409 sm_exc_new_x(etype, va_alist)
410 const SM_EXC_TYPE_T *etype;
412 #endif /* SM_VA_STD */
417 SM_VA_START(ap, etype);
418 exc = sm_exc_vnew_x(etype, ap);
424 ** SM_EXC_FREE -- Destroy a reference to an exception object.
427 ** exc -- exception object.
439 SM_REQUIRE(exc->sm_magic == SmExcMagic);
440 if (exc->exc_refcount == 0)
442 if (--exc->exc_refcount == 0)
446 for (i = 0; (c = exc->exc_type->etype_argformat[i]) != '\0';
453 sm_free(exc->exc_argv[i].v_str);
456 sm_exc_free(exc->exc_argv[i].v_exc);
460 exc->sm_magic = NULL;
461 sm_free(exc->exc_argv);
467 ** SM_EXC_MATCH -- Match exception category against a glob pattern.
471 ** pattern -- glob pattern.
478 sm_exc_match(exc, pattern)
484 SM_REQUIRE(exc->sm_magic == SmExcMagic);
485 return sm_match(exc->exc_type->etype_category, pattern);
489 ** SM_EXC_WRITE -- Write exception message to a stream (wo trailing newline).
493 ** stream -- file for output.
500 sm_exc_write(exc, stream)
504 SM_REQUIRE_ISA(exc, SmExcMagic);
505 exc->exc_type->etype_print(exc, stream);
509 ** SM_EXC_PRINT -- Print exception message to a stream (with trailing newline).
513 ** stream -- file for output.
520 sm_exc_print(exc, stream)
524 SM_REQUIRE_ISA(exc, SmExcMagic);
525 exc->exc_type->etype_print(exc, stream);
526 (void) sm_io_putc(stream, SM_TIME_DEFAULT, '\n');
529 SM_EXC_HANDLER_T *SmExcHandler = NULL;
530 static SM_EXC_DEFAULT_HANDLER_T SmExcDefaultHandler = NULL;
533 ** SM_EXC_NEWTHREAD -- Initialize exception handling for new process/thread.
536 ** h -- default exception handler.
543 ** Initialize a new process or a new thread by clearing the
544 ** exception handler stack and optionally setting a default
545 ** exception handler function. Call this at the beginning of main,
546 ** or in a new process after calling fork, or in a new thread.
548 ** This function is a luxury, not a necessity.
549 ** If h != NULL then you can get the same effect by
550 ** wrapping the body of main, or the body of a forked child
551 ** or a new thread in SM_TRY ... SM_EXCEPT(e,"*") h(e); SM_END_TRY.
556 SM_EXC_DEFAULT_HANDLER_T h;
559 SmExcDefaultHandler = h;
563 ** SM_EXC_RAISE_X -- Raise an exception.
576 SM_REQUIRE_ISA(exc, SmExcMagic);
578 if (SmExcHandler == NULL)
580 if (SmExcDefaultHandler != NULL)
582 SM_EXC_DEFAULT_HANDLER_T h;
585 ** If defined, the default handler is expected
586 ** to terminate the current thread of execution
587 ** using exit() or pthread_exit().
588 ** If it instead returns normally, then we fall
589 ** through to the default case below. If it
590 ** raises an exception, then sm_exc_raise_x is
591 ** re-entered and, because we set SmExcDefaultHandler
592 ** to NULL before invoking h, we will again
593 ** end up in the default case below.
596 h = SmExcDefaultHandler;
597 SmExcDefaultHandler = NULL;
602 ** No exception handler, so print the error and exit.
603 ** To override this behaviour on a program wide basis,
604 ** call sm_exc_newthread or put an exception handler in main().
606 ** XXX TODO: map the exception category to an exit code
607 ** XXX from <sysexits.h>.
610 sm_exc_print(exc, smioerr);
614 if (SmExcHandler->eh_value == NULL)
615 SmExcHandler->eh_value = exc;
619 sm_longjmp_nosig(SmExcHandler->eh_context, 1);
623 ** SM_EXC_RAISENEW_X -- shorthand for sm_exc_raise_x(sm_exc_new_x(...))
626 ** etype -- type of exception.
636 const SM_EXC_TYPE_T *etype,
639 sm_exc_raisenew_x(etype, va_alist)
640 const SM_EXC_TYPE_T *etype;
647 SM_VA_START(ap, etype);
648 exc = sm_exc_vnew_x(etype, ap);