trunk/src/log.c

/*
 *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
 *  s_log.c: Logger functions.
 *
 *  Copyright (C) 2002 by the past and present ircd coders, and others.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *  USA
 *
 *  $Id$
 */

#include "stdinc.h"

#ifdef USE_SYSLOG
# ifdef HAVE_SYS_SYSLOG_H
#  include <sys/syslog.h>
# else
#  ifdef HAVE_SYSLOG_H
#   include <syslog.h>
#  endif
# endif
#endif

#include "client.h"     /* Needed for struct Client */
#include "s_log.h"
#include "fileio.h"
#include "irc_string.h"
#include "sprintf_irc.h"
#include "ircd.h"
#include "s_misc.h"
#include "event.h"      /* Needed for EVH etc. */
#include "s_conf.h"
#include "memory.h"

/* some older syslogs would overflow at 2024 */
#define LOG_BUFSIZE 2000

static FBFILE *logFile;
static int logLevel = INIT_LOG_LEVEL;

#ifndef SYSLOG_USERS
static EVH user_log_resync;
static FBFILE *user_log_fb = NULL;
#endif


#ifdef USE_SYSLOG
static const int sysLogLevel[] =
{
  LOG_CRIT,
  LOG_ERR,
  LOG_WARNING,
  LOG_NOTICE,
  LOG_INFO,
  LOG_INFO,
  LOG_INFO
};
#endif

static const char *logLevelToString[] =
{
  "L_CRIT",
  "L_ERROR",
  "L_WARN",
  "L_NOTICE",
  "L_TRACE",
  "L_INFO",
  "L_DEBUG"
};

/*
 * open_log - open ircd logging file
 * returns true (1) if successful, false (0) otherwise
 */
static int 
open_log(const char *filename)
{
  logFile = fbopen(filename, "a");

  if (logFile == NULL)
  {
#ifdef USE_SYSLOG
    syslog(LOG_ERR, "Unable to open log file: %s: %s",
           filename, strerror(errno));
#endif
    return (0);
  }

  return (1);
}

static void 
write_log(const char *message)
{
  char buf[LOG_BUFSIZE];
  size_t nbytes = 0;

  if (logFile == NULL)
    return;

  nbytes = snprintf(buf, sizeof(buf), "[%s] %s\n",
                    smalldate(CurrentTime), message);

  fbputs(buf, logFile, nbytes);
}
   
void
ilog(const int priority, const char *fmt, ...)
{
  char buf[LOG_BUFSIZE];
  va_list args;

  assert(priority > -1);

  if (fmt == NULL)
    return;

  if (priority > logLevel)
    return;

  va_start(args, fmt);
  vsnprintf(buf, sizeof(buf), fmt, args);
  va_end(args);

#ifdef USE_SYSLOG  
  if (priority <= L_DEBUG)
    syslog(sysLogLevel[priority], "%s", buf);
#endif
  if (ConfigLoggingEntry.use_logging)
    write_log(buf);
}
  
void
init_log(const char *filename)
{
  open_log(filename);
#ifdef USE_SYSLOG
  openlog("ircd", LOG_PID | LOG_NDELAY, LOG_FACILITY);
#endif
#ifndef SYSLOG_USERS
  eventAddIsh("user_log_resync", user_log_resync, NULL, 60);
#endif
}

void
reopen_log(const char *filename)
{
  if (logFile != NULL)
    fbclose(logFile);
  open_log(filename);
}

void
set_log_level(const int level)
{
  if (L_ERROR < level && level <= L_DEBUG)
    logLevel = level;
}

int
get_log_level(void)
{
  return(logLevel);
}

const char *
get_log_level_as_string(int level)
{
  if (level > L_DEBUG)
    level = L_DEBUG;
  else if (level < L_ERROR)
    level = L_ERROR;

  return(logLevelToString[level]);
}

/* log_user_exit()
 *
 * inputs       - pointer to connecting client
 * output       - NONE
 * side effects - Current exiting client is logged to
 *                either SYSLOG or to file.
 */
