[apple/libc.git] / gen / FreeBSD / err.c

/*-
 * Copyright (c) 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)err.c	8.1 (Berkeley) 6/4/93";
#endif /* LIBC_SCCS and not lint */
#include <sys/cdefs.h>
__FBSDID("$FreeBSD: src/lib/libc/gen/err.c,v 1.15 2008/04/03 20:36:44 imp Exp $");

#include "namespace.h"
#include <err.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vis.h>
#include "un-namespace.h"

#ifdef __BLOCKS__
#include <Block.h>
#endif /* __BLOCKS__ */
#include "libc_private.h"

#define ERR_EXIT_UNDEF	0
#ifdef __BLOCKS__
#define ERR_EXIT_BLOCK	1
#endif /* __BLOCKS__ */
#define ERR_EXIT_FUNC	2
struct _e_err_exit {
	unsigned int type;
#ifdef __BLOCKS__
	union {
#endif /* __BLOCKS__ */
		void (*func)(int);
#ifdef __BLOCKS__
		void (^block)(int);
	};
#endif /* __BLOCKS__ */
};

#ifdef BUILDING_VARIANT

__private_extern__ FILE *_e_err_file; /* file to use for error output */
__private_extern__ struct _e_err_exit _e_err_exit;
__private_extern__ void _e_visprintf(FILE * __restrict, const char * __restrict, va_list);

#else /* !BUILDING_VARIANT */

__private_extern__ FILE *_e_err_file = NULL; /* file to use for error output */
__private_extern__ struct _e_err_exit _e_err_exit = {ERR_EXIT_UNDEF};

/*
 * zero means pass as is
 * 255 means use \nnn (octal)
 * otherwise use \x (x is value)
 * (NUL isn't used)
 */
static const unsigned char escape[256] = {
     /* NUL */
	 0, /* Unused: strings can't contain nulls */
     /*      SOH  STX  ETX  EOT  ENQ  ACK  BEL */
	     255, 255, 255, 255, 255, 255, 'a',
     /* BS   HT   NL   VT   NP   CR   SO   SI  */
	'b',  0,   0,  'v', 'f', 'r', 255, 255,
     /* DLE  DC1  DC2  DC3  DC4  NAK  SYN  ETB */
	255, 255, 255, 255, 255, 255, 255, 255,
     /* CAN  EM   SUB  ESC  FS   GS   RS   US  */
	255, 255, 255, 255, 255, 255, 255, 255,
     /* the rest are zero */
};

/*
 * Make characters visible.  If we can't allocate enough
 * memory, we fall back on vfprintf().
 */
__private_extern__ void
_e_visprintf(FILE * __restrict stream, const char * __restrict format, va_list ap)
{
	int failed = 0;
	char *str, *visstr;
	va_list backup;

	va_copy(backup, ap);
	vasprintf(&str, format, ap);
	if (str != NULL) {
		if ((visstr = malloc(4 * strlen(str) + 1)) != NULL) {
			unsigned char *fp = (unsigned char *)str;
			unsigned char *tp = (unsigned char *)visstr;
			while(*fp) {
				switch(escape[*fp]) {
				case 0:
					*tp++ = *fp;
					break;
				case 255:
					sprintf((char *)tp, "\\%03o", *fp);
					tp += 4;
					break;
				default:
					*tp++ = '\\';
					*tp++ = escape[*fp];
					break;
				}
				fp++;
			}
			*tp = 0;
			fputs(visstr, stream);
			free(visstr);
		} else
			failed = 1;
		free(str);
	} else
		failed = 1;
	if (failed)
		vfprintf(stream, format, backup);
	va_end(backup);
}

/*
 * This is declared to take a `void *' so that the caller is not required
 * to include <stdio.h> first.  However, it is really a `FILE *', and the
 * manual page documents it as such.
 */
void
err_set_file(void *fp)
{
	if (fp)
		_e_err_file = fp;
	else
		_e_err_file = stderr;
}

