ihost/libukcprog/logf.c

/* logf.c -- Log file and error reporting routines. */

/* Copyright 1992 Godfrey Paul, University of Kent of Canterbury. */

char ukcprog_logf_sccsid[] = "$Id: logf.c,v 1.22 1999/07/15 11:10:21 djb1 Exp $ UKC";

#ifndef MSDOS
#include <sys/types.h>
#else
#include <sys/tk_types.h>
#endif

#include <fcntl.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#ifdef __STDC__
#ifndef VMS
#include <unistd.h>
#endif /* VMS */
#include <stdarg.h>
#else
#include <varargs.h>
#endif

#ifndef MSDOS
#ifndef __FreeBSD__
#ifndef linux
extern int sys_nerr, errno;
extern char *sys_errlist[];
#endif /* !linux */
#endif /* !__FreeBSD__ */
#endif /* !MSDOS */

#include "ukcprog.h"

static void write_logstr PROTO((const char *str, bool err));
static const char *get_errno_str PROTO((void));

static int Log_fd = 2;          /* just print to stderr by default */
static int Log_level = LG_INFO; /* by default */
static char *Log_prefix;        /* identification tag */
static int Log_prefix_len = 0;

/*  This is to avoid using %m in logf_set_ofile.  We should really make
 *  this public and use it in formf().
 */
static const char *
get_errno_str()
{
        static char buf[40];
                
        if (errno > 0 && errno < sys_nerr && *sys_errlist[errno] != '\0')
                return sys_errlist[errno];
        
        sprintf(buf, "[errno=%d (unknown value)]", errno);
        return buf;
}

int
logf_set_ofile(filename, prefix)
const char *filename, *prefix;
{
        static bool first_time = TRUE;
        int fd;

        if (filename != NULL) {
                if ((fd = open(filename, O_RDWR|O_APPEND|O_CREAT, 0666)) < 0) {
                        errf("Can't open logfile %s (%s)",
                             filename, get_errno_str());
                        return -1;
                }

                if (!first_time)
                        (void)close(Log_fd);
                else
                        first_time = FALSE;

                Log_fd = fd;
        }

        if (prefix != NULL) {
                if (Log_prefix != NULL)
                        free(Log_prefix);
                Log_prefix = strsave(prefix);
                Log_prefix_len = strlen(Log_prefix);
        }

        return 0;
}


static void
write_logstr(str, err)
const char *str;
bool err;
{
        time_t now;
        const char *errstr;

        if (Log_fd < 0) {
                fprintf(stderr, "%s: %s\n", errf_get_progname(), str);
                return;
        }

        now = time((time_t *)NULL);
        errstr = err ? " ERROR: " : " ";
        
        write(Log_fd, ctime(&now), sizeof("Fri Sep  9 15:10:00 ") - 1);
        write(Log_fd, Log_prefix, Log_prefix_len);
        write(Log_fd, errstr, strlen(errstr));
        write(Log_fd, str, strlen(str));
        write(Log_fd, "\n", 1);
}


