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