void
err_set_exit(void (*ef)(int))
{
	_e_err_exit.type = ERR_EXIT_FUNC;
	_e_err_exit.func = ef;
}

#ifdef __BLOCKS__
void
err_set_exit_b(void (^ef)(int))
{
	_e_err_exit.type = ERR_EXIT_BLOCK;
	_e_err_exit.block = Block_copy(ef);
}
#endif /* __BLOCKS__ */
#endif /* !BUILDING_VARIANT */

__weak_reference(_err, err);

void
_err(int eval, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	verrc(eval, errno, fmt, ap);
	va_end(ap);
}

void
verr(eval, fmt, ap)
	int eval;
	const char *fmt;
	va_list ap;
{
	verrc(eval, errno, fmt, ap);
}

void
errc(int eval, int code, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	verrc(eval, code, fmt, ap);
	va_end(ap);
}

void
verrc(int eval, int code, const char *fmt, va_list ap)
{
	if (_e_err_file == 0)
		err_set_file((FILE *)0);
	fprintf(_e_err_file, "%s: ", _getprogname());
	if (fmt != NULL) {
		_e_visprintf(_e_err_file, fmt, ap);
		fprintf(_e_err_file, ": ");
	}
	fprintf(_e_err_file, "%s\n", strerror(code));
	if (_e_err_exit.type) {
#ifdef __BLOCKS__
		if (_e_err_exit.type == ERR_EXIT_BLOCK) {
			_e_err_exit.block(eval);
		} else {
			_e_err_exit.func(eval);
		}
#else
		_e_err_exit.func(eval);
#endif /* __BLOCKS__ */
	}
	exit(eval);
}

void
errx(int eval, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	verrx(eval, fmt, ap);
	va_end(ap);
}

void
verrx(int eval, const char *fmt, va_list ap)
{
	if (_e_err_file == 0)
		err_set_file((FILE *)0);
	fprintf(_e_err_file, "%s: ", _getprogname());
	if (fmt != NULL)
		_e_visprintf(_e_err_file, fmt, ap);
	fprintf(_e_err_file, "\n");
	if (_e_err_exit.type) {
#ifdef __BLOCKS__
		if (_e_err_exit.type == ERR_EXIT_BLOCK) {
			_e_err_exit.block(eval);
		} else {
			_e_err_exit.func(eval);
		}
#else
		_e_err_exit.func(eval);
#endif /* __BLOCKS__ */
	}
	exit(eval);
}

__weak_reference(_warn, warn);

void
_warn(const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	vwarnc(errno, fmt, ap);
	va_end(ap);
}

void
vwarn(const char *fmt, va_list ap)
{
	vwarnc(errno, fmt, ap);
}

void
warnc(int code, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	vwarnc(code, fmt, ap);
	va_end(ap);
}

void
vwarnc(int code, const char *fmt, va_list ap)
{
	if (_e_err_file == 0)
		err_set_file((FILE *)0);
	fprintf(_e_err_file, "%s: ", _getprogname());
	if (fmt != NULL) {
		_e_visprintf(_e_err_file, fmt, ap);
		fprintf(_e_err_file, ": ");
	}
	fprintf(_e_err_file, "%s\n", strerror(code));
}

void
warnx(const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	vwarnx(fmt, ap);
	va_end(ap);
}

void
vwarnx(const char *fmt, va_list ap)
{
	if (_e_err_file == 0)
		err_set_file((FILE *)0);
	fprintf(_e_err_file, "%s: ", _getprogname());
	if (fmt != NULL)
		_e_visprintf(_e_err_file, fmt, ap);
	fprintf(_e_err_file, "\n");
}
Commit	Line	Data
9385eb3d	1	/*-
e9ce8d39 A	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.
e9ce8d39 A	13	* 4. Neither the name of the University nor the names of its contributors
	14	* may be used to endorse or promote products derived from this software
	15	* without specific prior written permission.
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	20	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	27	* SUCH DAMAGE.
	28	*/
	29