void
log_user_exit(struct Client *source_p)
{
  time_t on_for = CurrentTime - source_p->localClient->firsttime;
#ifdef SYSLOG_USERS
  if (IsClient(source_p))
  {
    ilog(L_INFO, "%s (%3u:%02u:%02u): %s!%s@%s %llu/%llu",
         myctime(source_p->localClient->firsttime), (unsigned int)(on_for / 3600),
         (unsigned int)((on_for % 3600)/60), (unsigned int)(on_for % 60),
         source_p->name, source_p->username, source_p->host,
         source_p->localClient->send.bytes>>10,
         source_p->localClient->recv.bytes>>10);
    }
#else
  {
    char linebuf[BUFSIZ];

    /*
     * This conditional makes the logfile active only after
     * it's been created - thus logging can be turned off by
     * removing the file.
     * -Taner
     */
    if (IsClient(source_p))
    {
      if (user_log_fb == NULL)
      {
        if ((ConfigLoggingEntry.userlog[0] != '\0') && 
           (user_log_fb = fbopen(ConfigLoggingEntry.userlog, "r")) != NULL)
        {
          fbclose(user_log_fb);
          user_log_fb = fbopen(ConfigLoggingEntry.userlog, "a");
        }
      }

      if (user_log_fb != NULL)
      {
        size_t nbytes = ircsprintf(linebuf,
                   "%s (%3u:%02u:%02u): %s!%s@%s %llu/%llu\n",
                   myctime(source_p->localClient->firsttime),
                   (unsigned int)(on_for / 3600),
                   (unsigned int)((on_for % 3600)/60),
                   (unsigned int)(on_for % 60),
                   source_p->name, source_p->username, source_p->host,
                   source_p->localClient->send.bytes>>10,
                   source_p->localClient->recv.bytes>>10);
        fbputs(linebuf, user_log_fb, nbytes);
      }
    }
  }
#endif
}

#ifndef SYSLOG_USERS
/* user_log_resync()
 *
 * inputs       - NONE
 * output       - NONE
 * side effects -
 */
static void
user_log_resync(void *notused)
{
  if (user_log_fb != NULL)
  {
    fbclose(user_log_fb);
    user_log_fb = NULL;
  }
}
#endif

/* log_oper_action()
 *
 * inputs       - type of oper log entry
 *              - pointer to oper
 *              - const char *pattern == format string
 *              - var args for format string
 * output       - none
 * side effects - corresponding log is written to, if its present.
 *
 * rewritten sept 5 2005 - Dianora
 */
