gen/err-fbsd.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: src/lib/libc/gen/err.c,v 1.13 2002/03/29 22:43:41 markm Exp $");
  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 <vis.h>
  48 #include "un-namespace.h"
  49
  50 #include "libc_private.h"
  51
  52 #ifdef BUILDING_VARIANT
  53
  54 __private_extern__ FILE *_e_err_file; /* file to use for error output */
  55 __private_extern__ void (*_e_err_exit)(int);
  56 __private_extern__ void _e_visprintf(FILE * __restrict, const char * __restrict, va_list);
  57
  58 #else /* !BUILDING_VARIANT */
  59
  60 __private_extern__ FILE *_e_err_file = NULL; /* file to use for error output */
  61 __private_extern__ void (*_e_err_exit)(int) = NULL;
  62
  63 /*
  64  * zero means pass as is
  65  * 255 means use \nnn (octal)
  66  * otherwise use \x (x is value)
  67  * (NUL isn't used)
  68  */
  69 static unsigned char escape[256] = {
  70      /* NUL  SOH  STX  ETX  EOT  ENQ  ACK  BEL */
  71         0  , 255, 255, 255, 255, 255, 255, 'a',
  72      /* BS   HT   NL   VT   NP   CR   SO   SI  */
  73         'b', 't', 'n', 'v', 'f', 'r', 255, 255,
  74      /* DLE  DC1  DC2  DC3  DC4  NAK  SYN  ETB */
  75         255, 255, 255, 255, 255, 255, 255, 255,
  76      /* CAN  EM   SUB  ESC  FS   GS   RS   US  */
  77         255, 255, 255, 255, 255, 255, 255, 255,
  78      /* the rest are zero */
  79 };
  80
  81 /*
  82  * Make characters visible.  If we can't allocate enough
  83  * memory, we fall back on vfprintf().
  84  */
  85 __private_extern__ void
  86 _e_visprintf(FILE * __restrict stream, const char * __restrict format, va_list ap)
  87 {
  88         int failed = 0;
  89         char *str, *visstr;
  90         va_list backup;
  91
  92         va_copy(backup, ap);
  93         vasprintf(&str, format, ap);
  94         if (str != NULL) {
  95                 if ((visstr = malloc(4 * strlen(str) + 1)) != NULL) {
  96                         unsigned char *fp = (unsigned char *)str;
  97                         unsigned char *tp = (unsigned char *)visstr;
  98                         while(*fp) {
  99                                 switch(escape[*fp]) {
 100                                 case 0:
 101                                         *tp++ = *fp;
 102                                         break;
 103                                 case 255:
 104                                         sprintf(tp, "\\%03o", *fp);
 105                                         tp += 4;
 106                                         break;
 107                                 default:
 108                                         *tp++ = '\\';
 109                                         *tp++ = escape[*fp];
 110                                         break;
 111                                 }
 112                                 fp++;
 113                         }
 114                         *tp = 0;
 115                         fputs(visstr, stream);
 116                         free(visstr);
 117                 } else
 118                         failed = 1;
 119                 free(str);
 120         } else
 121                 failed = 1;
 122         if (failed)
 123                 vfprintf(stream, format, backup);
 124         va_end(backup);
 125 }
 126
 127 /*
 128  * This is declared to take a `void *' so that the caller is not required
 129  * to include <stdio.h> first.  However, it is really a `FILE *', and the
 130  * manual page documents it as such.
 131  */
 132 void
 133 err_set_file(void *fp)
 134 {
 135         if (fp)
 136                 _e_err_file = fp;
 137         else
 138                 _e_err_file = stderr;
 139 }
 140
 141 void
 142 err_set_exit(void (*ef)(int))
 143 {
 144         _e_err_exit = ef;
 145 }
 146 #endif /* !BUILDING_VARIANT */
 147
 148 __weak_reference(_err, err);
 149
 150 void
 151 _err(int eval, const char *fmt, ...)
 152 {
 153         va_list ap;
 154         va_start(ap, fmt);
 155         verrc(eval, errno, fmt, ap);
 156         va_end(ap);
 157 }
 158
 159 void
 160 verr(eval, fmt, ap)
 161         int eval;
 162         const char *fmt;
 163         va_list ap;
 164 {
 165         verrc(eval, errno, fmt, ap);
 166 }
 167
 168 void
 169 errc(int eval, int code, const char *fmt, ...)
 170 {
 171         va_list ap;
 172         va_start(ap, fmt);
 173         verrc(eval, code, fmt, ap);
 174         va_end(ap);
 175 }
 176
 177 void
 178 verrc(eval, code, fmt, ap)
 179         int eval;
 180         int code;
 181         const char *fmt;
 182         va_list ap;
 183 {
 184         if (_e_err_file == 0)
 185                 err_set_file((FILE *)0);
 186         fprintf(_e_err_file, "%s: ", _getprogname());
 187         if (fmt != NULL) {
 188                 _e_visprintf(_e_err_file, fmt, ap);
 189                 fprintf(_e_err_file, ": ");
 190         }
 191         fprintf(_e_err_file, "%s\n", strerror(code));
 192         if (_e_err_exit)
 193                 _e_err_exit(eval);
 194         exit(eval);
 195 }
 196
 197 void
 198 errx(int eval, const char *fmt, ...)
 199 {
 200         va_list ap;
 201         va_start(ap, fmt);
 202         verrx(eval, fmt, ap);
 203         va_end(ap);
 204 }
 205
 206 void
 207 verrx(eval, fmt, ap)
 208         int eval;
 209         const char *fmt;
 210         va_list ap;
 211 {
 212         if (_e_err_file == 0)
 213                 err_set_file((FILE *)0);
 214         fprintf(_e_err_file, "%s: ", _getprogname());
 215         if (fmt != NULL)
 216                 _e_visprintf(_e_err_file, fmt, ap);
 217         fprintf(_e_err_file, "\n");
 218         if (_e_err_exit)
 219                 _e_err_exit(eval);
 220         exit(eval);
 221 }
 222
 223 __weak_reference(_warn, warn);
 224
 225 void
 226 _warn(const char *fmt, ...)
 227 {
 228         va_list ap;
 229         va_start(ap, fmt);
 230         vwarnc(errno, fmt, ap);
 231         va_end(ap);
 232 }
 233
 234 void
 235 vwarn(fmt, ap)
 236         const char *fmt;
 237         va_list ap;
 238 {
 239         vwarnc(errno, fmt, ap);
 240 }
 241
 242 void
 243 warnc(int code, const char *fmt, ...)
 244 {
 245         va_list ap;
 246         va_start(ap, fmt);
 247         vwarnc(code, fmt, ap);
 248         va_end(ap);
 249 }
 250
 251 void
 252 vwarnc(code, fmt, ap)
 253         int code;
 254         const char *fmt;
 255         va_list ap;
 256 {
 257         if (_e_err_file == 0)
 258                 err_set_file((FILE *)0);
 259         fprintf(_e_err_file, "%s: ", _getprogname());
 260         if (fmt != NULL) {
 261                 _e_visprintf(_e_err_file, fmt, ap);
 262                 fprintf(_e_err_file, ": ");
 263         }
 264         fprintf(_e_err_file, "%s\n", strerror(code));
 265 }
 266
 267 void
 268 warnx(const char *fmt, ...)
 269 {
 270         va_list ap;
 271         va_start(ap, fmt);
 272         vwarnx(fmt, ap);
 273         va_end(ap);
 274 }
 275
 276 void
 277 vwarnx(fmt, ap)
 278         const char *fmt;
 279         va_list ap;
 280 {
 281         if (_e_err_file == 0)
 282                 err_set_file((FILE *)0);
 283         fprintf(_e_err_file, "%s: ", _getprogname());
 284         if (fmt != NULL)
 285                 _e_visprintf(_e_err_file, fmt, ap);
 286         fprintf(_e_err_file, "\n");
 287 }