9385eb3d A	30	#if defined(LIBC_SCCS) && !defined(lint)
	31	static char sccsid[] = "@(#)err.c 8.1 (Berkeley) 6/4/93";
	32	#endif /* LIBC_SCCS and not lint */
	33	#include <sys/cdefs.h>
1f2f436a	34	__FBSDID("$FreeBSD: src/lib/libc/gen/err.c,v 1.15 2008/04/03 20:36:44 imp Exp $");
e9ce8d39	35
9385eb3d	36	#include "namespace.h"
e9ce8d39 A	37	#include <err.h>
e9ce8d39 A	38	#include <errno.h>
9385eb3d	39	#include <stdarg.h>
e9ce8d39 A	40	#include <stdio.h>
	41	#include <stdlib.h>
	42	#include <string.h>
ad3c9f2a	43	#include <vis.h>
9385eb3d	44	#include "un-namespace.h"
e9ce8d39	45
ad3c9f2a A	46	#ifdef __BLOCKS__
	47	#include <Block.h>
	48	#endif /* __BLOCKS__ */
9385eb3d	49	#include "libc_private.h"
e9ce8d39	50
ad3c9f2a A	51	#define ERR_EXIT_UNDEF 0
	52	#ifdef __BLOCKS__
	53	#define ERR_EXIT_BLOCK 1
	54	#endif /* __BLOCKS__ */
	55	#define ERR_EXIT_FUNC 2
	56	struct _e_err_exit {
	57	unsigned int type;
	58	#ifdef __BLOCKS__
	59	union {
	60	#endif /* __BLOCKS__ */
	61	void (*func)(int);
	62	#ifdef __BLOCKS__
	63	void (^block)(int);
	64	};
	65	#endif /* __BLOCKS__ */
	66	};
	67
	68	#ifdef BUILDING_VARIANT
	69
	70	__private_extern__ FILE _e_err_file; / file to use for error output */
	71	__private_extern__ struct _e_err_exit _e_err_exit;
	72	__private_extern__ void _e_visprintf(FILE * __restrict, const char * __restrict, va_list);
	73
	74	#else /* !BUILDING_VARIANT */
	75
	76	__private_extern__ FILE _e_err_file = NULL; / file to use for error output */
	77	__private_extern__ struct _e_err_exit _e_err_exit = {ERR_EXIT_UNDEF};
	78
	79	/*
	80	* zero means pass as is
	81	* 255 means use \nnn (octal)
	82	* otherwise use \x (x is value)
	83	* (NUL isn't used)
	84	*/
6465356a	85	static const unsigned char escape[256] = {
ad3c9f2a A	86	/* NUL */
	87	0, /* Unused: strings can't contain nulls */
	88	/* SOH STX ETX EOT ENQ ACK BEL */
	89	255, 255, 255, 255, 255, 255, 'a',
	90	/* BS HT NL VT NP CR SO SI */
	91	'b', 0, 0, 'v', 'f', 'r', 255, 255,
	92	/* DLE DC1 DC2 DC3 DC4 NAK SYN ETB */
	93	255, 255, 255, 255, 255, 255, 255, 255,
	94	/* CAN EM SUB ESC FS GS RS US */
	95	255, 255, 255, 255, 255, 255, 255, 255,
	96	/* the rest are zero */
	97	};
	98
	99	/*
	100	* Make characters visible. If we can't allocate enough
	101	* memory, we fall back on vfprintf().
	102	*/
	103	__private_extern__ void
	104	_e_visprintf(FILE * __restrict stream, const char * __restrict format, va_list ap)
	105	{
	106	int failed = 0;
	107	char str, visstr;
	108	va_list backup;
	109
	110	va_copy(backup, ap);
	111	vasprintf(&str, format, ap);
	112	if (str != NULL) {
	113	if ((visstr = malloc(4 * strlen(str) + 1)) != NULL) {
	114	unsigned char fp = (unsigned char )str;
	115	unsigned char tp = (unsigned char )visstr;
	116	while(*fp) {
	117	switch(escape[*fp]) {
	118	case 0:
	119	tp++ = fp;
	120	break;
	121	case 255:
	122	sprintf((char )tp, "\\%03o", fp);
	123	tp += 4;
	124	break;
	125	default:
	126	*tp++ = '\\';
	127	tp++ = escape[fp];
	128	break;
	129	}
	130	fp++;
	131	}
	132	*tp = 0;
	133	fputs(visstr, stream);
	134	free(visstr);
	135	} else
	136	failed = 1;
	137	free(str);
	138	} else
	139	failed = 1;
	140	if (failed)
	141	vfprintf(stream, format, backup);
	142	va_end(backup);
	143	}