void
log_oper_action(int log_type, const struct Client *source_p, 
                const char *pattern, ...)
{
  va_list args;
  char linebuf[IRCD_BUFSIZE];
  FBFILE *log_fb;
  char *logfile;
  const char *log_message;
  size_t nbytes;
  size_t n_preamble;
  char *p;

  switch(log_type)
  {
  case LOG_OPER_TYPE:
    logfile = ConfigLoggingEntry.operlog;
    log_message = "OPER";
    break;
  case LOG_FAILED_OPER_TYPE:
    logfile = ConfigLoggingEntry.failed_operlog;
    log_message = "FAILED OPER";
    break;
  case LOG_KLINE_TYPE:
    logfile = ConfigLoggingEntry.klinelog;
    log_message = "KLINE";
    break;
  case LOG_RKLINE_TYPE:
    logfile = ConfigLoggingEntry.klinelog;
    log_message = "RKLINE";
    break;
  case LOG_DLINE_TYPE:
    logfile = ConfigLoggingEntry.klinelog;
    log_message = "DLINE";
    break;
  case LOG_TEMP_DLINE_TYPE:
    logfile = ConfigLoggingEntry.klinelog;
    log_message = "TEMP DLINE";
    break;
  case LOG_TEMP_KLINE_TYPE:
    logfile = ConfigLoggingEntry.klinelog;
    log_message = "TEMP KLINE";
    break;
  case LOG_GLINE_TYPE:
    logfile = ConfigLoggingEntry.glinelog;
    log_message = "GLINE";
    break;
  case LOG_KILL_TYPE:
    logfile = ConfigLoggingEntry.killlog;
    log_message = "KILL";
    break;
  case LOG_IOERR_TYPE:
    logfile = ConfigLoggingEntry.ioerrlog;
    log_message = "IO ERR";
    break;
  default:
    return;
  }

  if (*logfile == '\0')
    return;

  p = linebuf;
  if (source_p != NULL)
  {
    n_preamble = ircsprintf(linebuf, "%s %s by (%s!%s@%s) :",
                            myctime(CurrentTime), log_message,
                            source_p->name, source_p->username, source_p->host);

  }
  else
  {
    n_preamble = ircsprintf(linebuf, "%s %s :",
                            myctime(CurrentTime), log_message);
  }

  p += n_preamble;

  if ((log_fb = fbopen(logfile, "r")) != NULL)
  {
    fbclose(log_fb);
    log_fb = fbopen(logfile, "a");
    if (log_fb == NULL)
      return;
    va_start(args, pattern);
    /* XXX add check for IRCD_BUFSIZE-(n_preamble+1) < 0 ? -db */
    nbytes = vsnprintf(p, IRCD_BUFSIZE-(n_preamble+1), pattern, args);
    nbytes += n_preamble;
    va_end(args);
    fbputs(linebuf, log_fb, nbytes);
    fbclose(log_fb);
  }
}
Revision:	1243
Committed:	Fri Sep 30 10:47:53 2011 UTC (13 years, 10 months ago) by michael
Content type:	text/x-csrc
Original Path:	*ircd-hybrid-8/src/s_log.c*
File size:	8051 byte(s)
Log Message:	- move content of msg.h, ircd_handler.h and handlers.h into parse.h and remove headers accordingly - killed common.h - remove m_killhost.c and m_flags.c from contrib/ - sort out unused header includes here and there
#	Content
1	/*
2	* ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3	* s_log.c: Logger functions.
4	*
5	* Copyright (C) 2002 by the past and present ircd coders, and others.
6	*
7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20	* USA
21	*
22	* $Id$
23	*/
24
25	#include "stdinc.h"
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 "s_log.h"
39	#include "fileio.h"
40	#include "irc_string.h"
41	#include "sprintf_irc.h"
42	#include "ircd.h"
43	#include "s_misc.h"
44	#include "event.h" /* Needed for EVH etc. */
45	#include "s_conf.h"
46	#include "memory.h"
47
48	/* some older syslogs would overflow at 2024 */
49	#define LOG_BUFSIZE 2000
50
51	static FBFILE *logFile;
52	static int logLevel = INIT_LOG_LEVEL;
53
54	#ifndef SYSLOG_USERS
55	static EVH user_log_resync;
56	static FBFILE *user_log_fb = NULL;
57	#endif
58
59
60	#ifdef USE_SYSLOG
61	static const int sysLogLevel[] =
62	{
63	LOG_CRIT,
64	LOG_ERR,
65	LOG_WARNING,
66	LOG_NOTICE,
67	LOG_INFO,
68	LOG_INFO,
69	LOG_INFO
70	};
71	#endif
72
73	static const char *logLevelToString[] =
74	{
75	"L_CRIT",
76	"L_ERROR",
77	"L_WARN",
78	"L_NOTICE",
79	"L_TRACE",
80	"L_INFO",
81	"L_DEBUG"
82	};
83
84	/*
85	* open_log - open ircd logging file
86	* returns true (1) if successful, false (0) otherwise
87	*/
88	static int
89	open_log(const char *filename)
90	{
91	logFile = fbopen(filename, "a");
92
93	if (logFile == NULL)
94	{
95	#ifdef USE_SYSLOG
96	syslog(LOG_ERR, "Unable to open log file: %s: %s",
97	filename, strerror(errno));
98	#endif
99	return (0);
100	}
101
102	return (1);
103	}
104
105	static void
106	write_log(const char *message)
107	{
108	char buf[LOG_BUFSIZE];
109	size_t nbytes = 0;
110
111	if (logFile == NULL)
112	return;
113
114	nbytes = snprintf(buf, sizeof(buf), "[%s] %s\n",
115	smalldate(CurrentTime), message);
116
117	fbputs(buf, logFile, nbytes);
118	}
119
120	void
121	ilog(const int priority, const char *fmt, ...)
122	{
123	char buf[LOG_BUFSIZE];
124	va_list args;
125
126	assert(priority > -1);
127
128	if (fmt == NULL)
129	return;
130
131	if (priority > logLevel)
132	return;
133
134	va_start(args, fmt);
135	vsnprintf(buf, sizeof(buf), fmt, args);
136	va_end(args);
137
138	#ifdef USE_SYSLOG
139	if (priority <= L_DEBUG)
140	syslog(sysLogLevel[priority], "%s", buf);
141	#endif
142	if (ConfigLoggingEntry.use_logging)
143	write_log(buf);
144	}
145
146	void
147	init_log(const char *filename)
148	{
149	open_log(filename);
150	#ifdef USE_SYSLOG
151	openlog("ircd", LOG_PID \| LOG_NDELAY, LOG_FACILITY);
152	#endif
153	#ifndef SYSLOG_USERS
154	eventAddIsh("user_log_resync", user_log_resync, NULL, 60);
155	#endif
156	}
157
158	void
159	reopen_log(const char *filename)
160	{
161	if (logFile != NULL)
162	fbclose(logFile);
163	open_log(filename);
164	}
165
166	void
167	set_log_level(const int level)
168	{
169	if (L_ERROR < level && level <= L_DEBUG)
170	logLevel = level;
171	}
172
173	int
174	get_log_level(void)
175	{
176	return(logLevel);
177	}
178
179	const char *
180	get_log_level_as_string(int level)
181	{
182	if (level > L_DEBUG)
183	level = L_DEBUG;
184	else if (level < L_ERROR)
185	level = L_ERROR;
186
187	return(logLevelToString[level]);
188	}
189
190	/* log_user_exit()
191	*
192	* inputs - pointer to connecting client
193	* output - NONE
194	* side effects - Current exiting client is logged to
195	* either SYSLOG or to file.
196	*/
197	void
198	log_user_exit(struct Client *source_p)
199	{
200	time_t on_for = CurrentTime - source_p->localClient->firsttime;
201	#ifdef SYSLOG_USERS
202	if (IsClient(source_p))
203	{
204	ilog(L_INFO, "%s (%3u:%02u:%02u): %s!%s@%s %llu/%llu",
205	myctime(source_p->localClient->firsttime), (unsigned int)(on_for / 3600),
206	(unsigned int)((on_for % 3600)/60), (unsigned int)(on_for % 60),
207	source_p->name, source_p->username, source_p->host,
208	source_p->localClient->send.bytes>>10,
209	source_p->localClient->recv.bytes>>10);
210	}
211	#else
212	{
213	char linebuf[BUFSIZ];
214
215	/*
216	* This conditional makes the logfile active only after
217	* it's been created - thus logging can be turned off by
218	* removing the file.
219	* -Taner
220	*/
221	if (IsClient(source_p))
222	{
223	if (user_log_fb == NULL)
224	{
225	if ((ConfigLoggingEntry.userlog[0] != '\0') &&
226	(user_log_fb = fbopen(ConfigLoggingEntry.userlog, "r")) != NULL)
227	{
228	fbclose(user_log_fb);
229	user_log_fb = fbopen(ConfigLoggingEntry.userlog, "a");
230	}
231	}
232
233	if (user_log_fb != NULL)
234	{
235	size_t nbytes = ircsprintf(linebuf,
236	"%s (%3u:%02u:%02u): %s!%s@%s %llu/%llu\n",
237	myctime(source_p->localClient->firsttime),
238	(unsigned int)(on_for / 3600),
239	(unsigned int)((on_for % 3600)/60),
240	(unsigned int)(on_for % 60),
241	source_p->name, source_p->username, source_p->host,
242	source_p->localClient->send.bytes>>10,
243	source_p->localClient->recv.bytes>>10);
244	fbputs(linebuf, user_log_fb, nbytes);
245	}
246	}
247	}
248	#endif
249	}
250
251	#ifndef SYSLOG_USERS
252	/* user_log_resync()
253	*
254	* inputs - NONE
255	* output - NONE
256	* side effects -
257	*/
258	static void
259	user_log_resync(void *notused)
260	{
261	if (user_log_fb != NULL)
262	{
263	fbclose(user_log_fb);
264	user_log_fb = NULL;
265	}
266	}
267	#endif
268
269	/* log_oper_action()
270	*
271	* inputs - type of oper log entry
272	* - pointer to oper
273	* - const char *pattern == format string
274	* - var args for format string
275	* output - none
276	* side effects - corresponding log is written to, if its present.
277	*
278	* rewritten sept 5 2005 - Dianora
279	*/
280	void
281	log_oper_action(int log_type, const struct Client *source_p,
282	const char *pattern, ...)
283	{
284	va_list args;
285	char linebuf[IRCD_BUFSIZE];
286	FBFILE *log_fb;
287	char *logfile;
288	const char *log_message;
289	size_t nbytes;
290	size_t n_preamble;
291	char *p;
292
293	switch(log_type)
294	{
295	case LOG_OPER_TYPE:
296	logfile = ConfigLoggingEntry.operlog;
297	log_message = "OPER";
298	break;
299	case LOG_FAILED_OPER_TYPE:
300	logfile = ConfigLoggingEntry.failed_operlog;
301	log_message = "FAILED OPER";
302	break;
303	case LOG_KLINE_TYPE:
304	logfile = ConfigLoggingEntry.klinelog;
305	log_message = "KLINE";
306	break;
307	case LOG_RKLINE_TYPE:
308	logfile = ConfigLoggingEntry.klinelog;
309	log_message = "RKLINE";
310	break;
311	case LOG_DLINE_TYPE:
312	logfile = ConfigLoggingEntry.klinelog;
313	log_message = "DLINE";
314	break;
315	case LOG_TEMP_DLINE_TYPE:
316	logfile = ConfigLoggingEntry.klinelog;
317	log_message = "TEMP DLINE";
318	break;
319	case LOG_TEMP_KLINE_TYPE:
320	logfile = ConfigLoggingEntry.klinelog;
321	log_message = "TEMP KLINE";
322	break;
323	case LOG_GLINE_TYPE:
324	logfile = ConfigLoggingEntry.glinelog;
325	log_message = "GLINE";
326	break;
327	case LOG_KILL_TYPE:
328	logfile = ConfigLoggingEntry.killlog;
329	log_message = "KILL";
330	break;
331	case LOG_IOERR_TYPE:
332	logfile = ConfigLoggingEntry.ioerrlog;
333	log_message = "IO ERR";
334	break;
335	default:
336	return;
337	}
338
339	if (*logfile == '\0')
340	return;
341
342	p = linebuf;
343	if (source_p != NULL)
344	{
345	n_preamble = ircsprintf(linebuf, "%s %s by (%s!%s@%s) :",
346	myctime(CurrentTime), log_message,
347	source_p->name, source_p->username, source_p->host);
348
349	}
350	else
351	{
352	n_preamble = ircsprintf(linebuf, "%s %s :",
353	myctime(CurrentTime), log_message);
354	}
355
356	p += n_preamble;
357
358	if ((log_fb = fbopen(logfile, "r")) != NULL)
359	{
360	fbclose(log_fb);
361	log_fb = fbopen(logfile, "a");
362	if (log_fb == NULL)
363	return;
364	va_start(args, pattern);
365	/* XXX add check for IRCD_BUFSIZE-(n_preamble+1) < 0 ? -db */
366	nbytes = vsnprintf(p, IRCD_BUFSIZE-(n_preamble+1), pattern, args);
367	nbytes += n_preamble;
368	va_end(args);
369	fbputs(linebuf, log_fb, nbytes);
370	fbclose(log_fb);
371	}
372	}