ermyth/src/logger.C

/*
 * logger.C: Logging routines
 * Rights to this code are documented in doc/pod/license.pod.
 *
 * Copyright © 2005-2007 Atheme Project (http://www.atheme.org)           
 */

static char const rcsid[] = "$Id";

#include "atheme.h"
#include <account/myuser.h>

static logfile_t *log_file;
int log_force;

static list_t log_files = { NULL, NULL, 0 };

/* private destructor function for logfile_t. */
static void
logfile_delete (void *vdata)
{
  logfile_t *lf = static_cast<logfile_t *> (vdata);

  logfile_unregister (lf);

  fclose (static_cast<FILE *> (lf->log_file));
  free (lf->log_path);
  free (lf);
}

/*
 * logfile_write(logfile_t *lf, const char *buf)
 *
 * Writes an I/O stream to a static file.
 *
 * Inputs:
 *       - logfile_t representing the I/O stream.
 *       - data to write to the file
 *
 * Outputs:
 *       - none
 *
 * Side Effects:
 *       - none
 */
void
logfile_write (logfile_t *lf, const char *buf)
{
  char datetime[64];
  time_t t;
  struct tm tm;

  return_if_fail (lf != NULL);
  return_if_fail (lf->log_file != NULL);
  return_if_fail (buf != NULL);

  time (&t);
  tm = *localtime (&t);
  strftime (datetime, sizeof (datetime) - 1, "[%d/%m/%Y %H:%M:%S]", &tm);

  fprintf ((FILE *) lf->log_file, "%s %s\n", datetime, buf);
  fflush ((FILE *) lf->log_file);
}

/*
 * logfile_register(logfile_t *lf)
 *
 * Registers a log I/O stream.
 *
 * Inputs:
 *       - logfile_t representing the I/O stream.
 *
 * Outputs:
 *       - none
 *
 * Side Effects:
 *       - log_files is populated with the given object.
 */
void
logfile_register (logfile_t *lf)
{
  node_add (lf, &lf->node, &log_files);
}

/*
 * logfile_unregister(logfile_t *lf)
 *
 * Registers a log I/O stream.
 *
 * Inputs:
 *       - logfile_t representing the I/O stream.
 *
 * Outputs:
 *       - none
 *
 * Side Effects:
 *       - log_files is populated with the given object.
 */
void
logfile_unregister (logfile_t *lf)
{
  node_del (&lf->node, &log_files);
}

/*
 * logfile_new(const char *log_path, unsigned int log_mask)
 *
 * Logfile object factory.
 *
 * Inputs:
 *       - path to new logfile
 *       - bitmask of events to log
 *
 * Outputs:
 *       - a logfile_t object describing how this logfile should be used
 *
 * Side Effects:
 *       - log_files is populated with the newly created logfile_t.
 */
logfile_t *
logfile_new (const char *path, unsigned int log_mask)
{
  static time_t lastfail = 0;
  logfile_t *lf = static_cast<logfile_t *> (scalloc (sizeof (logfile_t), 1));

  object_init (asobject (lf), path, logfile_delete);
  if ((lf->log_file = fopen (path, "a")) == NULL)
    {
      free (lf);

      if (me.connected && lastfail + 3600 < NOW)
        {
          lastfail = NOW;
          wallops (_("Could not open log file (%s), log entries will be missing!"), strerror (errno));
        }

      return NULL;
    }
#ifdef FD_CLOEXEC
  fcntl (fileno ((FILE *) lf->log_file), F_SETFD, FD_CLOEXEC);
#endif
  lf->log_path = sstrdup (path);
  lf->log_mask = log_mask;
  lf->write_func = logfile_write;

  logfile_register (lf);

  return lf;
}

/*
 * log_open(void)
 *
 * Initializes the logging subsystem.
 *
 * Inputs:
 *       - none
 *
 * Outputs:
 *       - none
 *
 * Side Effects:
 *       - the log_files list is populated with the master
 *         atheme.log reference.
 */
void
log_open (void)
{
  log_file = logfile_new (log_path, LG_ERROR | LG_INFO | LG_CMD_ADMIN);
}

/*
 * log_shutdown(void)
 *
 * Shuts down the logging subsystem.
 *
 * Inputs:
 *       - none
 *
 * Outputs:
 *       - none
 *
 * Side Effects:
 *       - logfile_t objects in the log_files list are destroyed.
 */
void
log_shutdown (void)
{
  node_t *n, *tn;

  LIST_FOREACH_SAFE (n, tn, log_files.head)
  {
    object_unref (n->data);
  }
}