9385eb3d A	144
	145	/*
	146	* This is declared to take a `void *' so that the caller is not required
	147	* to include <stdio.h> first. However, it is really a `FILE *', and the
	148	* manual page documents it as such.
	149	*/
	150	void
	151	err_set_file(void *fp)
	152	{
	153	if (fp)
ad3c9f2a	154	_e_err_file = fp;
9385eb3d	155	else
ad3c9f2a	156	_e_err_file = stderr;
9385eb3d A	157	}
	158
	159	void
	160	err_set_exit(void (*ef)(int))
	161	{
ad3c9f2a A	162	_e_err_exit.type = ERR_EXIT_FUNC;
	163	_e_err_exit.func = ef;
	164	}
	165
	166	#ifdef __BLOCKS__
	167	void
	168	err_set_exit_b(void (^ef)(int))
	169	{
	170	_e_err_exit.type = ERR_EXIT_BLOCK;
	171	_e_err_exit.block = Block_copy(ef);
9385eb3d	172	}
ad3c9f2a A	173	#endif /* __BLOCKS__ */
ad3c9f2a A	174	#endif /* !BUILDING_VARIANT */
9385eb3d A	175
	176	__weak_reference(_err, err);
	177
	178	void
	179	_err(int eval, const char *fmt, ...)
e9ce8d39 A	180	{
e9ce8d39 A	181	va_list ap;
e9ce8d39	182	va_start(ap, fmt);
9385eb3d	183	verrc(eval, errno, fmt, ap);
e9ce8d39 A	184	va_end(ap);
	185	}
	186
9385eb3d	187	void
e9ce8d39 A	188	verr(eval, fmt, ap)
	189	int eval;
	190	const char *fmt;
	191	va_list ap;
	192	{
9385eb3d A	193	verrc(eval, errno, fmt, ap);
9385eb3d A	194	}
e9ce8d39	195
9385eb3d A	196	void
	197	errc(int eval, int code, const char *fmt, ...)
	198	{
	199	va_list ap;
	200	va_start(ap, fmt);
	201	verrc(eval, code, fmt, ap);
	202	va_end(ap);
	203	}
	204
	205	void
1f2f436a	206	verrc(int eval, int code, const char *fmt, va_list ap)
9385eb3d	207	{
ad3c9f2a	208	if (_e_err_file == 0)
9385eb3d	209	err_set_file((FILE *)0);
ad3c9f2a	210	fprintf(_e_err_file, "%s: ", _getprogname());
e9ce8d39	211	if (fmt != NULL) {
ad3c9f2a A	212	_e_visprintf(_e_err_file, fmt, ap);
ad3c9f2a A	213	fprintf(_e_err_file, ": ");
e9ce8d39	214	}
ad3c9f2a	215	fprintf(_e_err_file, "%s\n", strerror(code));
6465356a	216	if (_e_err_exit.type) {
ad3c9f2a	217	#ifdef __BLOCKS__
6465356a	218	if (_e_err_exit.type == ERR_EXIT_BLOCK) {
ad3c9f2a	219	_e_err_exit.block(eval);
6465356a	220	} else {
ad3c9f2a	221	_e_err_exit.func(eval);
6465356a A	222	}
	223	#else
	224	_e_err_exit.func(eval);
	225	#endif /* __BLOCKS__ */
	226	}
e9ce8d39 A	227	exit(eval);
	228	}
	229
