Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/amd/amd/xutil.c	Lines:	0	123	0.0 %
Date:	2017-11-07	Branches:	0	86	0.0 %


/*
 * Copyright (c) 1990 Jan-Simon Pendry
 * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
 * Copyright (c) 1990, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Jan-Simon Pendry at Imperial College, London.
 *
 * 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. 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.
 *
 *	from: @(#)xutil.c	8.1 (Berkeley) 6/6/93
 *	$Id: xutil.c,v 1.19 2015/12/12 20:06:42 mmcc Exp $
 */

#include "am.h"

#include <sys/stat.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <time.h>
#include <unistd.h>

FILE *logfp = stderr;		/* Log errors to stderr initially */
int syslogging;
int xlog_level = XLOG_ALL & ~XLOG_MAP & ~XLOG_STATS & ~XLOG_INFO;
int xlog_level_init = ~0;

/*
 * List of log options
 */
struct opt_tab xlog_opt[] = {
	{ "all", XLOG_ALL },		/* All messages */
#ifdef DEBUG
	{ "debug", XLOG_DEBUG },	/* Debug messages */
#endif /* DEBUG */
	{ "error", XLOG_ERROR },	/* Non-fatal system errors */
	{ "fatal", XLOG_FATAL },	/* Fatal errors */
	{ "info", XLOG_INFO },		/* Information */
	{ "map", XLOG_MAP },		/* Map errors */
	{ "stats", XLOG_STATS },	/* Additional statistical information */
	{ "user", XLOG_USER },		/* Non-fatal user errors */
	{ "warn", XLOG_WARNING },	/* Warnings */
	{ "warning", XLOG_WARNING },	/* Warnings */
	{ 0, 0 }
};

__dead void
xmallocfailure(void)
{
	plog(XLOG_FATAL, "Out of memory");
	going_down(1);
	abort();
}

void *
xmalloc(size_t len)
{
	void *p;
	int retries = 600;

	do {
		if ((p = malloc(len)) != NULL)
			return p;

		if (retries > 0) {
			plog(XLOG_ERROR, "Retrying memory allocation");
			sleep(1);
		}
	} while (--retries);

	xmallocfailure();
}

void *
xreallocarray(void *ptr, size_t nmemb, size_t size)
{
	ptr = reallocarray(ptr, nmemb, size);

	if (ptr == NULL)
		xmallocfailure();
	return (ptr);
}


/*
 * Take a log format string and expand occurrences of %m
 * with the current error code taken from errno.  Make sure
 * 'e' never gets longer than maxlen characters.
 */
static void
expand_error(const char *f, char *e, int maxlen)
{
	const char *p;
	char *q;
	int error = errno;
	int len = 0;

	for (p = f, q = e; (*q = *p) && len < maxlen; len++, q++, p++) {
		if (p[0] == '%' && p[1] == 'm') {
			char *errstr;
			errstr = strerror(error);
			if (errstr)
				strlcpy(q, errstr, maxlen - (q - e));
			else
				snprintf(q, maxlen - (q - e),
				    "Error %d", error);
			len += strlen(q) - 1;
			q += strlen(q) - 1;
			p++;
		}
	}
	e[maxlen-1] = '\0';		/* null terminate, to be sure */
}

/*
 * Output the time of day and hostname to the logfile
 */
static void
show_time_host_and_name(int lvl)
{
	static time_t last_t = 0;
	static char *last_ctime = 0;
	time_t t = clocktime();
	char *sev;

#if defined(DEBUG) && defined(PARANOID)
extern char **gargv;
#endif /* defined(DEBUG) && defined(PARANOID) */

	if (t != last_t) {
		last_ctime = ctime(&t);
		last_t = t;
	}

	switch (lvl) {
	case XLOG_FATAL:	sev = "fatal:"; break;
	case XLOG_ERROR:	sev = "error:"; break;
	case XLOG_USER:		sev = "user: "; break;
	case XLOG_WARNING:	sev = "warn: "; break;
	case XLOG_INFO:		sev = "info: "; break;
	case XLOG_DEBUG:	sev = "debug:"; break;
	case XLOG_MAP:		sev = "map:  "; break;
	case XLOG_STATS:	sev = "stats:"; break;
	default:		sev = "hmm:  "; break;
	}
	fprintf(logfp, "%15.15s %s %s[%ld]/%s ",
		last_ctime+4, hostname,
#if defined(DEBUG) && defined(PARANOID)
		gargv[0],
#else
		__progname,
#endif /* defined(DEBUG) && defined(PARANOID) */
		(long)mypid,
		sev);
}

