[apple/libc.git] / gen / err-fbsd.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.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 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.13 2002/03/29 22:43:41 markm 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"

#include "libc_private.h"

#ifdef BUILDING_VARIANT

__private_extern__ FILE *_e_err_file; /* file to use for error output */
__private_extern__ void (*_e_err_exit)(int);
__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__ void (*_e_err_exit)(int) = NULL;

/*
 * zero means pass as is
 * 255 means use \nnn (octal)
 * otherwise use \x (x is value)
 * (NUL isn't used)
 */
static unsigned char escape[256] = {
     /* NUL  SOH  STX  ETX  EOT  ENQ  ACK  BEL */
	0  , 255, 255, 255, 255, 255, 255, 'a',
     /* BS   HT   NL   VT   NP   CR   SO   SI  */
	'b', 't', 'n', '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(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 = ef;
}
#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(eval, code, fmt, ap)
	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)
		_e_err_exit(eval);
	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(eval, fmt, ap)
	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)
		_e_err_exit(eval);
	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(fmt, ap)
	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(code, fmt, ap)
	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(fmt, ap)
	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
224c7076 A	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	}