9385eb3d	230	void
e9ce8d39	231	errx(int eval, const char *fmt, ...)
e9ce8d39 A	232	{
e9ce8d39 A	233	va_list ap;
e9ce8d39	234	va_start(ap, fmt);
e9ce8d39 A	235	verrx(eval, fmt, ap);
	236	va_end(ap);
	237	}
	238
9385eb3d	239	void
1f2f436a	240	verrx(int eval, const char *fmt, va_list ap)
e9ce8d39	241	{
ad3c9f2a	242	if (_e_err_file == 0)
9385eb3d	243	err_set_file((FILE *)0);
ad3c9f2a	244	fprintf(_e_err_file, "%s: ", _getprogname());
e9ce8d39	245	if (fmt != NULL)
ad3c9f2a A	246	_e_visprintf(_e_err_file, fmt, ap);
ad3c9f2a A	247	fprintf(_e_err_file, "\n");
6465356a	248	if (_e_err_exit.type) {
ad3c9f2a	249	#ifdef __BLOCKS__
6465356a	250	if (_e_err_exit.type == ERR_EXIT_BLOCK) {
ad3c9f2a	251	_e_err_exit.block(eval);
6465356a	252	} else {
ad3c9f2a	253	_e_err_exit.func(eval);
6465356a A	254	}
	255	#else
	256	_e_err_exit.func(eval);
	257	#endif /* __BLOCKS__ */
	258	}
e9ce8d39 A	259	exit(eval);
	260	}
	261
9385eb3d A	262	__weak_reference(_warn, warn);
9385eb3d A	263
e9ce8d39	264	void
9385eb3d	265	_warn(const char *fmt, ...)
e9ce8d39 A	266	{
e9ce8d39 A	267	va_list ap;
e9ce8d39	268	va_start(ap, fmt);
9385eb3d	269	vwarnc(errno, fmt, ap);
e9ce8d39 A	270	va_end(ap);
	271	}
	272
	273	void
1f2f436a	274	vwarn(const char *fmt, va_list ap)
e9ce8d39	275	{
9385eb3d A	276	vwarnc(errno, fmt, ap);
	277	}
	278
	279	void
	280	warnc(int code, const char *fmt, ...)
	281	{
	282	va_list ap;
	283	va_start(ap, fmt);
	284	vwarnc(code, fmt, ap);
	285	va_end(ap);
	286	}
	287
	288	void
1f2f436a	289	vwarnc(int code, const char *fmt, va_list ap)
9385eb3d	290	{
ad3c9f2a	291	if (_e_err_file == 0)
9385eb3d	292	err_set_file((FILE *)0);
ad3c9f2a	293	fprintf(_e_err_file, "%s: ", _getprogname());
e9ce8d39	294	if (fmt != NULL) {
ad3c9f2a A	295	_e_visprintf(_e_err_file, fmt, ap);
ad3c9f2a A	296	fprintf(_e_err_file, ": ");
e9ce8d39	297	}
ad3c9f2a	298	fprintf(_e_err_file, "%s\n", strerror(code));
e9ce8d39 A	299	}
	300
	301	void
e9ce8d39	302	warnx(const char *fmt, ...)
e9ce8d39 A	303	{
e9ce8d39 A	304	va_list ap;
e9ce8d39	305	va_start(ap, fmt);
e9ce8d39 A	306	vwarnx(fmt, ap);
	307	va_end(ap);
	308	}
	309
	310	void
1f2f436a	311	vwarnx(const char *fmt, va_list ap)
e9ce8d39	312	{
ad3c9f2a	313	if (_e_err_file == 0)
9385eb3d	314	err_set_file((FILE *)0);
ad3c9f2a	315	fprintf(_e_err_file, "%s: ", _getprogname());
e9ce8d39	316	if (fmt != NULL)
ad3c9f2a A	317	_e_visprintf(_e_err_file, fmt, ap);
ad3c9f2a A	318	fprintf(_e_err_file, "\n");
e9ce8d39	319	}