src/logcache.c File Reference

#include "copyright.h"
#include "config.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <signal.h>
#include <errno.h>
#include "mudconf.h"
#include "externs.h"
#include "interface.h"
#include "flags.h"
#include "command.h"
#include "attrs.h"
#include "rbtree.h"
#include "debug.h"

Include dependency graph for logcache.c:

Go to the source code of this file.

Data Structures
struct	logfile_t
Defines
#define	LOGFILE_TIMEOUT   300
Functions
static int	logcache_compare (void *vleft, void *vright, void *arg)
static int	logcache_close (struct logfile_t *log)
static void	logcache_expire (int fd, short event, void *arg)
static int	_logcache_list (void *key, void *data, int depth, void *arg)
void	logcache_list (dbref player)
static int	logcache_open (char *filename)
void	logcache_init ()
static int	_logcache_destruct (void *key, void *data, int depth, void *arg)
void	logcache_destruct ()
int	logcache_writelog (char *fname, char *fdata)
Variables
rbtree	logfiles = NULL

---

Define Documentation

#define LOGFILE_TIMEOUT   300

Definition at line 38 of file logcache.c.

Referenced by logcache_open(), and logcache_writelog().

---

Function Documentation

static int _logcache_destruct	(	void *	key,
		void *	data,
		int	depth,
		void *	arg
	)			[static]

Definition at line 140 of file logcache.c.

References logcache_close().

Referenced by logcache_destruct().

{
        struct logfile_t *log = (struct logfile_t *) data;
        logcache_close(log);
        return 1;
}

static int _logcache_list	(	void *	key,
		void *	data,
		int	depth,
		void *	arg
	)			[static]

Definition at line 75 of file logcache.c.

References logfile_t::ev, logfile_t::filename, mudstate, notify_printf(), and statedata::now.

Referenced by logcache_list().

{
        struct timeval tv;
        struct logfile_t *log = (struct logfile_t *) data;
        dbref player = *(dbref *) arg;
        evtimer_pending(&log->ev, &tv);
        notify_printf(player, "%-40s%d", log->filename, tv.tv_sec - mudstate.now);
        return 1;
}

static int logcache_close

(

struct logfile_t *

log

)

[static]

Definition at line 53 of file logcache.c.

References dprintk, logfile_t::ev, logfile_t::fd, logfile_t::filename, logfiles, and rb_delete().

Referenced by _logcache_destruct(), logcache_expire(), and logcache_writelog().

{
        dprintk("closing logfile '%s'.", log->filename);
        if(evtimer_pending(&log->ev, NULL)) {
                evtimer_del(&log->ev);
        }
        close(log->fd);
        rb_delete(logfiles, log->filename);
        if(log->filename)
                free(log->filename);
        log->filename = NULL;
        log->fd = -1;
        free(log);
        return 1;
}

static int logcache_compare	(	void *	vleft,
		void *	vright,
		void *	arg
	)			[static]

Definition at line 48 of file logcache.c.

Referenced by logcache_init().

{
        return strcmp((char *) vleft, (char *) vright);
}

void logcache_destruct

(

)

Definition at line 147 of file logcache.c.

References _logcache_destruct(), dprintk, logfiles, rb_destroy(), rb_walk(), and WALK_INORDER.

Referenced by main(), and shutdown_services().

{
        dprintk("logcache destructing.");
        if(!logfiles) {
                dprintk("logcache_destruct() CALLED WHILE UNITIALIZED!");
                return;
        }
        rb_walk(logfiles, WALK_INORDER, _logcache_destruct, NULL);
        rb_destroy(logfiles);
        logfiles = NULL;
}

static void logcache_expire	(	int	fd,
		short	event,
		void *	arg
	)			[static]

Definition at line 69 of file logcache.c.

References dprintk, and logcache_close().

Referenced by logcache_open().

{
        dprintk("Expiring '%s'.", ((struct logfile_t *) arg)->filename);
        logcache_close((struct logfile_t *) arg);
}

