Return to fatal.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / common

sudo v 1.8.10p3

    1: /*
    2:  * Copyright (c) 2004-2005, 2010-2013 Todd C. Miller <Todd.Miller@courtesan.com>
    3:  *
    4:  * Permission to use, copy, modify, and distribute this software for any
    5:  * purpose with or without fee is hereby granted, provided that the above
    6:  * copyright notice and this permission notice appear in all copies.
    7:  *
    8:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    9:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   10:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   11:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   12:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   13:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   14:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   15:  */
   16: 
   17: #include <config.h>
   18: 
   19: #include <sys/types.h>
   20: 
   21: #include <errno.h>
   22: #include <stdio.h>
   23: #include <stdlib.h>
   24: #include <string.h>
   25: #ifdef HAVE_STDBOOL_H
   26: # include <stdbool.h>
   27: #else
   28: # include "compat/stdbool.h"
   29: #endif /* HAVE_STDBOOL_H */
   30: 
   31: #define DEFAULT_TEXT_DOMAIN	"sudo"
   32: #include "gettext.h"		/* must be included before missing.h */
   33: 
   34: #include "missing.h"
   35: #include "alloc.h"
   36: #include "fatal.h"
   37: #include "queue.h"
   38: #include "sudo_plugin.h"
   39: 
   40: struct sudo_fatal_callback {
   41:     SLIST_ENTRY(sudo_fatal_callback) entries;
   42:     void (*func)(void);
   43: };
   44: SLIST_HEAD(sudo_fatal_callback_list, sudo_fatal_callback);
   45: 
   46: sigjmp_buf fatal_jmp;
   47: static bool setjmp_enabled = false;
   48: static struct sudo_fatal_callback_list callbacks;
   49: 
   50: static void _warning(int, const char *, va_list);
   51: 
   52: static void
   53: do_cleanup(void)
   54: {
   55:     struct sudo_fatal_callback *cb;
   56: 
   57:     /* Run callbacks, removing them from the list as we go. */
   58:     while ((cb = SLIST_FIRST(&callbacks)) != NULL) {
   59: 	SLIST_REMOVE_HEAD(&callbacks, entries);
   60: 	cb->func();
   61: 	free(cb);
   62:     }
   63: }
   64: 
   65: void
   66: fatal_nodebug(const char *fmt, ...)
   67: {
   68:     va_list ap;
   69: 
   70:     va_start(ap, fmt);
   71:     _warning(1, fmt, ap);
   72:     va_end(ap);
   73:     do_cleanup();
   74:     if (setjmp_enabled)
   75: 	siglongjmp(fatal_jmp, 1);
   76:     else
   77: 	exit(EXIT_FAILURE);
   78: }
   79: 
   80: void
   81: fatalx_nodebug(const char *fmt, ...)
   82: {
   83:     va_list ap;
   84: 
   85:     va_start(ap, fmt);
   86:     _warning(0, fmt, ap);
   87:     va_end(ap);
   88:     do_cleanup();
   89:     if (setjmp_enabled)
   90: 	siglongjmp(fatal_jmp, 1);
   91:     else
   92: 	exit(EXIT_FAILURE);
   93: }
   94: 
   95: void
   96: vfatal_nodebug(const char *fmt, va_list ap)
   97: {
   98:     _warning(1, fmt, ap);
   99:     do_cleanup();
  100:     if (setjmp_enabled)
  101: 	siglongjmp(fatal_jmp, 1);
  102:     else
  103: 	exit(EXIT_FAILURE);
  104: }
  105: 
  106: void
  107: vfatalx_nodebug(const char *fmt, va_list ap)
  108: {
  109:     _warning(0, fmt, ap);
  110:     do_cleanup();
  111:     if (setjmp_enabled)
  112: 	siglongjmp(fatal_jmp, 1);
  113:     else
  114: 	exit(EXIT_FAILURE);
  115: }
  116: 
  117: void
  118: warning_nodebug(const char *fmt, ...)
  119: {
  120:     va_list ap;
  121: 
  122:     va_start(ap, fmt);
  123:     _warning(1, fmt, ap);
  124:     va_end(ap);
  125: }
  126: 
  127: void
  128: warningx_nodebug(const char *fmt, ...)
  129: {
  130:     va_list ap;
  131:     va_start(ap, fmt);
  132:     _warning(0, fmt, ap);
  133:     va_end(ap);
  134: }
  135: 
  136: void
  137: vwarning_nodebug(const char *fmt, va_list ap)
  138: {
  139:     _warning(1, fmt, ap);
  140: }
  141: 
  142: void
  143: vwarningx_nodebug(const char *fmt, va_list ap)
  144: {
  145:     _warning(0, fmt, ap);
  146: }
  147: 
  148: static void
  149: _warning(int use_errno, const char *fmt, va_list ap)
  150: {
  151:     int serrno = errno;
  152:     char *str;
  153: 
  154:     evasprintf(&str, fmt, ap);
  155:     if (use_errno) {
  156: 	if (fmt != NULL) {
  157: 	    sudo_printf(SUDO_CONV_ERROR_MSG,
  158: 		_("%s: %s: %s\n"), getprogname(), str, strerror(serrno));
  159: 	} else {
  160: 	    sudo_printf(SUDO_CONV_ERROR_MSG,
  161: 		_("%s: %s\n"), getprogname(), strerror(serrno));
  162: 	}
  163:     } else {
  164: 	sudo_printf(SUDO_CONV_ERROR_MSG,
  165: 	    _("%s: %s\n"), getprogname(), str ? str : "(null)");
  166:     }
  167:     efree(str);
  168:     errno = serrno;
  169: }
  170: 
  171: int
  172: fatal_callback_register(void (*func)(void))
  173: {
  174:     struct sudo_fatal_callback *cb;
  175: 
  176:     cb = malloc(sizeof(*cb));
  177:     if (cb == NULL)
  178: 	return -1;
  179:     cb->func = func;
  180:     SLIST_INSERT_HEAD(&callbacks, cb, entries);
  181: 
  182:     return 0;
  183: }
  184: 
  185: void
  186: fatal_disable_setjmp(void)
  187: {
  188:     setjmp_enabled = false;
  189: }
  190: 
  191: void
  192: fatal_enable_setjmp(void)
  193: {
  194:     setjmp_enabled = true;
  195: }