void
plog(int lvl, const char *fmt, ...)
{
	char efmt[1024];
	va_list ap;

	if (!(xlog_level & lvl))
		return;


	if (syslogging) {
		switch(lvl) {	/* from mike <mcooper@usc.edu> */
		case XLOG_FATAL:	lvl = LOG_CRIT; break;
		case XLOG_ERROR:	lvl = LOG_ERR; break;
		case XLOG_USER:		lvl = LOG_WARNING; break;
		case XLOG_WARNING:	lvl = LOG_WARNING; break;
		case XLOG_INFO:		lvl = LOG_INFO; break;
		case XLOG_DEBUG:	lvl = LOG_DEBUG; break;
		case XLOG_MAP:		lvl = LOG_DEBUG; break;
		case XLOG_STATS:	lvl = LOG_INFO; break;
		default:		lvl = LOG_ERR; break;
		}
		va_start(ap, fmt);
		vsyslog(lvl, fmt, ap);
		va_end(ap);
		return;
	}

	expand_error(fmt, efmt, sizeof(efmt));

	/*
	 * Mimic syslog header
	 */
	show_time_host_and_name(lvl);
	va_start(ap, fmt);
	vfprintf(logfp, efmt, ap);
	va_end(ap);
	fputc('\n', logfp);
	fflush(logfp);
}

void
show_opts(int ch, struct opt_tab *opts)
{
	/*
	 * Display current debug options
	 */
	int i;
	int s = '{';

	fprintf(stderr, "\t[-%c {no}", ch);
	for (i = 0; opts[i].opt; i++) {
		fprintf(stderr, "%c%s", s, opts[i].opt);
		s = ',';
	}
	fputs("}]\n", stderr);
}

int
cmdoption(char *s, struct opt_tab *optb, int *flags)
{
	char *p = s;
	int errs = 0;

	while (p && *p) {
		int neg;
		char *opt;
		struct opt_tab *dp, *dpn = 0;

		s = p;
		p = strchr(p, ',');
		if (p)
			*p = '\0';

		if (s[0] == 'n' && s[1] == 'o') {
			opt = s + 2;
			neg = 1;
		} else {
			opt = s;
			neg = 0;
		}

		/*
		 * Scan the array of debug options to find the
		 * corresponding flag value.  If it is found
		 * then set (or clear) the flag (depending on
		 * whether the option was prefixed with "no").
		 */
		for (dp = optb; dp->opt; dp++) {
			if (strcmp(opt, dp->opt) == 0)
				break;
			if (opt != s && !dpn && strcmp(s, dp->opt) == 0)
				dpn = dp;
		}

		if (dp->opt || dpn) {
			if (!dp->opt) {
				dp = dpn;
				neg = !neg;
			}
			if (neg)
				*flags &= ~dp->flag;
			else
				*flags |= dp->flag;
		} else {
			/*
			 * This will log to stderr when parsing the command line
			 * since any -l option will not yet have taken effect.
			 */
			plog(XLOG_USER, "option \"%s\" not recognised", s);
			errs++;
		}
		/*
		 * Put the comma back
		 */
		if (p)
			*p++ = ',';
	}

	return errs;
}

/*
 * Switch on/off logging options
 */
int
switch_option(char *opt)
{
	int xl = xlog_level;
	int rc = cmdoption(opt, xlog_opt, &xl);
	if (rc) {
		rc = EINVAL;
	} else {
		/*
		 * Keep track of initial log level, and
		 * don't allow options to be turned off.
		 */
		if (xlog_level_init == ~0)
			xlog_level_init = xl;
		else
			xl |= xlog_level_init;
		xlog_level = xl;
	}
	return rc;
}

/*
 * Change current logfile
 */
