Seeding from the 1.2 tree.
This commit is contained in:
Dan Mashal
812
source/lastlog.c
Normal file
812
source/lastlog.c
Normal file
@@ -0,0 +1,812 @@
|
||||
/*
|
||||
* lastlog.c: handles the lastlog features of irc.
|
||||
*
|
||||
* Written By Michael Sandrof
|
||||
*
|
||||
* Copyright(c) 1990
|
||||
*
|
||||
* See the COPYRIGHT file, or do a HELP IRCII COPYRIGHT
|
||||
*/
|
||||
|
||||
|
||||
#include "irc.h"
|
||||
static char cvsrevision[] = "$Id: lastlog.c 3 2008-02-25 09:49:14Z keaston $";
|
||||
CVS_REVISION(lastlog_c)
|
||||
#include "struct.h"
|
||||
|
||||
#include "lastlog.h"
|
||||
#include "window.h"
|
||||
#include "screen.h"
|
||||
#include "vars.h"
|
||||
#include "ircaux.h"
|
||||
#include "output.h"
|
||||
#include "misc.h"
|
||||
#include "hook.h"
|
||||
#include "status.h"
|
||||
#define MAIN_SOURCE
|
||||
#include "modval.h"
|
||||
|
||||
extern int grab_http (char *, char *, char *);
|
||||
/*
|
||||
* lastlog_level: current bitmap setting of which things should be stored in
|
||||
* the lastlog. The LOG_MSG, LOG_NOTICE, etc., defines tell more about this
|
||||
*/
|
||||
static unsigned long lastlog_level;
|
||||
static unsigned long notify_level;
|
||||
|
||||
static unsigned long msglog_level = 0;
|
||||
unsigned long beep_on_level = 0;
|
||||
unsigned long new_server_lastlog_level = 0;
|
||||
unsigned long current_window_level = 0;
|
||||
|
||||
|
||||
FILE *logptr = NULL;
|
||||
|
||||
/*
|
||||
* msg_level: the mask for the current message level. What? Did he really
|
||||
* say that? This is set in the set_lastlog_msg_level() routine as it
|
||||
* compared to the lastlog_level variable to see if what ever is being added
|
||||
* should actually be added
|
||||
*/
|
||||
static unsigned long msg_level = LOG_CRAP;
|
||||
|
||||
static char *levels[] =
|
||||
{
|
||||
"CRAP", "PUBLIC", "MSGS", "NOTICES",
|
||||
"WALLS", "WALLOPS", "NOTES", "OPNOTES",
|
||||
"SNOTES", "ACTIONS", "DCC", "CTCP",
|
||||
"USERLOG1", "USERLOG2", "USERLOG3", "USERLOG4",
|
||||
"USERLOG5", "BEEP", "TCL", "SEND_MSG",
|
||||
"KILL", "MODEUSER", "MODECHAN", "KICK",
|
||||
"KICKUSER", "PARTS", "INVITES", "JOIN",
|
||||
"TOPIC", "HELP", "NOTIFY", "DEBUG"
|
||||
};
|
||||
|
||||
#define NUMBER_OF_LEVELS (sizeof(levels) / sizeof(char *))
|
||||
|
||||
|
||||
void reset_hold_mode(Window *win)
|
||||
{
|
||||
win->hold_mode = win->save_hold_mode;
|
||||
win->save_hold_mode = win->in_more = 0;
|
||||
}
|
||||
|
||||
/* set_lastlog_msg_level: sets the message level for recording in the lastlog */
|
||||
unsigned long BX_set_lastlog_msg_level(unsigned long level)
|
||||
{
|
||||
unsigned long old;
|
||||
|
||||
old = msg_level;
|
||||
msg_level = level;
|
||||
return (old);
|
||||
}
|
||||
|
||||
/*
|
||||
* bits_to_lastlog_level: converts the bitmap of lastlog levels into a nice
|
||||
* string format. Note that this uses the global buffer, so watch out
|
||||
*/
|
||||
char * bits_to_lastlog_level(unsigned long level)
|
||||
{
|
||||
static char buffer[481]; /* this *should* be enough for this */
|
||||
int i;
|
||||
unsigned long p;
|
||||
|
||||
if (level == LOG_ALL)
|
||||
strcpy(buffer, "ALL");
|
||||
else if (level == 0)
|
||||
strcpy(buffer, "NONE");
|
||||
else
|
||||
{
|
||||
*buffer = '\0';
|
||||
for (i = 0, p = 1; i < NUMBER_OF_LEVELS; i++, p <<= 1)
|
||||
{
|
||||
if (level & p)
|
||||
{
|
||||
if (*buffer)
|
||||
strmcat(buffer, space, 480);
|
||||
strmcat(buffer, levels[i],480);
|
||||
}
|
||||
}
|
||||
}
|
||||
return (buffer);
|
||||
}
|
||||
|
||||
unsigned long parse_lastlog_level(char *str, int display)
|
||||
{
|
||||
char *ptr,
|
||||
*rest;
|
||||
int len,
|
||||
i;
|
||||
unsigned long p,
|
||||
level;
|
||||
int neg;
|
||||
|
||||
level = 0;
|
||||
while ((str = next_arg(str, &rest)) != NULL)
|
||||
{
|
||||
while (str)
|
||||
{
|
||||
if ((ptr = strchr(str, ',')) != NULL)
|
||||
*ptr++ = '\0';
|
||||
if ((len = strlen(str)) != 0)
|
||||
{
|
||||
if (my_strnicmp(str, "ALL", len) == 0)
|
||||
level = LOG_ALL;
|
||||
else if (my_strnicmp(str, "NONE", len) == 0)
|
||||
level = 0;
|
||||
else
|
||||
{
|
||||
if (*str == '-')
|
||||
{
|
||||
str++; len--;
|
||||
neg = 1;
|
||||
}
|
||||
else
|
||||
neg = 0;
|
||||
for (i = 0, p = 1; i < NUMBER_OF_LEVELS; i++, p <<= 1)
|
||||
{
|
||||
if (!my_strnicmp(str, levels[i], len))
|
||||
{
|
||||
if (neg)
|
||||
level &= (LOG_ALL ^ p);
|
||||
else
|
||||
level |= p;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i == NUMBER_OF_LEVELS)
|
||||
{
|
||||
if (display)
|
||||
say("Unknown lastlog level: %s", str);
|
||||
return LOG_ALL;
|
||||
}
|
||||
}
|
||||
}
|
||||
str = ptr;
|
||||
}
|
||||
str = rest;
|
||||
}
|
||||
return (level);
|
||||
}
|
||||
|
||||
/*
|
||||
* set_lastlog_level: called whenever a "SET LASTLOG_LEVEL" is done. It
|
||||
* parses the settings and sets the lastlog_level variable appropriately. It
|
||||
* also rewrites the LASTLOG_LEVEL variable to make it look nice
|
||||
*/
|
||||
void set_lastlog_level(Window *win, char *str, int unused)
|
||||
{
|
||||
lastlog_level = parse_lastlog_level(str, 1);
|
||||
set_string_var(LASTLOG_LEVEL_VAR, bits_to_lastlog_level(lastlog_level));
|
||||
current_window->lastlog_level = lastlog_level;
|
||||
}
|
||||
|
||||
/*
|
||||
* set_msglog_level: called whenever a "SET MSGLOG_LEVEL" is done. It
|
||||
* parses the settings and sets the msglog_level variable appropriately. It
|
||||
* also rewrites the MSGLOG_LEVEL variable to make it look nice
|
||||
*/
|
||||
void set_msglog_level(Window *win, char *str, int unused)
|
||||
{
|
||||
msglog_level = parse_lastlog_level(str, 1);
|
||||
set_string_var(MSGLOG_LEVEL_VAR, bits_to_lastlog_level(msglog_level));
|
||||
}
|
||||
|
||||
void set_new_server_lastlog_level (Window *win, char *str, int unused)
|
||||
{
|
||||
new_server_lastlog_level = parse_lastlog_level(str, 1);
|
||||
set_string_var(NEW_SERVER_LASTLOG_LEVEL_VAR,
|
||||
bits_to_lastlog_level(new_server_lastlog_level));
|
||||
}
|
||||
|
||||
void remove_from_lastlog(Window *window)
|
||||
{
|
||||
Lastlog *tmp, *end_holder;
|
||||
|
||||
if (window->lastlog_tail)
|
||||
{
|
||||
end_holder = window->lastlog_tail;
|
||||
tmp = window->lastlog_tail->prev;
|
||||
window->lastlog_tail = tmp;
|
||||
if (tmp)
|
||||
tmp->next = NULL;
|
||||
else
|
||||
window->lastlog_head = window->lastlog_tail;
|
||||
window->lastlog_size--;
|
||||
new_free(&end_holder->msg);
|
||||
new_free((char **)&end_holder);
|
||||
}
|
||||
else
|
||||
window->lastlog_size = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* set_lastlog_size: sets up a lastlog buffer of size given. If the lastlog
|
||||
* has gotten larger than it was before, all previous lastlog entry remain.
|
||||
* If it get smaller, some are deleted from the end.
|
||||
*/
|
||||
void set_lastlog_size(Window *win_unused, char *unused, int size)
|
||||
{
|
||||
int i,
|
||||
diff;
|
||||
Window *win = NULL;
|
||||
|
||||
while ((traverse_all_windows(&win)))
|
||||
{
|
||||
if (win->lastlog_size > size)
|
||||
{
|
||||
diff = win->lastlog_size - size;
|
||||
for (i = 0; i < diff; i++)
|
||||
remove_from_lastlog(win);
|
||||
}
|
||||
win->lastlog_max = size;
|
||||
}
|
||||
}
|
||||
|
||||
void free_lastlog(Window *win)
|
||||
{
|
||||
Lastlog *ptr;
|
||||
for (ptr = win->lastlog_head; ptr;)
|
||||
{
|
||||
Lastlog *next = ptr->next;
|
||||
new_free(&ptr->msg);
|
||||
new_free(&ptr);
|
||||
ptr = next;
|
||||
}
|
||||
win->lastlog_head = NULL;
|
||||
win->lastlog_tail = NULL;
|
||||
win->lastlog_size = 0;
|
||||
}
|
||||
/*
|
||||
* lastlog: the /LASTLOG command. Displays the lastlog to the screen. If
|
||||
* args contains a valid integer, only that many lastlog entries are shown
|
||||
* (if the value is less than lastlog_size), otherwise the entire lastlog is
|
||||
* displayed
|
||||
*/
|
||||
BUILT_IN_COMMAND(lastlog)
|
||||
{
|
||||
int cnt,
|
||||
from = 0,
|
||||
p,
|
||||
i,
|
||||
level = 0,
|
||||
msg_level,
|
||||
len,
|
||||
mask = 0,
|
||||
header = 1,
|
||||
lines = 0,
|
||||
reverse = 0,
|
||||
time_log = 1,
|
||||
remove = 0;
|
||||
|
||||
Lastlog *start_pos;
|
||||
char *match = NULL,
|
||||
*arg;
|
||||
char *file_open[] = { "wt", "at" };
|
||||
int file_open_type = 0;
|
||||
char *blah = NULL;
|
||||
FILE *fp = NULL;
|
||||
|
||||
reset_display_target();
|
||||
cnt = current_window->lastlog_size;
|
||||
|
||||
while ((arg = new_next_arg(args, &args)) != NULL)
|
||||
{
|
||||
if (*arg == '-')
|
||||
{
|
||||
arg++;
|
||||
if (!(len = strlen(arg)))
|
||||
{
|
||||
header = 0;
|
||||
continue;
|
||||
}
|
||||
else if (!my_strnicmp(arg, "MAX", len))
|
||||
{
|
||||
char *ptr = NULL;
|
||||
ptr = new_next_arg(args, &args);
|
||||
if (ptr)
|
||||
lines = atoi(ptr);
|
||||
if (lines < 0)
|
||||
lines = 0;
|
||||
}
|
||||
else if (!my_strnicmp(arg, "LITERAL", len))
|
||||
{
|
||||
if (match)
|
||||
{
|
||||
say("Second -LITERAL argument ignored");
|
||||
(void) new_next_arg(args, &args);
|
||||
continue;
|
||||
}
|
||||
if ((match = new_next_arg(args, &args)) != NULL)
|
||||
continue;
|
||||
say("Need pattern for -LITERAL");
|
||||
return;
|
||||
}
|
||||
else if (!my_strnicmp(arg, "REVERSE", len))
|
||||
reverse = 1;
|
||||
else if (!my_strnicmp(arg, "TIME", len))
|
||||
time_log = 0;
|
||||
else if (!my_strnicmp(arg, "BEEP", len))
|
||||
{
|
||||
if (match)
|
||||
{
|
||||
say("-BEEP is exclusive; ignored");
|
||||
continue;
|
||||
}
|
||||
else
|
||||
match = "\007";
|
||||
}
|
||||
else if (!my_strnicmp(arg, "CLEAR", len))
|
||||
{
|
||||
free_lastlog(current_window);
|
||||
say("Cleared lastlog");
|
||||
return;
|
||||
}
|
||||
else if (!my_strnicmp(arg, "APPEND", len))
|
||||
file_open_type = 1;
|
||||
else if (!my_strnicmp(arg, "FILE", len))
|
||||
{
|
||||
#ifdef PUBLIC_ACCESS
|
||||
bitchsay("This command has been disabled on a public access system");
|
||||
return;
|
||||
#else
|
||||
if (args && *args)
|
||||
{
|
||||
char *filename;
|
||||
filename = next_arg(args, &args);
|
||||
if (!(fp = fopen(filename, file_open[file_open_type])))
|
||||
{
|
||||
bitchsay("cannot open file %s", filename);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
bitchsay("Filename needed for save");
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else if (!my_strnicmp(arg, "MORE", len))
|
||||
{
|
||||
current_window->save_hold_mode = current_window->hold_mode;
|
||||
current_window->in_more = 1;
|
||||
reset_line_cnt(current_window, NULL, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (*arg == '-')
|
||||
remove = 1, arg++;
|
||||
else
|
||||
remove = 0;
|
||||
|
||||
/*
|
||||
* Which can be combined with -ALL, which
|
||||
* turns on all levels. Use --MSGS or
|
||||
* whatever to turn off ones you dont want.
|
||||
*/
|
||||
if (!my_strnicmp(arg, "ALL", len))
|
||||
{
|
||||
if (remove)
|
||||
mask = 0;
|
||||
else
|
||||
mask = LOG_ALL;
|
||||
continue; /* Go to next arg */
|
||||
}
|
||||
|
||||
/*
|
||||
* Find the lastlog level in our list.
|
||||
*/
|
||||
for (i = 0, p = 1; i < NUMBER_OF_LEVELS; i++, p *= 2)
|
||||
{
|
||||
if (!my_strnicmp(levels[i], arg, len))
|
||||
{
|
||||
if (remove)
|
||||
mask &= ~p;
|
||||
else
|
||||
mask |= p;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (i == NUMBER_OF_LEVELS)
|
||||
{
|
||||
bitchsay("Unknown flag: %s", arg);
|
||||
reset_display_target();
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (level == 0)
|
||||
{
|
||||
if (match || isdigit((unsigned char)*arg))
|
||||
{
|
||||
cnt = atoi(arg);
|
||||
level++;
|
||||
}
|
||||
else
|
||||
match = arg;
|
||||
}
|
||||
else if (level == 1)
|
||||
{
|
||||
from = atoi(arg);
|
||||
level++;
|
||||
}
|
||||
}
|
||||
}
|
||||
start_pos = current_window->lastlog_head;
|
||||
level = current_window->lastlog_level;
|
||||
msg_level = set_lastlog_msg_level(0);
|
||||
|
||||
if (!reverse)
|
||||
{
|
||||
for (i = 0; (i < from) && start_pos; start_pos = start_pos->next)
|
||||
if (!mask || (mask & start_pos->level))
|
||||
i++;
|
||||
|
||||
for (i = 0; (i < cnt) && start_pos; start_pos = start_pos->next)
|
||||
if (!mask || (mask & start_pos->level))
|
||||
i++;
|
||||
|
||||
start_pos = (start_pos) ? start_pos->prev : current_window->lastlog_tail;
|
||||
} else
|
||||
start_pos = current_window->lastlog_head;
|
||||
|
||||
/* Let's not get confused here, display a seperator.. -lynx */
|
||||
strip_ansi_in_echo = 0;
|
||||
if (header && !fp)
|
||||
say("Lastlog:");
|
||||
|
||||
if (match)
|
||||
{
|
||||
|
||||
blah = (char *) alloca(strlen(match)+4);
|
||||
sprintf(blah, "*%s*", match);
|
||||
}
|
||||
for (i = 0; (i < cnt) && start_pos; start_pos = (reverse ? start_pos->next : start_pos->prev))
|
||||
{
|
||||
if (!mask || (mask & start_pos->level))
|
||||
{
|
||||
i++;
|
||||
if (!match || wild_match(blah, start_pos->msg))
|
||||
{
|
||||
char *s = !get_int_var(LASTLOG_ANSI_VAR)?stripansicodes(start_pos->msg):start_pos->msg;
|
||||
|
||||
if (!fp)
|
||||
{
|
||||
put_it("%s", !time_log ? s : convert_output_format(fget_string_var(FORMAT_LASTLOG_FSET), "%l %s", start_pos->time, s));
|
||||
grab_http("*", "*", start_pos->msg);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (time_log)
|
||||
{
|
||||
s = convert_output_format(fget_string_var(FORMAT_LASTLOG_FSET), "%l %s", start_pos->time, s);
|
||||
chop(s, 3);
|
||||
}
|
||||
fprintf(fp, "%s\n", s);
|
||||
}
|
||||
if (lines == 0)
|
||||
continue;
|
||||
else if (lines == 1)
|
||||
break;
|
||||
lines--;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (header && !fp)
|
||||
say("End of Lastlog");
|
||||
if (fp)
|
||||
fclose(fp);
|
||||
strip_ansi_in_echo = 1;
|
||||
current_window->lastlog_level = level;
|
||||
set_lastlog_msg_level(msg_level);
|
||||
}
|
||||
|
||||
Lastlog *get_lastlog_current_head(Window *win)
|
||||
{
|
||||
return win->lastlog_head;
|
||||
}
|
||||
|
||||
/*
|
||||
* add_to_lastlog: adds the line to the lastlog. If the LASTLOG_CONVERSATION
|
||||
* variable is on, then only those lines that are user messages (private
|
||||
* messages, channel messages, wall's, and any outgoing messages) are
|
||||
* recorded, otherwise, everything is recorded
|
||||
*/
|
||||
void add_to_lastlog(Window *window, const char *line)
|
||||
{
|
||||
Lastlog *new;
|
||||
|
||||
if (window == NULL)
|
||||
window = current_window;
|
||||
if (window->lastlog_level & msg_level)
|
||||
{
|
||||
/* no nulls or empty lines (they contain "> ") */
|
||||
if (line && (strlen(line) > 2))
|
||||
{
|
||||
new = (Lastlog *) new_malloc(sizeof(Lastlog));
|
||||
new->next = window->lastlog_head;
|
||||
new->prev = NULL;
|
||||
new->level = msg_level;
|
||||
new->msg = NULL;
|
||||
new->time = now;
|
||||
new->msg = m_strdup(line);
|
||||
|
||||
if (window->lastlog_head)
|
||||
window->lastlog_head->prev = new;
|
||||
window->lastlog_head = new;
|
||||
|
||||
if (window->lastlog_tail == NULL)
|
||||
window->lastlog_tail = window->lastlog_head;
|
||||
|
||||
if (window->lastlog_size++ >= window->lastlog_max)
|
||||
remove_from_lastlog(window);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsigned long real_notify_level(void)
|
||||
{
|
||||
return (notify_level);
|
||||
}
|
||||
|
||||
unsigned long real_lastlog_level(void)
|
||||
{
|
||||
return (lastlog_level);
|
||||
}
|
||||
|
||||
void set_notify_level(Window *win, char *str, int unused)
|
||||
{
|
||||
notify_level = parse_lastlog_level(str, 1);
|
||||
set_string_var(NOTIFY_LEVEL_VAR, bits_to_lastlog_level(notify_level));
|
||||
current_window->notify_level = notify_level;
|
||||
}
|
||||
|
||||
int logmsg(unsigned long log_type, char *from, int flag, char *format, ...)
|
||||
{
|
||||
#ifdef PUBLIC_ACCESS
|
||||
return 0;
|
||||
#else
|
||||
char *timestr;
|
||||
time_t t;
|
||||
char *filename = NULL;
|
||||
char *expand = NULL;
|
||||
char *type = NULL;
|
||||
unsigned char **lines = NULL;
|
||||
char msglog_buffer[BIG_BUFFER_SIZE+1];
|
||||
|
||||
|
||||
if (!get_string_var(MSGLOGFILE_VAR) || !get_string_var(CTOOLZ_DIR_VAR))
|
||||
return 0;
|
||||
|
||||
t = now;
|
||||
timestr = update_clock(GET_TIME);
|
||||
|
||||
|
||||
if (format)
|
||||
{
|
||||
va_list ap;
|
||||
va_start(ap, format);
|
||||
vsnprintf(msglog_buffer, BIG_BUFFER_SIZE, format, ap);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
|
||||
switch (flag)
|
||||
{
|
||||
case 0:
|
||||
if (!(type = bits_to_lastlog_level(log_type)))
|
||||
type = "Unknown";
|
||||
if (msglog_level & log_type && format)
|
||||
{
|
||||
char *format;
|
||||
|
||||
if (!do_hook(MSGLOG_LIST, "%s %s %s %s", timestr, type, from, msglog_buffer))
|
||||
break;
|
||||
if (!logptr)
|
||||
return 0;
|
||||
if (!(format = fget_string_var(FORMAT_MSGLOG_FSET)))
|
||||
format = "[$[10]0] [$1] - $2-";
|
||||
lines = split_up_line(stripansicodes(convert_output_format(format, "%s %s %s %s", type, timestr, from, msglog_buffer)), 80);
|
||||
for ( ; *lines; lines++)
|
||||
{
|
||||
char *local_copy;
|
||||
int len = strlen(*lines) * 2 + 1;
|
||||
if (!*lines || !**lines) break;
|
||||
local_copy = alloca(len);
|
||||
strcpy(local_copy, *lines);
|
||||
|
||||
if (local_copy[strlen(local_copy)-1] == ALL_OFF)
|
||||
local_copy[strlen(local_copy)-1] = 0;
|
||||
if (logfile_line_mangler)
|
||||
mangle_line(local_copy, logfile_line_mangler, len);
|
||||
if (*local_copy)
|
||||
fprintf(logptr, "%s\n", local_copy);
|
||||
}
|
||||
fflush(logptr);
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
malloc_sprintf(&filename, "%s/%s", get_string_var(CTOOLZ_DIR_VAR), get_string_var(MSGLOGFILE_VAR));
|
||||
expand = expand_twiddle(filename);
|
||||
new_free(&filename);
|
||||
if (!do_hook(MSGLOG_LIST, "%s %s %s %s", timestr, "On", expand, empty_string))
|
||||
{
|
||||
new_free(&expand);
|
||||
return 1;
|
||||
}
|
||||
if (logptr)
|
||||
{
|
||||
new_free(&expand);
|
||||
return 1;
|
||||
}
|
||||
if (!(logptr = fopen(expand, get_int_var(APPEND_LOG_VAR)?"at":"wt")))
|
||||
{
|
||||
set_int_var(MSGLOG_VAR, 0);
|
||||
new_free(&expand);
|
||||
return 0;
|
||||
}
|
||||
|
||||
fprintf(logptr, "MsgLog started [%s]\n", my_ctime(t));
|
||||
fflush(logptr);
|
||||
if (format)
|
||||
{
|
||||
int i;
|
||||
|
||||
i = logmsg(LOG_CURRENT, from, 0, "%s", msglog_buffer);
|
||||
return i;
|
||||
}
|
||||
bitchsay("Now logging messages to: %s", expand);
|
||||
new_free(&expand);
|
||||
break;
|
||||
case 2:
|
||||
if (!do_hook(MSGLOG_LIST, "%s %s %s %s", timestr, "Off", empty_string, empty_string))
|
||||
return 1;
|
||||
if (!logptr)
|
||||
return 1;
|
||||
fprintf(logptr, "MsgLog ended [%s]\n", my_ctime(t));
|
||||
fclose(logptr);
|
||||
logptr = NULL;
|
||||
break;
|
||||
case 3:
|
||||
return logptr ? 1 : 0;
|
||||
break;
|
||||
case 4:
|
||||
if (!logptr)
|
||||
return 1;
|
||||
fprintf(logptr, "[TimeStamp %s]\n", my_ctime(t));
|
||||
fflush(logptr);
|
||||
break;
|
||||
default:
|
||||
bitchsay("Bad Flag passed to logmsg");
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
void set_beep_on_msg (Window *win, char *str, int unused)
|
||||
{
|
||||
beep_on_level = parse_lastlog_level(str, 1);
|
||||
set_string_var(BEEP_ON_MSG_VAR, bits_to_lastlog_level(beep_on_level));
|
||||
}
|
||||
|
||||
BUILT_IN_COMMAND(awaylog)
|
||||
{
|
||||
if (args && *args)
|
||||
{
|
||||
msglog_level = parse_lastlog_level(args, 1);
|
||||
set_string_var(MSGLOG_LEVEL_VAR, bits_to_lastlog_level(msglog_level));
|
||||
put_it("%s", convert_output_format("$G Away logging set to: $0-", "%s", get_string_var(MSGLOG_LEVEL_VAR)));
|
||||
}
|
||||
else
|
||||
put_it("%s", convert_output_format("$G Away logging currently: $0-", "%s", bits_to_lastlog_level(msglog_level)));
|
||||
}
|
||||
|
||||
#define EMPTY empty_string
|
||||
#define RETURN_EMPTY return m_strdup(EMPTY)
|
||||
#define RETURN_IF_EMPTY(x) if (empty( x )) RETURN_EMPTY
|
||||
#define GET_INT_ARG(x, y) {RETURN_IF_EMPTY(y); x = my_atol(safe_new_next_arg(y, &y));}
|
||||
#define GET_STR_ARG(x, y) {RETURN_IF_EMPTY((y)); x = new_next_arg((y), &(y));RETURN_IF_EMPTY((x));}
|
||||
#define RETURN_STR(x) return m_strdup(x ? x : EMPTY);
|
||||
|
||||
/*
|
||||
* $line(<line number> [window number])
|
||||
* Returns the text of logical line <line number> from the lastlog of
|
||||
* window <window number>. If no window number is supplied, the current
|
||||
* window will be used. If the window number is invalid, the function
|
||||
* will return the false value.
|
||||
*
|
||||
* Lines are numbered from 1, starting at the most recent line in the buffer.
|
||||
* Contributed by Crackbaby (Matt Carothers) on March 19, 1998.
|
||||
*/
|
||||
|
||||
BUILT_IN_FUNCTION(function_line)
|
||||
{
|
||||
int line = 0;
|
||||
char * windesc = zero;
|
||||
Lastlog *start_pos;
|
||||
Window *win;
|
||||
char *extra;
|
||||
int do_level = 0;
|
||||
|
||||
|
||||
GET_INT_ARG(line, input);
|
||||
|
||||
while (input && *input)
|
||||
{
|
||||
GET_STR_ARG(extra, input);
|
||||
|
||||
if (!my_stricmp(extra, "-LEVEL"))
|
||||
do_level = 1;
|
||||
else
|
||||
windesc = extra;
|
||||
}
|
||||
|
||||
/* Get the current window, default to current window */
|
||||
if (!(win = get_window_by_desc(windesc)))
|
||||
RETURN_EMPTY;
|
||||
|
||||
/* Make sure that the line request is within reason */
|
||||
if (line < 1 || line > win->lastlog_size)
|
||||
RETURN_EMPTY;
|
||||
|
||||
/* Get the line from the lastlog */
|
||||
for (start_pos = win->lastlog_head; line; start_pos = start_pos->next)
|
||||
line--;
|
||||
|
||||
if (!start_pos)
|
||||
start_pos = win->lastlog_tail;
|
||||
else
|
||||
start_pos = start_pos->prev;
|
||||
|
||||
if (do_level)
|
||||
return m_sprintf("%s %s", start_pos->msg,
|
||||
levels[start_pos->level]);
|
||||
else
|
||||
RETURN_STR(start_pos->msg);
|
||||
}
|
||||
|
||||
/*
|
||||
* $lastlog(<window description> <lastlog levels>)
|
||||
* Returns all of the lastlog lines (suitable for use with $line()) on the
|
||||
* indicated window (0 for the current window) that have any of the lastlog
|
||||
* levels as represented by the lastlog levels. If the window number is
|
||||
* invalid, the function will return the false value.
|
||||
*/
|
||||
|
||||
BUILT_IN_FUNCTION(function_lastlog)
|
||||
{
|
||||
char * windesc = zero;
|
||||
char * pattern = NULL;
|
||||
char * retval = NULL;
|
||||
Lastlog *iter;
|
||||
Window *win;
|
||||
int levels;
|
||||
int line = 1;
|
||||
|
||||
GET_STR_ARG(windesc, input);
|
||||
GET_STR_ARG(pattern, input);
|
||||
levels = parse_lastlog_level(input, 0);
|
||||
|
||||
/* Get the current window, default to current window */
|
||||
if (!(win = get_window_by_desc(windesc)))
|
||||
RETURN_EMPTY;
|
||||
|
||||
for (iter = win->lastlog_head; iter; iter = iter->next, line++)
|
||||
{
|
||||
if (iter->level & levels)
|
||||
if (wild_match(pattern, iter->msg))
|
||||
m_s3cat(&retval, space, ltoa(line));
|
||||
}
|
||||
|
||||
if (retval)
|
||||
return retval;
|
||||
|
||||
RETURN_EMPTY;
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user