lib/libc/gen/err.c

   1 /*-
   2  * Copyright (c) 1993
   3  *      The Regents of the University of California.  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  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #if defined(LIBC_SCCS) && !defined(lint)
  35 static char sccsid[] = "@(#)err.c       8.1 (Berkeley) 6/4/93";
  36 #endif /* LIBC_SCCS and not lint */
  37 #include <sys/cdefs.h>
  38 __FBSDID("$FreeBSD$");
  39
  40 #include "namespace.h"
  41 #include <err.h>
  42 #include <errno.h>
  43 #include <stdarg.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include "un-namespace.h"
  48
  49 #include "libc_private.h"
  50
  51 static FILE *err_file; /* file to use for error output */
  52 static void (*err_exit)(int);
  53
  54 /*
  55  * This is declared to take a `void *' so that the caller is not required
  56  * to include <stdio.h> first.  However, it is really a `FILE *', and the
  57  * manual page documents it as such.
  58  */
  59 void
  60 err_set_file(void *fp)
  61 {
  62         if (fp)
  63                 err_file = fp;
  64         else
  65                 err_file = stderr;
  66 }
  67
  68 void
  69 err_set_exit(void (*ef)(int))
  70 {
  71         err_exit = ef;
  72 }
  73
  74 __weak_reference(_err, err);
  75
  76 void
  77 _err(int eval, const char *fmt, ...)
  78 {
  79         va_list ap;
  80         va_start(ap, fmt);
  81         verrc(eval, errno, fmt, ap);
  82         va_end(ap);
  83 }
  84
  85 void
  86 verr(eval, fmt, ap)
  87         int eval;
  88         const char *fmt;
  89         va_list ap;
  90 {
  91         verrc(eval, errno, fmt, ap);
  92 }
  93
  94 void
  95 errc(int eval, int code, const char *fmt, ...)
  96 {
  97         va_list ap;
  98         va_start(ap, fmt);
  99         verrc(eval, code, fmt, ap);
 100         va_end(ap);
 101 }
 102
 103 void
 104 verrc(eval, code, fmt, ap)
 105         int eval;
 106         int code;
 107         const char *fmt;
 108         va_list ap;
 109 {
 110         if (err_file == 0)
 111                 err_set_file((FILE *)0);
 112         fprintf(err_file, "%s: ", _getprogname());
 113         if (fmt != NULL) {
 114                 vfprintf(err_file, fmt, ap);
 115                 fprintf(err_file, ": ");
 116         }
 117         fprintf(err_file, "%s\n", strerror(code));
 118         if (err_exit)
 119                 err_exit(eval);
 120         exit(eval);
 121 }
 122
 123 void
 124 errx(int eval, const char *fmt, ...)
 125 {
 126         va_list ap;
 127         va_start(ap, fmt);
 128         verrx(eval, fmt, ap);
 129         va_end(ap);
 130 }
 131
 132 void
 133 verrx(eval, fmt, ap)
 134         int eval;
 135         const char *fmt;
 136         va_list ap;
 137 {
 138         if (err_file == 0)
 139                 err_set_file((FILE *)0);
 140         fprintf(err_file, "%s: ", _getprogname());
 141         if (fmt != NULL)
 142                 vfprintf(err_file, fmt, ap);
 143         fprintf(err_file, "\n");
 144         if (err_exit)
 145                 err_exit(eval);
 146         exit(eval);
 147 }
 148
 149 __weak_reference(_warn, warn);
 150
 151 void
 152 _warn(const char *fmt, ...)
 153 {
 154         va_list ap;
 155         va_start(ap, fmt);
 156         vwarnc(errno, fmt, ap);
 157         va_end(ap);
 158 }
 159
 160 void
 161 vwarn(fmt, ap)
 162         const char *fmt;
 163         va_list ap;
 164 {
 165         vwarnc(errno, fmt, ap);
 166 }
 167
 168 void
 169 warnc(int code, const char *fmt, ...)
 170 {
 171         va_list ap;
 172         va_start(ap, fmt);
 173         vwarnc(code, fmt, ap);
 174         va_end(ap);
 175 }
 176
 177 void
 178 vwarnc(code, fmt, ap)
 179         int code;
 180         const char *fmt;
 181         va_list ap;
 182 {
 183         if (err_file == 0)
 184                 err_set_file((FILE *)0);
 185         fprintf(err_file, "%s: ", _getprogname());
 186         if (fmt != NULL) {
 187                 vfprintf(err_file, fmt, ap);
 188                 fprintf(err_file, ": ");
 189         }
 190         fprintf(err_file, "%s\n", strerror(code));
 191 }
 192
 193 void
 194 warnx(const char *fmt, ...)
 195 {
 196         va_list ap;
 197         va_start(ap, fmt);
 198         vwarnx(fmt, ap);
 199         va_end(ap);
 200 }
 201
 202 void
 203 vwarnx(fmt, ap)
 204         const char *fmt;
 205         va_list ap;
 206 {
 207         if (err_file == 0)
 208                 err_set_file((FILE *)0);
 209         fprintf(err_file, "%s: ", _getprogname());
 210         if (fmt != NULL)
 211                 vfprintf(err_file, fmt, ap);
 212         fprintf(err_file, "\n");
 213 }