void logcache_init

(

)

Definition at line 130 of file logcache.c.

References dprintk, logcache_compare(), logfiles, and rb_init().

Referenced by logcache_writelog(), and main().

{
        if(!logfiles) {
                dprintk("logcache initialized.");
                logfiles = rb_init(logcache_compare, NULL);
        } else {
                dprintk("REDUNDANT CALL TO logcache_init()!");
        }
}

void logcache_list

(

dbref

player

)

Definition at line 85 of file logcache.c.

References _logcache_list(), logfiles, notify, rb_size(), rb_walk(), and WALK_INORDER.

Referenced by do_list().

{
        notify(player, "/--------------------------- Open Logfiles");
        if(rb_size(logfiles) == 0) {
                notify(player, "- There are no open logfile handles.");
                return;
        }
        notify(player, "Filename                               Timeout");
        rb_walk(logfiles, WALK_INORDER, _logcache_list, &player);
}

static int logcache_open

(

char *

filename

)

[static]

Definition at line 96 of file logcache.c.

References dprintk, logfile_t::ev, logfile_t::fd, logfile_t::filename, log_perror(), logcache_expire(), LOGFILE_TIMEOUT, logfiles, rb_exists(), and rb_insert().

Referenced by logcache_writelog().

{
        int fd;
        struct logfile_t *newlog;
        struct timeval tv = { LOGFILE_TIMEOUT, 0 };

        if(rb_exists(logfiles, filename)) {
                fprintf(stderr,
                                "Serious braindamage, logcache_open() called for already open logfile.\n");
                return 0;
        }

        fd = open(filename, O_RDWR | O_APPEND | O_CREAT, 0644);
        if(fd < 0) {
                fprintf(stderr,
                                "Failed to open logfile %s because open() failed with code: %d -  %s\n",
                                filename, errno, strerror(errno));
                return 0;
        }
        if(fcntl(fd, F_SETFD, FD_CLOEXEC) < 0) {
                log_perror("LOGCACHE", "FAIL", NULL,
                                   "fcntl(fd, F_SETFD, FD_CLOEXEC)");
        }

        newlog = malloc(sizeof(struct logfile_t));
        newlog->fd = fd;
        newlog->filename = strdup(filename);
        evtimer_set(&newlog->ev, logcache_expire, newlog);
        evtimer_add(&newlog->ev, &tv);
        rb_insert(logfiles, newlog->filename, newlog);
        dprintk("opened logfile '%s' fd = %d.", filename, fd);
        return 1;
}

int logcache_writelog	(	char *	fname,
		char *	fdata
	)

Definition at line 159 of file logcache.c.

References logfile_t::ev, logfile_t::fd, logfile_t::filename, logcache_close(), logcache_init(), logcache_open(), LOGFILE_TIMEOUT, logfiles, and rb_find().

{
        struct logfile_t *log;
        struct timeval tv = { LOGFILE_TIMEOUT, 0 };
        int len;

        if(!logfiles)
                logcache_init();

        len = strlen(fdata);

        log = rb_find(logfiles, fname);

        if(!log) {
                if(logcache_open(fname) < 0) {
                        return 0;
                }
                log = rb_find(logfiles, fname);
                if(!log) {
                        return 0;
                }
        }

        if(evtimer_pending(&log->ev, NULL)) {
                event_del(&log->ev);
                event_add(&log->ev, &tv);
        }

        if(write(log->fd, fdata, len) < 0) {
                fprintf(stderr,
                                "System failed to write data to file with error '%s' on logfile '%s'. Closing.\n",
                                strerror(errno), log->filename);
                logcache_close(log);
        }
        return 1;
}

---

Variable Documentation

rbtree logfiles = NULL

Definition at line 46 of file logcache.c.

Referenced by logcache_close(), logcache_destruct(), logcache_init(), logcache_list(), logcache_open(), and logcache_writelog().

---