int
switch_to_logfile(char *logfile)
{
	FILE *new_logfp = stderr;

	if (logfile) {
		syslogging = 0;
		if (strcmp(logfile, "/dev/stderr") == 0)
			new_logfp = stderr;
		else if (strcmp(logfile, "syslog") == 0) {
			syslogging = 1;
			new_logfp = stderr;
#if defined(LOG_CONS) && defined(LOG_NOWAIT)
			openlog(__progname, LOG_PID|LOG_CONS|LOG_NOWAIT,
				LOG_DAEMON);
#else
			/* 4.2 compat mode - XXX */
			openlog(__progname, LOG_PID);
#endif /* LOG_CONS && LOG_NOWAIT */
		} else {
			(void) umask(orig_umask);
			new_logfp = fopen(logfile, "a");
			umask(0);
		}
	}

	/*
	 * If we couldn't open a new file, then continue using the old.
	 */
	if (!new_logfp && logfile) {
		plog(XLOG_USER, "%s: Can't open logfile: %m", logfile);
		return 1;
	}
	/*
	 * Close the previous file
	 */
	if (logfp && logfp != stderr)
		(void) fclose(logfp);
	logfp = new_logfp;
	return 0;
}

time_t clock_valid = 0;
time_t xclock_valid = 0;
#ifndef clocktime
time_t
clocktime(void)
{
	time_t now = time(&clock_valid);
	if (xclock_valid > now) {
		/*
		 * Someone set the clock back!
		 */
		plog(XLOG_WARNING, "system clock reset");
		reschedule_timeouts(now, xclock_valid);
	}
	return xclock_valid = now;
}
#endif /* clocktime */


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 1990 Jan-Simon Pendry
3			* Copyright (c) 1990 Imperial College of Science, Technology & Medicine
4			* Copyright (c) 1990, 1993
5			* The Regents of the University of California. All rights reserved.
6			*
7			* This code is derived from software contributed to Berkeley by
8			* Jan-Simon Pendry at Imperial College, London.
9			*
10			* Redistribution and use in source and binary forms, with or without
11			* modification, are permitted provided that the following conditions
12			* are met:
13			* 1. Redistributions of source code must retain the above copyright
14			* notice, this list of conditions and the following disclaimer.
15			* 2. Redistributions in binary form must reproduce the above copyright
16			* notice, this list of conditions and the following disclaimer in the
17			* documentation and/or other materials provided with the distribution.
18			* 3. Neither the name of the University nor the names of its contributors
19			* may be used to endorse or promote products derived from this software
20			* without specific prior written permission.
21			*
22			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32			* SUCH DAMAGE.
33			*
34			* from: @(#)xutil.c 8.1 (Berkeley) 6/6/93
35			* $Id: xutil.c,v 1.19 2015/12/12 20:06:42 mmcc Exp $
36			*/
37
38			#include "am.h"
39
40			#include <sys/stat.h>
41			#include <stdarg.h>
42			#include <stdlib.h>
43			#include <string.h>
44			#include <syslog.h>
45			#include <time.h>
46			#include <unistd.h>
47
48			FILE logfp = stderr; / Log errors to stderr initially */
49			int syslogging;
50			int xlog_level = XLOG_ALL & ~XLOG_MAP & ~XLOG_STATS & ~XLOG_INFO;
51			int xlog_level_init = ~0;
52
53			/*
54			* List of log options
55			*/
56			struct opt_tab xlog_opt[] = {
57			{ "all", XLOG_ALL }, /* All messages */
58			#ifdef DEBUG
59			{ "debug", XLOG_DEBUG }, /* Debug messages */
60			#endif /* DEBUG */
61			{ "error", XLOG_ERROR }, /* Non-fatal system errors */
62			{ "fatal", XLOG_FATAL }, /* Fatal errors */
63			{ "info", XLOG_INFO }, /* Information */
64			{ "map", XLOG_MAP }, /* Map errors */
65			{ "stats", XLOG_STATS }, /* Additional statistical information */
66			{ "user", XLOG_USER }, /* Non-fatal user errors */
67			{ "warn", XLOG_WARNING }, /* Warnings */
68			{ "warning", XLOG_WARNING }, /* Warnings */
69			{ 0, 0 }
70			};
71
72			__dead void
73			xmallocfailure(void)
74			{
75			plog(XLOG_FATAL, "Out of memory");
76			going_down(1);
77			abort();
78			}
79
80			void *
81			xmalloc(size_t len)
82			{
83			void *p;
84			int retries = 600;
85
86			do {
87			if ((p = malloc(len)) != NULL)
88			return p;
89
90			if (retries > 0) {
91			plog(XLOG_ERROR, "Retrying memory allocation");
92			sleep(1);
93			}
94			} while (--retries);
95
96			xmallocfailure();
97			}
98
99			void *
100			xreallocarray(void *ptr, size_t nmemb, size_t size)
101			{
102			ptr = reallocarray(ptr, nmemb, size);
103
104			if (ptr == NULL)
105			xmallocfailure();
106			return (ptr);
107			}
108
109
110			/*
111			* Take a log format string and expand occurrences of %m
112			* with the current error code taken from errno. Make sure
113			* 'e' never gets longer than maxlen characters.
114			*/
115			static void
116			expand_error(const char f, char e, int maxlen)
117			{
118			const char *p;
119			char *q;
120			int error = errno;
121			int len = 0;
122
123			for (p = f, q = e; (q = p) && len < maxlen; len++, q++, p++) {
124			if (p[0] == '%' && p[1] == 'm') {
125			char *errstr;
126			errstr = strerror(error);
127			if (errstr)
128			strlcpy(q, errstr, maxlen - (q - e));
129			else
130			snprintf(q, maxlen - (q - e),
131			"Error %d", error);
132			len += strlen(q) - 1;
133			q += strlen(q) - 1;
134			p++;
135			}
136			}
137			e[maxlen-1] = '\0'; /* null terminate, to be sure */
138			}
139
140			/*
141			* Output the time of day and hostname to the logfile
142			*/
143			static void
144			show_time_host_and_name(int lvl)
145			{
146			static time_t last_t = 0;
147			static char *last_ctime = 0;
148			time_t t = clocktime();
149			char *sev;
150
151			#if defined(DEBUG) && defined(PARANOID)
152			extern char **gargv;
153			#endif /* defined(DEBUG) && defined(PARANOID) */
154
155			if (t != last_t) {
156			last_ctime = ctime(&t);
157			last_t = t;
158			}
159
160			switch (lvl) {
161			case XLOG_FATAL: sev = "fatal:"; break;
162			case XLOG_ERROR: sev = "error:"; break;
163			case XLOG_USER: sev = "user: "; break;
164			case XLOG_WARNING: sev = "warn: "; break;
165			case XLOG_INFO: sev = "info: "; break;
166			case XLOG_DEBUG: sev = "debug:"; break;
167			case XLOG_MAP: sev = "map: "; break;
168			case XLOG_STATS: sev = "stats:"; break;
169			default: sev = "hmm: "; break;
170			}
171			fprintf(logfp, "%15.15s %s %s[%ld]/%s ",
172			last_ctime+4, hostname,
173			#if defined(DEBUG) && defined(PARANOID)
174			gargv[0],
175			#else
176			__progname,
177			#endif /* defined(DEBUG) && defined(PARANOID) */
178			(long)mypid,
179			sev);
180			}
181
182			void
183			plog(int lvl, const char *fmt, ...)
184			{
185			char efmt[1024];
186			va_list ap;
187
188			if (!(xlog_level & lvl))
189			return;
190
191
192			if (syslogging) {
193			switch(lvl) { /* from mike <mcooper@usc.edu> */
194			case XLOG_FATAL: lvl = LOG_CRIT; break;
195			case XLOG_ERROR: lvl = LOG_ERR; break;
196			case XLOG_USER: lvl = LOG_WARNING; break;
197			case XLOG_WARNING: lvl = LOG_WARNING; break;
198			case XLOG_INFO: lvl = LOG_INFO; break;
199			case XLOG_DEBUG: lvl = LOG_DEBUG; break;
200			case XLOG_MAP: lvl = LOG_DEBUG; break;
201			case XLOG_STATS: lvl = LOG_INFO; break;
202			default: lvl = LOG_ERR; break;
203			}
204			va_start(ap, fmt);
205			vsyslog(lvl, fmt, ap);
206			va_end(ap);
207			return;
208			}
209
210			expand_error(fmt, efmt, sizeof(efmt));
211
212			/*
213			* Mimic syslog header
214			*/
215			show_time_host_and_name(lvl);
216			va_start(ap, fmt);
217			vfprintf(logfp, efmt, ap);
218			va_end(ap);
219			fputc('\n', logfp);
220			fflush(logfp);
221			}
222
223			void
224			show_opts(int ch, struct opt_tab *opts)
225			{
226			/*
227			* Display current debug options
228			*/
229			int i;
230			int s = '{';
231
232			fprintf(stderr, "\t[-%c {no}", ch);
233			for (i = 0; opts[i].opt; i++) {
234			fprintf(stderr, "%c%s", s, opts[i].opt);
235			s = ',';
236			}
237			fputs("}]\n", stderr);
238			}
239
240			int
241			cmdoption(char s, struct opt_tab optb, int *flags)
242			{
243			char *p = s;
244			int errs = 0;
245
246			while (p && *p) {
247			int neg;
248			char *opt;
249			struct opt_tab dp, dpn = 0;
250
251			s = p;
252			p = strchr(p, ',');
253			if (p)
254			*p = '\0';
255
256			if (s[0] == 'n' && s[1] == 'o') {
257			opt = s + 2;
258			neg = 1;
259			} else {
260			opt = s;
261			neg = 0;
262			}
263
264			/*
265			* Scan the array of debug options to find the
266			* corresponding flag value. If it is found
267			* then set (or clear) the flag (depending on
268			* whether the option was prefixed with "no").
269			*/
270			for (dp = optb; dp->opt; dp++) {
271			if (strcmp(opt, dp->opt) == 0)
272			break;
273			if (opt != s && !dpn && strcmp(s, dp->opt) == 0)
274			dpn = dp;
275			}
276
277			if (dp->opt \|\| dpn) {
278			if (!dp->opt) {
279			dp = dpn;
280			neg = !neg;
281			}
282			if (neg)
283			*flags &= ~dp->flag;
284			else
285			*flags \|= dp->flag;
286			} else {
287			/*
288			* This will log to stderr when parsing the command line
289			* since any -l option will not yet have taken effect.
290			*/
291			plog(XLOG_USER, "option \"%s\" not recognised", s);
292			errs++;
293			}
294			/*
295			* Put the comma back
296			*/
297			if (p)
298			*p++ = ',';
299			}
300
301			return errs;
302			}
303
304			/*
305			* Switch on/off logging options
306			*/
307			int
308			switch_option(char *opt)
309			{
310			int xl = xlog_level;
311			int rc = cmdoption(opt, xlog_opt, &xl);
312			if (rc) {
313			rc = EINVAL;
314			} else {
315			/*
316			* Keep track of initial log level, and
317			* don't allow options to be turned off.
318			*/
319			if (xlog_level_init == ~0)
320			xlog_level_init = xl;
321			else
322			xl \|= xlog_level_init;
323			xlog_level = xl;
324			}
325			return rc;
326			}
327
328			/*
329			* Change current logfile
330			*/
331			int
332			switch_to_logfile(char *logfile)
333			{
334			FILE *new_logfp = stderr;
335
336			if (logfile) {
337			syslogging = 0;
338			if (strcmp(logfile, "/dev/stderr") == 0)
339			new_logfp = stderr;
340			else if (strcmp(logfile, "syslog") == 0) {
341			syslogging = 1;
342			new_logfp = stderr;
343			#if defined(LOG_CONS) && defined(LOG_NOWAIT)
344			openlog(__progname, LOG_PID\|LOG_CONS\|LOG_NOWAIT,
345			LOG_DAEMON);
346			#else
347			/* 4.2 compat mode - XXX */
348			openlog(__progname, LOG_PID);
349			#endif /* LOG_CONS && LOG_NOWAIT */
350			} else {
351			(void) umask(orig_umask);
352			new_logfp = fopen(logfile, "a");
353			umask(0);
354			}
355			}
356
357			/*
358			* If we couldn't open a new file, then continue using the old.
359			*/
360			if (!new_logfp && logfile) {
361			plog(XLOG_USER, "%s: Can't open logfile: %m", logfile);
362			return 1;
363			}
364			/*
365			* Close the previous file
366			*/
367			if (logfp && logfp != stderr)
368			(void) fclose(logfp);
369			logfp = new_logfp;
370			return 0;
371			}
372
373			time_t clock_valid = 0;
374			time_t xclock_valid = 0;
375			#ifndef clocktime
376			time_t
377			clocktime(void)
378			{
379			time_t now = time(&clock_valid);
380			if (xclock_valid > now) {
381			/*
382			* Someone set the clock back!
383			*/
384			plog(XLOG_WARNING, "system clock reset");
385			reschedule_timeouts(now, xclock_valid);
386			}
387			return xclock_valid = now;
388			}
389			#endif /* clocktime */