/*
 * log_debug_enabled(void)
 *
 * Determines whether debug logging (LG_DEBUG and/or LG_RAWDATA) is enabled.
 *
 * Inputs:
 *       - none
 *
 * Outputs:
 *       - boolean
 *
 * Side Effects:
 *       - none
 */
bool
log_debug_enabled (void)
{
  node_t *n;
  logfile_t *lf;

  if (log_force)
    return true;
  LIST_FOREACH (n, log_files.head)
  {
    lf = static_cast<logfile_t *> (n->data);
    if (lf->log_mask & (LG_DEBUG | LG_RAWDATA))
      return true;
  }
  return false;
}

/*
 * log_master_set_mask(unsigned int mask)
 *
 * Sets the logging mask for the main log file.
 *
 * Inputs:
 *       - mask
 *
 * Outputs:
 *       - none
 *
 * Side Effects:
 *       - logging mask updated
 */
void
log_master_set_mask (unsigned int mask)
{
  /* couldn't be opened etc */
  if (log_file == NULL)
    return;
  log_file->log_mask = mask;
}

/*
 * slog(unsigned int level, const char *fmt, ...)
 *
 * Handles the basic logging of log messages to the log files defined
 * in the configuration file. All I/O is handled here, and no longer
 * in the various sourceinfo_t log transforms.
 *
 * Inputs:
 *       - a bitmask of the various log categories this event qualifies to
 *       - a printf-style format string
 *       - (optional) additional arguments to be used with that format string
 *
 * Outputs:
 *       - none
 *
 * Side Effects:
 *       - logfiles are updated depending on how they are configured.
 */
void
slog (unsigned int level, const char *fmt, ...)
{
  va_list args;
  char buf[BUFSIZE];
  node_t *n;
  char datetime[64];
  time_t t;
  struct tm tm;

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

  time (&t);
  tm = *localtime (&t);
  strftime (datetime, sizeof (datetime) - 1, "[%d/%m/%Y %H:%M:%S]", &tm);

  LIST_FOREACH (n, log_files.head)
  {
    logfile_t *lf = (logfile_t *) n->data;

    if ((lf != log_file || !log_force) && !(level & lf->log_mask))
      continue;

    return_if_fail (lf->write_func != NULL);

    lf->write_func (lf, buf);
  }

  /* 
   * if the event is in the default loglevel, and we are starting, then
   * display it in the controlling terminal.
   */
  if (((runflags & (RF_LIVE | RF_STARTING)) && (log_file != NULL ? log_file->log_mask : LG_ERROR | LG_INFO) & level) || ((runflags & RF_LIVE) && log_force))
    fprintf (stderr, "%s %s\n", datetime, buf);
}

/*
 * logcommand(sourceinfo_t *si, int level, const char *fmt, ...)
 *
 * Logs usage of a command from a user or other source (RPC call) as
 * described by sourceinfo_t.
 *
 * Inputs:
 *       - sourceinfo_t object which describes the source of the command call
 *       - bitmask of log categories to log the command use to.
 *       - printf-style format string
 *       - (optional) additional parameters
 *
 * Outputs:
 *       - none
 *
 * Side Effects:
 *       - qualifying logfile_t objects in log_files are updated.
 */
void
logcommand (sourceinfo_t *si, int level, const char *fmt, ...)
{
  va_list args;
  char lbuf[BUFSIZE];

  va_start (args, fmt);
  vsnprintf (lbuf, BUFSIZE, fmt, args);
  va_end (args);
  if (si->su != NULL)
    logcommand_user (si->service, si->su, level, "%s", lbuf);
  else
    logcommand_external (si->service, si->v != NULL ? si->v->description : "unknown", si->connection, si->sourcedesc, si->smu, level, "%s", lbuf);
}

/*
 * logcommand_user(service_t *svs, user_t *source, int level, const char *fmt, ...)
 *
 * Logs usage of a command from a user as described by sourceinfo_t.
 *
 * Inputs:
 *       - service_t object which describes the service the command is attached to
 *       - user_t object which describes the source of the command call
 *       - bitmask of log categories to log the command use to.
 *       - printf-style format string
 *       - (optional) additional parameters
 *
 * Outputs:
 *       - none
 *
 * Side Effects:
 *       - qualifying logfile_t objects in log_files are updated.
 */
void
logcommand_user (service_t *svs, user_t *source, int level, const char *fmt, ...)
{
  va_list args;
  char lbuf[BUFSIZE];

  va_start (args, fmt);
  vsnprintf (lbuf, BUFSIZE, fmt, args);
  va_end (args);

  slog (level, "%s %s:%s!%s@%s[%s] %s", svs != NULL ? svs->name : me.name, source->myuser != NULL ? source->myuser->name : "", source->nick, source->user, source->vhost, source->ip[0] != '\0' ? source->ip : source->host, lbuf);
}

