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"

#include "s_log.h"
#include "fileio.h"
#include "irc_string.h"
#include "sprintf_irc.h"
#include "ircd.h"
#include "s_misc.h"
#include "s_conf.h"
#include "memory.h"

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

static struct {
  char path[PATH_MAX + 1];
  size_t size;
  FBFILE *file;
} log_type_table[LOG_TYPE_LAST];


int
log_add_file(unsigned int type, size_t size, const char *path)
{
  if (log_type_table[type].file)
    fbclose(log_type_table[type].file);
  else
    log_type_table[type].file = MyMalloc(sizeof(FBFILE));

  strlcpy(log_type_table[type].path, path, sizeof(log_type_table[type].path));

  return (log_type_table[type].file = fbopen(path, "a")) != NULL;
}

void
log_close_all(void)
{
  unsigned int type = 0;

  while (++type < LOG_TYPE_LAST)
  {
    if (log_type_table[type].file == NULL)
      continue;

    fbclose(log_type_table[type].file);
    MyFree(log_type_table[type].file);
  }
}

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

  if (log_type_table[type].file == NULL)
    return;

  if (ConfigLoggingEntry.timestamp)
    nbytes = snprintf(buf, sizeof(buf), "[%s] %s\n",
                      smalldate(CurrentTime), message);
  else
    nbytes = snprintf(buf, sizeof(buf), "%s\n", message);

  fbputs(buf, log_type_table[type].file, nbytes);
}
   
void
ilog(unsigned int type, const char *fmt, ...)
{
  char buf[LOG_BUFSIZE];
  va_list args;

  assert(fmt);
  assert(type >= 0 && type < LOG_TYPE_LAST);

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

  if (ConfigLoggingEntry.use_logging)
    write_log(type, buf);
} 
Revision:	1247
Committed:	Sat Oct 1 07:54:24 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:	2621 byte(s)
Log Message:	- Rewrite and cleanup half-broken logging subsystem. Logfile rotating is not working yet
#	User	Rev	Content
1	adx	30	/*
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	knight	31	* $Id$
23	adx	30	*/
24
25			#include "stdinc.h"
26
27			#include "s_log.h"
28			#include "fileio.h"
29			#include "irc_string.h"
30			#include "sprintf_irc.h"
31			#include "ircd.h"
32			#include "s_misc.h"
33			#include "s_conf.h"
34			#include "memory.h"
35
36			/* some older syslogs would overflow at 2024 */
37			#define LOG_BUFSIZE 2000
38
39	michael	1247	static struct {
40			char path[PATH_MAX + 1];
41			size_t size;
42			FBFILE *file;
43			} log_type_table[LOG_TYPE_LAST];
44	adx	30
45
46	michael	1247	int
47			log_add_file(unsigned int type, size_t size, const char *path)
48	adx	30	{
49	michael	1247	if (log_type_table[type].file)
50			fbclose(log_type_table[type].file);
51			else
52			log_type_table[type].file = MyMalloc(sizeof(FBFILE));
53	adx	30
54	michael	1247	strlcpy(log_type_table[type].path, path, sizeof(log_type_table[type].path));
55	adx	30
56	michael	1247	return (log_type_table[type].file = fbopen(path, "a")) != NULL;
57			}
58
59			void
60			log_close_all(void)
61	adx	30	{
62	michael	1247	unsigned int type = 0;
63	adx	30
64	michael	1247	while (++type < LOG_TYPE_LAST)
65	adx	30	{
66	michael	1247	if (log_type_table[type].file == NULL)
67			continue;
68
69			fbclose(log_type_table[type].file);
70			MyFree(log_type_table[type].file);
71	adx	30	}
72			}
73
74			static void
75	michael	1247	write_log(unsigned int type, const char *message)
76	adx	30	{
77			char buf[LOG_BUFSIZE];
78			size_t nbytes = 0;
79
80	michael	1247	if (log_type_table[type].file == NULL)
81	adx	30	return;
82
83	michael	1247	if (ConfigLoggingEntry.timestamp)
84			nbytes = snprintf(buf, sizeof(buf), "[%s] %s\n",
85			smalldate(CurrentTime), message);
86			else
87			nbytes = snprintf(buf, sizeof(buf), "%s\n", message);
88	michael	1001
89	michael	1247	fbputs(buf, log_type_table[type].file, nbytes);
90	adx	30	}
91
92			void
93	michael	1247	ilog(unsigned int type, const char *fmt, ...)
94	adx	30	{
95			char buf[LOG_BUFSIZE];
96			va_list args;
97
98	michael	1247	assert(fmt);
99			assert(type >= 0 && type < LOG_TYPE_LAST);
100	adx	30
101			va_start(args, fmt);
102	michael	1086	vsnprintf(buf, sizeof(buf), fmt, args);
103	adx	30	va_end(args);
104
105			if (ConfigLoggingEntry.use_logging)
106	michael	1247	write_log(type, buf);
107			}