libukcprog/src/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:	Sat Mar 29 16:30:33 2003 UTC (21 years, 9 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
CVS Tags:	LIBUKCPROG_1_0_2, LIBUKCPROG_1_0_1, LIBUKCPROG_1_0, HEAD
Log Message:	libukcprog is now a seperate package. I doubt this will be much use to anyone other than us, but I see no reason why we can't package it up and distribute it. Obviously we can't attach the GPL to this, as we don't own it.
#	User	Rev	Content
1	tdb	1.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			}