/*
 * logcommand_external(service_t *svs, const char *type, connection_t *source,
 *       const char *sourcedesc, myuser_t *login, int level, const char *fmt, ...)
 *
 * Logs usage of a command from an RPC call as described by sourceinfo_t.
 *
 * Inputs:
 *       - service_t object which describes the service the command is attached to
 *       - string which describes the type of RPC call
 *       - connection_t which describes the socket source of the RPC call
 *       - string which describes the socket source of the RPC call
 *       - myuser_t which describes the services account used for the RPC call
 *       - bitmask of log categories to log the command use to.
 *       - printf-style format string
 *       - (optional) additional parameters
 *
 * Outputs:
 *       - none
 *
 * Side Effects:
 *       - qualifying logfile_t objects in log_files are updated.
 */
void
logcommand_external (service_t *svs, const char *type, connection_t *source, const char *sourcedesc, myuser_t *login, int level, const char *fmt, ...)
{
  va_list args;
  char lbuf[BUFSIZE];

  va_start (args, fmt);
  vsnprintf (lbuf, BUFSIZE, fmt, args);
  va_end (args);

  slog (level, "%s %s:%s(%s)[%s] %s", svs != NULL ? svs->name : me.name, login != NULL ? login->name : "", type, source != NULL ? source->hbuf : "<noconn>", sourcedesc != NULL ? sourcedesc : "<unknown>", lbuf);
}
Revision:	1.2
Committed:	Sat Jul 21 01:29:12 2007 UTC (16 years, 10 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Changes since 1.1:	+1 -1 lines
Log Message:	- moved to new documentation system - fixed small build error
#	Content
1	/*
2	* logger.C: Logging routines
3	* Rights to this code are documented in doc/pod/license.pod.
4	*
5	* Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
6	*/
7
8	static char const rcsid[] = "$Id";
9
10	#include "atheme.h"
11	#include <account/myuser.h>
12
13	static logfile_t *log_file;
14	int log_force;
15
16	static list_t log_files = { NULL, NULL, 0 };
17
18	/* private destructor function for logfile_t. */
19	static void
20	logfile_delete (void *vdata)
21	{
22	logfile_t lf = static_cast<logfile_t > (vdata);
23
24	logfile_unregister (lf);
25
26	fclose (static_cast<FILE *> (lf->log_file));
27	free (lf->log_path);
28	free (lf);
29	}
30
31	/*
32	* logfile_write(logfile_t lf, const char buf)
33	*
34	* Writes an I/O stream to a static file.
35	*
36	* Inputs:
37	* - logfile_t representing the I/O stream.
38	* - data to write to the file
39	*
40	* Outputs:
41	* - none
42	*
43	* Side Effects:
44	* - none
45	*/
46	void
47	logfile_write (logfile_t lf, const char buf)
48	{
49	char datetime[64];
50	time_t t;
51	struct tm tm;
52
53	return_if_fail (lf != NULL);
54	return_if_fail (lf->log_file != NULL);
55	return_if_fail (buf != NULL);
56
57	time (&t);
58	tm = *localtime (&t);
59	strftime (datetime, sizeof (datetime) - 1, "[%d/%m/%Y %H:%M:%S]", &tm);
60
61	fprintf ((FILE *) lf->log_file, "%s %s\n", datetime, buf);
62	fflush ((FILE *) lf->log_file);
63	}
64
65	/*
66	* logfile_register(logfile_t *lf)
67	*
68	* Registers a log I/O stream.
69	*
70	* Inputs:
71	* - logfile_t representing the I/O stream.
72	*
73	* Outputs:
74	* - none
75	*
76	* Side Effects:
77	* - log_files is populated with the given object.
78	*/
79	void
80	logfile_register (logfile_t *lf)
81	{
82	node_add (lf, &lf->node, &log_files);
83	}
84
85	/*
86	* logfile_unregister(logfile_t *lf)
87	*
88	* Registers a log I/O stream.
89	*
90	* Inputs:
91	* - logfile_t representing the I/O stream.
92	*
93	* Outputs:
94	* - none
95	*
96	* Side Effects:
97	* - log_files is populated with the given object.
98	*/
99	void
100	logfile_unregister (logfile_t *lf)
101	{
102	node_del (&lf->node, &log_files);
103	}
104
105	/*
106	* logfile_new(const char *log_path, unsigned int log_mask)
107	*
108	* Logfile object factory.
109	*
110	* Inputs:
111	* - path to new logfile
112	* - bitmask of events to log
113	*
114	* Outputs:
115	* - a logfile_t object describing how this logfile should be used
116	*
117	* Side Effects:
118	* - log_files is populated with the newly created logfile_t.
119	*/
120	logfile_t *
121	logfile_new (const char *path, unsigned int log_mask)
122	{
123	static time_t lastfail = 0;
124	logfile_t lf = static_cast<logfile_t > (scalloc (sizeof (logfile_t), 1));
125
126	object_init (asobject (lf), path, logfile_delete);
127	if ((lf->log_file = fopen (path, "a")) == NULL)
128	{
129	free (lf);
130
131	if (me.connected && lastfail + 3600 < NOW)
132	{
133	lastfail = NOW;
134	wallops (_("Could not open log file (%s), log entries will be missing!"), strerror (errno));
135	}
136
137	return NULL;
138	}
139	#ifdef FD_CLOEXEC
140	fcntl (fileno ((FILE *) lf->log_file), F_SETFD, FD_CLOEXEC);
141	#endif
142	lf->log_path = sstrdup (path);
143	lf->log_mask = log_mask;
144	lf->write_func = logfile_write;
145
146	logfile_register (lf);
147
148	return lf;
149	}
150
151	/*
152	* log_open(void)
153	*
154	* Initializes the logging subsystem.
155	*
156	* Inputs:
157	* - none
158	*
159	* Outputs:
160	* - none
161	*
162	* Side Effects:
163	* - the log_files list is populated with the master
164	* atheme.log reference.
165	*/
166	void
167	log_open (void)
168	{
169	log_file = logfile_new (log_path, LG_ERROR \| LG_INFO \| LG_CMD_ADMIN);
170	}
171
172	/*
173	* log_shutdown(void)
174	*
175	* Shuts down the logging subsystem.
176	*
177	* Inputs:
178	* - none
179	*
180	* Outputs:
181	* - none
182	*
183	* Side Effects:
184	* - logfile_t objects in the log_files list are destroyed.
185	*/
186	void
187	log_shutdown (void)
188	{
189	node_t n, tn;
190
191	LIST_FOREACH_SAFE (n, tn, log_files.head)
192	{
193	object_unref (n->data);
194	}
195	}
196
197	/*
198	* log_debug_enabled(void)
199	*
200	* Determines whether debug logging (LG_DEBUG and/or LG_RAWDATA) is enabled.
201	*
202	* Inputs:
203	* - none
204	*
205	* Outputs:
206	* - boolean
207	*
208	* Side Effects:
209	* - none
210	*/
211	bool
212	log_debug_enabled (void)
213	{
214	node_t *n;
215	logfile_t *lf;
216
217	if (log_force)
218	return true;
219	LIST_FOREACH (n, log_files.head)
220	{
221	lf = static_cast<logfile_t *> (n->data);
222	if (lf->log_mask & (LG_DEBUG \| LG_RAWDATA))
223	return true;
224	}
225	return false;
226	}
227
228	/*
229	* log_master_set_mask(unsigned int mask)
230	*
231	* Sets the logging mask for the main log file.
232	*
233	* Inputs:
234	* - mask
235	*
236	* Outputs:
237	* - none
238	*
239	* Side Effects:
240	* - logging mask updated
241	*/
242	void
243	log_master_set_mask (unsigned int mask)
244	{
245	/* couldn't be opened etc */
246	if (log_file == NULL)
247	return;
248	log_file->log_mask = mask;
249	}
250
251	/*
252	* slog(unsigned int level, const char *fmt, ...)
253	*
254	* Handles the basic logging of log messages to the log files defined
255	* in the configuration file. All I/O is handled here, and no longer
256	* in the various sourceinfo_t log transforms.
257	*
258	* Inputs:
259	* - a bitmask of the various log categories this event qualifies to
260	* - a printf-style format string
261	* - (optional) additional arguments to be used with that format string
262	*
263	* Outputs:
264	* - none
265	*
266	* Side Effects:
267	* - logfiles are updated depending on how they are configured.
268	*/
269	void
270	slog (unsigned int level, const char *fmt, ...)
271	{
272	va_list args;
273	char buf[BUFSIZE];
274	node_t *n;
275	char datetime[64];
276	time_t t;
277	struct tm tm;
278
279	va_start (args, fmt);
280	vsnprintf (buf, BUFSIZE, fmt, args);
281	va_end (args);
282
283	time (&t);
284	tm = *localtime (&t);
285	strftime (datetime, sizeof (datetime) - 1, "[%d/%m/%Y %H:%M:%S]", &tm);
286
287	LIST_FOREACH (n, log_files.head)
288	{
289	logfile_t lf = (logfile_t ) n->data;
290
291	if ((lf != log_file \|\| !log_force) && !(level & lf->log_mask))
292	continue;
293
294	return_if_fail (lf->write_func != NULL);
295
296	lf->write_func (lf, buf);
297	}
298
299	/*
300	* if the event is in the default loglevel, and we are starting, then
301	* display it in the controlling terminal.
302	*/
303	if (((runflags & (RF_LIVE \| RF_STARTING)) && (log_file != NULL ? log_file->log_mask : LG_ERROR \| LG_INFO) & level) \|\| ((runflags & RF_LIVE) && log_force))
304	fprintf (stderr, "%s %s\n", datetime, buf);
305	}
306
307	/*
308	* logcommand(sourceinfo_t si, int level, const char fmt, ...)
309	*
310	* Logs usage of a command from a user or other source (RPC call) as
311	* described by sourceinfo_t.
312	*
313	* Inputs:
314	* - sourceinfo_t object which describes the source of the command call
315	* - bitmask of log categories to log the command use to.
316	* - printf-style format string
317	* - (optional) additional parameters
318	*
319	* Outputs:
320	* - none
321	*
322	* Side Effects:
323	* - qualifying logfile_t objects in log_files are updated.
324	*/
325	void
326	logcommand (sourceinfo_t si, int level, const char fmt, ...)
327	{
328	va_list args;
329	char lbuf[BUFSIZE];
330
331	va_start (args, fmt);
332	vsnprintf (lbuf, BUFSIZE, fmt, args);
333	va_end (args);
334	if (si->su != NULL)
335	logcommand_user (si->service, si->su, level, "%s", lbuf);
336	else
337	logcommand_external (si->service, si->v != NULL ? si->v->description : "unknown", si->connection, si->sourcedesc, si->smu, level, "%s", lbuf);
338	}
339
340	/*
341	* logcommand_user(service_t svs, user_t source, int level, const char *fmt, ...)
342	*
343	* Logs usage of a command from a user as described by sourceinfo_t.
344	*
345	* Inputs:
346	* - service_t object which describes the service the command is attached to
347	* - user_t object which describes the source of the command call
348	* - bitmask of log categories to log the command use to.
349	* - printf-style format string
350	* - (optional) additional parameters
351	*
352	* Outputs:
353	* - none
354	*
355	* Side Effects:
356	* - qualifying logfile_t objects in log_files are updated.
357	*/
358	void
359	logcommand_user (service_t svs, user_t source, int level, const char *fmt, ...)
360	{
361	va_list args;
362	char lbuf[BUFSIZE];
363
364	va_start (args, fmt);
365	vsnprintf (lbuf, BUFSIZE, fmt, args);
366	va_end (args);
367
368	slog (level, "%s %s:%s!%s@%s[%s] %s", svs != NULL ? svs->name : me.name, source->myuser != NULL ? source->myuser->name : "", source->nick, source->user, source->vhost, source->ip[0] != '\0' ? source->ip : source->host, lbuf);
369	}
370
371	/*
372	* logcommand_external(service_t svs, const char type, connection_t *source,
373	* const char sourcedesc, myuser_t login, int level, const char *fmt, ...)
374	*
375	* Logs usage of a command from an RPC call as described by sourceinfo_t.
376	*
377	* Inputs:
378	* - service_t object which describes the service the command is attached to
379	* - string which describes the type of RPC call
380	* - connection_t which describes the socket source of the RPC call
381	* - string which describes the socket source of the RPC call
382	* - myuser_t which describes the services account used for the RPC call
383	* - bitmask of log categories to log the command use to.
384	* - printf-style format string
385	* - (optional) additional parameters
386	*
387	* Outputs:
388	* - none
389	*
390	* Side Effects:
391	* - qualifying logfile_t objects in log_files are updated.
392	*/
393	void
394	logcommand_external (service_t svs, const char type, connection_t source, const char sourcedesc, myuser_t login, int level, const char fmt, ...)
395	{
396	va_list args;
397	char lbuf[BUFSIZE];
398
399	va_start (args, fmt);
400	vsnprintf (lbuf, BUFSIZE, fmt, args);
401	va_end (args);
402
403	slog (level, "%s %s:%s(%s)[%s] %s", svs != NULL ? svs->name : me.name, login != NULL ? login->name : "", type, source != NULL ? source->hbuf : "<noconn>", sourcedesc != NULL ? sourcedesc : "<unknown>", lbuf);
404	}