#ifdef __STDC__
void
logf(int level, const char *fmt, ...)
{

#else /* !__STDC__ */
void
logf(va_alist)
va_dcl
{
        int level;
        char *fmt;
#endif /* !__STDC__ */
        va_list args;
        char buffer[100];
        char *s;

#ifdef __STDC__
        va_start(args, fmt);
#else
        va_start(args);
        level = va_arg(args, int);
        fmt = va_arg(args, char *);
#endif
        if (level < Log_level) {
                va_end(args);
                return;
        }

        s = formf(buffer, sizeof(buffer), fmt, args);
        va_end(args);
        write_logstr(s, FALSE);

        if (s != buffer)
                free(s);        /* allocated by formf() */
}

int
logf_set_level(new_level)
int new_level;
{
        int old;

        old = Log_level;
        Log_level = new_level;
        logf(LG_LOG, "Log level changed from %d to %d", old, new_level);

        return old;
}


void
logf_errf_ofunc(str)
const char *str;
{
        write_logstr(str, TRUE);
}
Revision:	1.1
Committed:	Fri Mar 8 14:37:29 2002 UTC (22 years, 8 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
CVS Tags:	IHOST_1_5_3, IHOST_1_5_2, IHOST_1_5_1, IHOST_1_5, IHOST_1_0_RC1
Log Message:	I'm not usually up for putting third party sources in here, but in this case I'll make an exception. This is ukcprog, a set of useful C functions which the ihost plugins Pete's writing uses. It's got a pretty free license too. I've munged the Makefile around, as all it needs to do now is make the library, not install anything. The idea is to statically compile the other programs against this library, making the final binary independent of this code etc.
#	Content
1	/* logf.c -- Log file and error reporting routines. */
2
3	/* Copyright 1992 Godfrey Paul, University of Kent of Canterbury. */
4
5	char ukcprog_logf_sccsid[] = "$Id: logf.c,v 1.22 1999/07/15 11:10:21 djb1 Exp $ UKC";
6
7	#ifndef MSDOS
8	#include <sys/types.h>
9	#else
10	#include <sys/tk_types.h>
11	#endif
12
13	#include <fcntl.h>
14
15	#include <stdlib.h>
16	#include <stdio.h>
17	#include <string.h>
18	#include <time.h>
19	#include <errno.h>
20	#ifdef __STDC__
21	#ifndef VMS
22	#include <unistd.h>
23	#endif /* VMS */
24	#include <stdarg.h>
25	#else
26	#include <varargs.h>
27	#endif
28
29	#ifndef MSDOS
30	#ifndef __FreeBSD__
31	#ifndef linux
32	extern int sys_nerr, errno;
33	extern char *sys_errlist[];
34	#endif /* !linux */
35	#endif /* !__FreeBSD__ */
36	#endif /* !MSDOS */
37
38	#include "ukcprog.h"
39
40	static void write_logstr PROTO((const char *str, bool err));
41	static const char *get_errno_str PROTO((void));
42
43	static int Log_fd = 2; /* just print to stderr by default */
44	static int Log_level = LG_INFO; /* by default */
45	static char Log_prefix; / identification tag */
46	static int Log_prefix_len = 0;
47
48	/* This is to avoid using %m in logf_set_ofile. We should really make
49	* this public and use it in formf().
50	*/
51	static const char *
52	get_errno_str()
53	{
54	static char buf[40];
55
56	if (errno > 0 && errno < sys_nerr && *sys_errlist[errno] != '\0')
57	return sys_errlist[errno];
58
59	sprintf(buf, "[errno=%d (unknown value)]", errno);
60	return buf;
61	}
62
63	int
64	logf_set_ofile(filename, prefix)
65	const char filename, prefix;
66	{
67	static bool first_time = TRUE;
68	int fd;
69
70	if (filename != NULL) {
71	if ((fd = open(filename, O_RDWR\|O_APPEND\|O_CREAT, 0666)) < 0) {
72	errf("Can't open logfile %s (%s)",
73	filename, get_errno_str());
74	return -1;
75	}
76
77	if (!first_time)
78	(void)close(Log_fd);
79	else
80	first_time = FALSE;
81
82	Log_fd = fd;
83	}
84
85	if (prefix != NULL) {
86	if (Log_prefix != NULL)
87	free(Log_prefix);
88	Log_prefix = strsave(prefix);
89	Log_prefix_len = strlen(Log_prefix);
90	}
91
92	return 0;
93	}
94
95
96	static void
97	write_logstr(str, err)
98	const char *str;
99	bool err;
100	{
101	time_t now;
102	const char *errstr;
103
104	if (Log_fd < 0) {
105	fprintf(stderr, "%s: %s\n", errf_get_progname(), str);
106	return;
107	}
108
109	now = time((time_t *)NULL);
110	errstr = err ? " ERROR: " : " ";
111
112	write(Log_fd, ctime(&now), sizeof("Fri Sep 9 15:10:00 ") - 1);
113	write(Log_fd, Log_prefix, Log_prefix_len);
114	write(Log_fd, errstr, strlen(errstr));
115	write(Log_fd, str, strlen(str));
116	write(Log_fd, "\n", 1);
117	}
118
119
120	#ifdef __STDC__
121	void
122	logf(int level, const char *fmt, ...)
123	{
124
125	#else /* !__STDC__ */
126	void
127	logf(va_alist)
128	va_dcl
129	{
130	int level;
131	char *fmt;
132	#endif /* !__STDC__ */
133	va_list args;
134	char buffer[100];
135	char *s;
136
137	#ifdef __STDC__
138	va_start(args, fmt);
139	#else
140	va_start(args);
141	level = va_arg(args, int);
142	fmt = va_arg(args, char *);
143	#endif
144	if (level < Log_level) {
145	va_end(args);
146	return;
147	}
148
149	s = formf(buffer, sizeof(buffer), fmt, args);
150	va_end(args);
151	write_logstr(s, FALSE);
152
153	if (s != buffer)
154	free(s); /* allocated by formf() */
155	}
156
157	int
158	logf_set_level(new_level)
159	int new_level;
160	{
161	int old;
162
163	old = Log_level;
164	Log_level = new_level;
165	logf(LG_LOG, "Log level changed from %d to %d", old, new_level);
166
167	return old;
168	}
169
170
171	void
172	logf_errf_ofunc(str)
173	const char *str;
174	{
175	write_logstr(str, TRUE);
176	}