ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/trunk/src/log.c

Comparing:
ircd-hybrid/src/s_log.c (file contents), Revision 31 by knight, Sun Oct 2 20:34:05 2005 UTC vs.
ircd-hybrid/trunk/src/log.c (file contents), Revision 3215 by michael, Tue Mar 25 19:23:15 2014 UTC

#	Line 1 | Line 1
1		/*
2	<	*  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3	<	*  s_log.c: Logger functions.
2	>	*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (C) 2002 by the past and present ircd coders, and others.
4	>	*  Copyright (c) 1997-2014 ircd-hybrid development team
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 18 | Line 17
17		*  along with this program; if not, write to the Free Software
18		*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
19		*  USA
21	–	*
22	–	*  $Id$
20		*/
21
22	<	#include "stdinc.h"
22	>	/*! \file log.c
23	>	* \brief Logger functions.
24	>	* \version $Id$
25	>	*/
26
27	<	#ifdef USE_SYSLOG
28	<	# ifdef HAVE_SYS_SYSLOG_H
29	<	#  include <sys/syslog.h>
30	<	# else
31	<	#  ifdef HAVE_SYSLOG_H
32	<	#   include <syslog.h>
33	<	#  endif
34	<	# endif
35	<	#endif
36	<
37	<	#include "client.h"     /* Needed for struct Client */
38	<	#include "common.h"
39	<	#include "s_log.h"
40	<	#include "fileio.h"
27	>	#include "stdinc.h"
28	>	#include "log.h"
29		#include "irc_string.h"
42	–	#include "sprintf_irc.h"
30		#include "ircd.h"
31	+	#include "conf.h"
32		#include "s_misc.h"
45	–	#include "event.h"      /* Needed for EVH etc. */
46	–	#include "s_conf.h"
47	–	#include "memory.h"
48	–
49	–	/* some older syslogs would overflow at 2024 */
50	–	#define LOG_BUFSIZE 2000
33
52	–	static FBFILE *logFile;
53	–	static int logLevel = INIT_LOG_LEVEL;
34
35	<	#ifndef SYSLOG_USERS
56	<	static EVH user_log_resync;
57	<	static FBFILE *user_log_fb = NULL;
58	<	#endif
59	<
60	<
61	<	#ifdef USE_SYSLOG
62	<	static const int sysLogLevel[] =
35	>	static struct
36		{
37	<	LOG_CRIT,
38	<	LOG_ERR,
39	<	LOG_WARNING,
40	<	LOG_NOTICE,
68	<	LOG_INFO,
69	<	LOG_INFO,
70	<	LOG_INFO
71	<	};
72	<	#endif
37	>	char path[HYB_PATH_MAX + 1];
38	>	size_t size;
39	>	FILE *file;
40	>	} log_type_table[LOG_TYPE_LAST];
41
74	–	static const char *logLevelToString[] =
75	–	{
76	–	"L_CRIT",
77	–	"L_ERROR",
78	–	"L_WARN",
79	–	"L_NOTICE",
80	–	"L_TRACE",
81	–	"L_INFO",
82	–	"L_DEBUG"
83	–	};
42
43	<	/*
44	<	* open_log - open ircd logging file
87	<	* returns true (1) if successful, false (0) otherwise
88	<	*/
89	<	static int
90	<	open_log(const char *filename)
43	>	void
44	>	log_set_file(enum log_type type, size_t size, const char *path)
45		{
46	<	logFile = fbopen(filename, "a");
47	<
94	<	if (logFile == NULL)
95	<	{
96	<	#ifdef USE_SYSLOG
97	<	syslog(LOG_ERR, "Unable to open log file: %s: %s",
98	<	filename, strerror(errno));
99	<	#endif
100	<	return (0);
101	<	}
46	>	strlcpy(log_type_table[type].path, path, sizeof(log_type_table[type].path));
47	>	log_type_table[type].size = size;
48
49	<	return (1);
49	>	if (type == LOG_TYPE_IRCD)
50	>	log_type_table[type].file = fopen(log_type_table[type].path, "a");
51		}
52
106	–	static void
107	–	write_log(const char *message)
108	–	{
109	–	char buf[LOG_BUFSIZE];
110	–	size_t nbytes = 0;
111	–
112	–	if (logFile == NULL)
113	–	return;
114	–
115	–	#ifdef _WIN32
116	–	nbytes = snprintf(buf, sizeof(buf), "[%s] %s\r\n",
117	–	#else
118	–	nbytes = snprintf(buf, sizeof(buf), "[%s] %s\n",
119	–	#endif
120	–	smalldate(CurrentTime), message);
121	–	fbputs(buf, logFile, nbytes);
122	–	}
123	–
53		void
54	<	ilog(const int priority, const char *fmt, ...)
54	>	log_del_all(void)
55		{
56	<	char buf[LOG_BUFSIZE];
128	<	va_list args;
129	<
130	<	assert(priority > -1);
131	<
132	<	if (fmt == NULL)
133	<	return;
134	<
135	<	if (priority > logLevel)
136	<	return;
137	<
138	<	va_start(args, fmt);
139	<	vsprintf(buf, fmt, args);
140	<	va_end(args);
56	>	unsigned int type = 0;
57
58	<	#ifdef USE_SYSLOG
59	<	if (priority <= L_DEBUG)
144	<	syslog(sysLogLevel[priority], "%s", buf);
145	<	#endif
146	<	if (ConfigLoggingEntry.use_logging)
147	<	write_log(buf);
148	<	}
149	<
150	<	void
151	<	init_log(const char *filename)
152	<	{
153	<	open_log(filename);
154	<	#ifdef USE_SYSLOG
155	<	openlog("ircd", LOG_PID | LOG_NDELAY, LOG_FACILITY);
156	<	#endif
157	<	#ifndef SYSLOG_USERS
158	<	eventAddIsh("user_log_resync", user_log_resync, NULL, 60);
159	<	#endif
58	>	while (++type < LOG_TYPE_LAST)
59	>	log_type_table[type].path[0] = '\0';
60		}
61
62		void
63	<	reopen_log(const char *filename)
63	>	log_reopen_all(void)
64		{
65	<	if (logFile != NULL)
166	<	fbclose(logFile);
167	<	open_log(filename);
168	<	}
65	>	unsigned int type = 0;
66
67	<	void
68	<	set_log_level(const int level)
69	<	{
70	<	if (L_ERROR < level && level <= L_DEBUG)
71	<	logLevel = level;
72	<	}
67	>	while (++type < LOG_TYPE_LAST)
68	>	{
69	>	if (log_type_table[type].file)
70	>	{
71	>	fclose(log_type_table[type].file);
72	>	log_type_table[type].file = NULL;
73	>	}
74
75	<	int
76	<	get_log_level(void)
77	<	{
180	<	return(logLevel);
75	>	if (log_type_table[type].path[0])
76	>	log_type_table[type].file = fopen(log_type_table[type].path, "a");
77	>	}
78		}
79
80	<	const char *
81	<	get_log_level_as_string(int level)
80	>	static int
81	>	log_exceed_size(unsigned int type)
82		{
83	<	if (level > L_DEBUG)
187	<	level = L_DEBUG;
188	<	else if (level < L_ERROR)
189	<	level = L_ERROR;
83	>	struct stat sb;
84
85	<	return(logLevelToString[level]);
86	<	}
85	>	if (!log_type_table[type].size)
86	>	return 0;
87
88	<	/* log_user_exit()
89	<	*
196	<	* inputs       - pointer to connecting client
197	<	* output       - NONE
198	<	* side effects - Current exiting client is logged to
199	<	*                either SYSLOG or to file.
200	<	*/
201	<	void
202	<	log_user_exit(struct Client *source_p)
203	<	{
204	<	time_t on_for = CurrentTime - source_p->firsttime;
205	<	#ifdef SYSLOG_USERS
206	<	if (IsClient(source_p))
207	<	{
208	<	ilog(L_INFO, "%s (%3ld:%02ld:%02ld): %s!%s@%s %llu/%llu\n",
209	<	myctime(source_p->firsttime),
210	<	(signed long) on_for / 3600,
211	<	(signed long) (on_for % 3600)/60,
212	<	(signed long) on_for % 60,
213	<	source_p->name, source_p->username, source_p->host,
214	<	source_p->localClient->send.bytes>>10,
215	<	source_p->localClient->recv.bytes>>10);
216	<	}
217	<	#else
218	<	{
219	<	char linebuf[BUFSIZ];
88	>	if (stat(log_type_table[type].path, &sb) < 0)
89	>	return -1;
90
91	<	/*
222	<	* This conditional makes the logfile active only after
223	<	* it's been created - thus logging can be turned off by
224	<	* removing the file.
225	<	* -Taner
226	<	*/
227	<	if (IsClient(source_p))
228	<	{
229	<	if (user_log_fb == NULL)
230	<	{
231	<	if ((ConfigLoggingEntry.userlog[0] != '\0') &&
232	<	(user_log_fb = fbopen(ConfigLoggingEntry.userlog, "r")) != NULL)
233	<	{
234	<	fbclose(user_log_fb);
235	<	user_log_fb = fbopen(ConfigLoggingEntry.userlog, "a");
236	<	}
237	<	}
238	<
239	<	if (user_log_fb != NULL)
240	<	{
241	<	size_t nbytes = ircsprintf(linebuf,
242	<	"%s (%3ld:%02ld:%02ld): %s!%s@%s %llu/%llu\n",
243	<	myctime(source_p->firsttime),
244	<	(signed long) on_for / 3600,
245	<	(signed long) (on_for % 3600)/60,
246	<	(signed long) on_for % 60,
247	<	source_p->name, source_p->username, source_p->host,
248	<	source_p->localClient->send.bytes>>10,
249	<	source_p->localClient->recv.bytes>>10);
250	<	fbputs(linebuf, user_log_fb, nbytes);
251	<	}
252	<	}
253	<	}
254	<	#endif
91	>	return (size_t)sb.st_size > log_type_table[type].size;
92		}
93
257	–	#ifndef SYSLOG_USERS
258	–	/* user_log_resync()
259	–	*
260	–	* inputs       - NONE
261	–	* output       - NONE
262	–	* side effects -
263	–	*/
94		static void
95	<	user_log_resync(void *notused)
95	>	log_write(enum log_type type, const char *message)
96		{
97	<	if (user_log_fb != NULL)
98	<	{
99	<	fbclose(user_log_fb);
100	<	user_log_fb = NULL;
101	<	}
97	>	char buf[IRCD_BUFSIZE] = "";
98	>
99	>	strftime(buf, sizeof(buf), "[%FT%H:%M:%S%z]", localtime(&CurrentTime));
100	>
101	>	fprintf(log_type_table[type].file, "%s %s\n", buf, message);
102	>	fflush(log_type_table[type].file);
103		}
273	–	#endif
104
275	–	/* log_oper_action()
276	–	*
277	–	* inputs       - type of oper log entry
278	–	*              - pointer to oper
279	–	*              - const char *pattern == format string
280	–	*              - var args for format string
281	–	* output       - none
282	–	* side effects - corresponding log is written to, if its present.
283	–	*
284	–	* rewritten sept 5 2005 - Dianora
285	–	*/
105		void
106	<	log_oper_action(int log_type, const struct Client *source_p,
288	<	const char *pattern, ...)
106	>	ilog(enum log_type type, const char *fmt, ...)
107		{
108	+	char buf[LOG_BUFSIZE] = "";
109		va_list args;
291	–	char linebuf[IRCD_BUFSIZE];
292	–	FBFILE *log_fb;
293	–	char *logfile;
294	–	const char *log_message;
295	–	size_t nbytes;
296	–	size_t n_preamble;
297	–	char *p;
110
111	<	switch(log_type)
300	<	{
301	<	case LOG_OPER_TYPE:
302	<	logfile = ConfigLoggingEntry.operlog;
303	<	log_message = "OPER";
304	<	break;
305	<	case LOG_FAILED_OPER_TYPE:
306	<	logfile = ConfigLoggingEntry.failed_operlog;
307	<	log_message = "FAILED OPER";
308	<	break;
309	<	case LOG_KLINE_TYPE:
310	<	logfile = ConfigLoggingEntry.klinelog;
311	<	log_message = "KLINE";
312	<	break;
313	<	case LOG_RKLINE_TYPE:
314	<	logfile = ConfigLoggingEntry.klinelog;
315	<	log_message = "RKLINE";
316	<	break;
317	<	case LOG_DLINE_TYPE:
318	<	logfile = ConfigLoggingEntry.klinelog;
319	<	log_message = "DLINE";
320	<	break;
321	<	case LOG_TEMP_DLINE_TYPE:
322	<	logfile = ConfigLoggingEntry.klinelog;
323	<	log_message = "TEMP DLINE";
324	<	break;
325	<	case LOG_TEMP_KLINE_TYPE:
326	<	logfile = ConfigLoggingEntry.klinelog;
327	<	log_message = "TEMP KLINE";
328	<	break;
329	<	case LOG_GLINE_TYPE:
330	<	logfile = ConfigLoggingEntry.glinelog;
331	<	log_message = "GLINE";
332	<	break;
333	<	case LOG_KILL_TYPE:
334	<	logfile = ConfigLoggingEntry.killlog;
335	<	log_message = "KILL";
336	<	break;
337	<	case LOG_IOERR_TYPE:
338	<	logfile = ConfigLoggingEntry.ioerrlog;
339	<	log_message = "IO ERR";
340	<	break;
341	<	default:
111	>	if (!log_type_table[type].file || !ConfigLoggingEntry.use_logging)
112		return;
343	–	}
113
114	<	if (*logfile == '\0')
115	<	return;
114	>	va_start(args, fmt);
115	>	vsnprintf(buf, sizeof(buf), fmt, args);
116	>	va_end(args);
117
118	<	p = linebuf;
349	<	if (source_p != NULL)
350	<	{
351	<	n_preamble = ircsprintf(linebuf, "%s %s by (%s!%s@%s) :",
352	<	myctime(CurrentTime), log_message,
353	<	source_p->name, source_p->username, source_p->host);
118	>	log_write(type, buf);
119
120	<	}
121	<	else
357	<	{
358	<	n_preamble = ircsprintf(linebuf, "%s %s :",
359	<	myctime(CurrentTime), log_message);
360	<	}
120	>	if (log_exceed_size(type) <= 0)
121	>	return;
122
123	<	p += n_preamble;
123	>	snprintf(buf, sizeof(buf), "Rotating logfile %s",
124	>	log_type_table[type].path);
125	>	log_write(type, buf);
126	>
127	>	fclose(log_type_table[type].file);
128	>	log_type_table[type].file = NULL;
129	>
130	>	snprintf(buf, sizeof(buf), "%s.old", log_type_table[type].path);
131	>	unlink(buf);
132	>	rename(log_type_table[type].path, buf);
133
134	<	if ((log_fb = fbopen(logfile, "r")) != NULL)
135	<	{
366	<	fbclose(log_fb);
367	<	log_fb = fbopen(logfile, "a");
368	<	if (log_fb == NULL)
369	<	return;
370	<	va_start(args, pattern);
371	<	/* XXX add check for IRCD_BUFSIZE-(n_preamble+1) < 0 ? -db */
372	<	nbytes = vsnprintf(p, IRCD_BUFSIZE-(n_preamble+1), pattern, args);
373	<	nbytes += n_preamble;
374	<	va_end(args);
375	<	fbputs(linebuf, log_fb, nbytes);
376	<	fbclose(log_fb);
377	<	}
134	>	log_set_file(type, log_type_table[type].size, log_type_table[type].path);
135	>	log_type_table[type].file = fopen(log_type_table[type].path, "a");
136		}

Comparing:
ircd-hybrid/src/s_log.c (property svn:keywords), Revision 31 by knight, Sun Oct 2 20:34:05 2005 UTC vs.
ircd-hybrid/trunk/src/log.c (property svn:keywords), Revision 3215 by michael, Tue Mar 25 19:23:15 2014 UTC

#	Line 1 | Line 1
1	<	"Id Revision"
1	>	Id Revision

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)