compat/lib/compaterr.c

   1 /*
   2  *      Ported to Linux's Second Extended File System as part of the
   3  *      dump and restore backup suit
   4  *      Remy Card <card@Linux.EU.Org>, 1994-1997
   5  *      Stelian Pop <pop@cybercable.fr>, 1999
   6  *
   7  */
   8
   9 /*-
  10  * Copyright (c) 1993
  11  *      The Regents of the University of California.  All rights reserved.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. All advertising materials mentioning features or use of this software
  22  *    must display the following acknowledgement:
  23  *      This product includes software developed by the University of
  24  *      California, Berkeley and its contributors.
  25  * 4. Neither the name of the University nor the names of its contributors
  26  *    may be used to endorse or promote products derived from this software
  27  *    without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  30  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  33  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  37  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  38  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  39  * SUCH DAMAGE.
  40  *
  41  * $Id: compaterr.c,v 1.3 1999/10/11 13:31:10 stelian Exp $
  42  */
  43
  44 #include <compaterr.h>
  45 #include <errno.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49
  50 #include <stdarg.h>
  51
  52 #include <config.h>
  53
  54 extern char *__progname;                /* Program name, from crt0. */
  55
  56 #if !defined(HAVE_ERR) || !defined(HAVE_ERRX) || !defined(HAVE_VERR) || !defined(HAVE_VERRX) || !defined(HAVE_VWARN) || !defined(HAVE_VWARNX) || !defined(HAVE_WARN) || !defined(HAVE_WARNX)
  57
  58 __BEGIN_DECLS
  59 __dead void     errc __P((int, int, const char *, ...));
  60 __dead void     verrc __P((int, int, const char *, _BSD_VA_LIST_));
  61 void            warnc __P((int, const char *, ...));
  62 void            vwarnc __P((int, const char *, _BSD_VA_LIST_));
  63 void            err_set_file __P((void *));
  64 void            err_set_exit __P((void (*)(int)));
  65 __END_DECLS
  66
  67 static void (*err_exit)(int);
  68
  69 static FILE *err_file; /* file to use for error output */
  70 /*
  71  * This is declared to take a `void *' so that the caller is not required
  72  * to include <stdio.h> first.  However, it is really a `FILE *', and the
  73  * manual page documents it as such.
  74  */
  75 void
  76 err_set_file(void *fp)
  77 {
  78         if (fp)
  79                 err_file = fp;
  80         else
  81                 err_file = stderr;
  82 }
  83
  84 void
  85 err_set_exit(void (*ef)(int))
  86 {
  87         err_exit = ef;
  88 }
  89
  90 __dead void
  91 errc(int eval, int code, const char *fmt, ...)
  92 {
  93         va_list ap;
  94         va_start(ap, fmt);
  95         verrc(eval, code, fmt, ap);
  96         va_end(ap);
  97 }
  98
  99 __dead void
 100 verrc(int eval, int code, const char *fmt, va_list ap)
 101 {
 102         if (err_file == 0)
 103                 err_set_file((FILE *)0);
 104         fprintf(err_file, "%s: ", __progname);
 105         if (fmt != NULL) {
 106                 vfprintf(err_file, fmt, ap);
 107                 fprintf(err_file, ": ");
 108         }
 109         fprintf(err_file, "%s\n", strerror(code));
 110         if (err_exit)
 111                 err_exit(eval);
 112         exit(eval);
 113 }
 114
 115 void
 116 warnc(int code, const char *fmt, ...)
 117 {
 118         va_list ap;
 119         va_start(ap, fmt);
 120         vwarnc(code, fmt, ap);
 121         va_end(ap);
 122 }
 123
 124 void
 125 vwarnc(int code, const char *fmt, va_list ap)
 126 {
 127         if (err_file == 0)
 128                 err_set_file((FILE *)0);
 129         fprintf(err_file, "%s: ", __progname);
 130         if (fmt != NULL) {
 131                 vfprintf(err_file, fmt, ap);
 132                 fprintf(err_file, ": ");
 133         }
 134         fprintf(err_file, "%s\n", strerror(code));
 135 }
 136 #endif
 137
 138 #ifndef HAVE_ERR
 139 __dead void
 140 err(int eval, const char *fmt, ...)
 141 {
 142         va_list ap;
 143         va_start(ap, fmt);
 144         verrc(eval, errno, fmt, ap);
 145         va_end(ap);
 146 }
 147 #endif
 148
 149 #ifndef HAVE_VERR
 150 __dead void
 151 verr(int eval, const char *fmt, va_list ap)
 152 {
 153         verrc(eval, errno, fmt, ap);
 154 }
 155 #endif
 156
 157 #ifndef HAVE_ERRX
 158 __dead void
 159 errx(int eval, const char *fmt, ...)
 160 {
 161         va_list ap;
 162         va_start(ap, fmt);
 163         verrx(eval, fmt, ap);
 164         va_end(ap);
 165 }
 166 #endif
 167
 168 #ifndef HAVE_VERRX
 169 __dead void
 170 verrx(int eval, const char *fmt, va_list ap)
 171 {
 172         if (err_file == 0)
 173                 err_set_file((FILE *)0);
 174         fprintf(err_file, "%s: ", __progname);
 175         if (fmt != NULL)
 176                 vfprintf(err_file, fmt, ap);
 177         fprintf(err_file, "\n");
 178         if (err_exit)
 179                 err_exit(eval);
 180         exit(eval);
 181 }
 182 #endif
 183
 184 #ifndef HAVE_WARN
 185 void
 186 warn(const char *fmt, ...)
 187 {
 188         va_list ap;
 189         va_start(ap, fmt);
 190         vwarnc(errno, fmt, ap);
 191         va_end(ap);
 192 }
 193 #endif
 194
 195 #ifndef HAVE_VWARN
 196 void
 197 vwarn(const char *fmt, va_list ap)
 198 {
 199         vwarnc(errno, fmt, ap);
 200 }
 201 #endif
 202
 203 #ifndef HAVE_WARNX
 204 void
 205 warnx(const char *fmt, ...)
 206 {
 207         va_list ap;
 208         va_start(ap, fmt);
 209         vwarnx(fmt, ap);
 210         va_end(ap);
 211 }
 212 #endif
 213
 214 #ifndef HAVE_VWARNX
 215 void
 216 vwarnx(const char *fmt, va_list ap)
 217 {
 218         if (err_file == 0)
 219                 err_set_file((FILE *)0);
 220         fprintf(err_file, "%s: ", __progname);
 221         if (fmt != NULL)
 222                 vfprintf(err_file, fmt, ap);
 223         fprintf(err_file, "\n");
 224 }
 225 #endif