/* * logger.c - logger plugin for WeeChat: save buffer lines to disk files * * Copyright (C) 2003-2020 Sébastien Helleu * * This file is part of WeeChat, the extensible chat client. * * WeeChat 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 3 of the License, or * (at your option) any later version. * * WeeChat 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 WeeChat. If not, see . */ #include #include #include #include #include #include #include #include #include #include #include #include #include "../weechat-plugin.h" #include "logger.h" #include "logger-backlog.h" #include "logger-buffer.h" #include "logger-command.h" #include "logger-config.h" #include "logger-info.h" #include "logger-tail.h" WEECHAT_PLUGIN_NAME(LOGGER_PLUGIN_NAME); WEECHAT_PLUGIN_DESCRIPTION(N_("Log buffers to files")); WEECHAT_PLUGIN_AUTHOR("Sébastien Helleu "); WEECHAT_PLUGIN_VERSION(WEECHAT_VERSION); WEECHAT_PLUGIN_LICENSE(WEECHAT_LICENSE); WEECHAT_PLUGIN_PRIORITY(14000); struct t_weechat_plugin *weechat_logger_plugin = NULL; struct t_hook *logger_hook_timer = NULL; /* timer to flush log files */ struct t_hook *logger_hook_print = NULL; /* * Gets logger file path option. * * Special vars are replaced: * - "%h" (at beginning of string): WeeChat home * - "~": user home * - date/time specifiers (see man strftime) * * Note: result must be freed after use. */ char * logger_get_file_path () { char *path, *path2; int length; time_t seconds; struct tm *date_tmp; path = NULL; path2 = NULL; /* replace %h and "~", evaluate path */ path = weechat_string_eval_path_home ( weechat_config_string (logger_config_file_path), NULL, NULL, NULL); if (!path) goto end; /* replace date/time specifiers in path */ length = strlen (path) + 256 + 1; path2 = malloc (length); if (!path2) goto end; seconds = time (NULL); date_tmp = localtime (&seconds); path2[0] = '\0'; if (strftime (path2, length - 1, path, date_tmp) == 0) path2[0] = '\0'; if (weechat_logger_plugin->debug) { weechat_printf_date_tags (NULL, 0, "no_log", "%s: file path = \"%s\"", LOGGER_PLUGIN_NAME, path2); } end: if (path) free (path); return path2; } /* * Creates logger directory. * * Returns: * 1: OK * 0: error */ int logger_create_directory () { int rc; char *file_path; rc = 1; file_path = logger_get_file_path (); if (file_path) { if (!weechat_mkdir_parents (file_path, 0700)) rc = 0; free (file_path); } else rc = 0; return rc; } /* * Builds full name of buffer. * * Note: result must be freed after use. */ char * logger_build_option_name (struct t_gui_buffer *buffer) { const char *plugin_name, *name; char *option_name; int length; if (!buffer) return NULL; plugin_name = weechat_buffer_get_string (buffer, "plugin"); name = weechat_buffer_get_string (buffer, "name"); length = strlen (plugin_name) + 1 + strlen (name) + 1; option_name = malloc (length); if (!option_name) return NULL; snprintf (option_name, length, "%s.%s", plugin_name, name); return option_name; } /* * Gets logging level for buffer. * * Returns level between 0 and 9 (0 = logging disabled). */ int logger_get_level_for_buffer (struct t_gui_buffer *buffer) { const char *no_log; char *name, *option_name, *ptr_end; struct t_config_option *ptr_option; /* no log for buffer if local variable "no_log" is defined for buffer */ no_log = weechat_buffer_get_string (buffer, "localvar_no_log"); if (no_log && no_log[0]) return 0; name = logger_build_option_name (buffer); if (!name) return LOGGER_LEVEL_DEFAULT; option_name = strdup (name); if (option_name) { ptr_end = option_name + strlen (option_name); while (ptr_end >= option_name) { ptr_option = logger_config_get_level (option_name); if (ptr_option) { free (option_name); free (name); return weechat_config_integer (ptr_option); } ptr_end--; while ((ptr_end >= option_name) && (ptr_end[0] != '.')) { ptr_end--; } if ((ptr_end >= option_name) && (ptr_end[0] == '.')) ptr_end[0] = '\0'; } ptr_option = logger_config_get_level (option_name); free (option_name); free (name); if (ptr_option) return weechat_config_integer (ptr_option); } else free (name); /* nothing found => return default level */ return LOGGER_LEVEL_DEFAULT; } /* * Gets filename mask for a buffer. * * First tries with all arguments, then removes one by one to find mask (from * specific to general mask). */ const char * logger_get_mask_for_buffer (struct t_gui_buffer *buffer) { char *name, *option_name, *ptr_end; struct t_config_option *ptr_option; name = logger_build_option_name (buffer); if (!name) return NULL; option_name = strdup (name); if (option_name) { ptr_end = option_name + strlen (option_name); while (ptr_end >= option_name) { ptr_option = logger_config_get_mask (option_name); if (ptr_option) { free (option_name); free (name); return weechat_config_string (ptr_option); } ptr_end--; while ((ptr_end >= option_name) && (ptr_end[0] != '.')) { ptr_end--; } if ((ptr_end >= option_name) && (ptr_end[0] == '.')) ptr_end[0] = '\0'; } ptr_option = logger_config_get_mask (option_name); free (option_name); free (name); if (ptr_option) return weechat_config_string (ptr_option); } else free (name); /* nothing found => return default mask (if set) */ if (weechat_config_string (logger_config_file_mask) && weechat_config_string (logger_config_file_mask)[0]) return weechat_config_string (logger_config_file_mask); /* no default mask set */ return NULL; } /* * Gets expanded mask for a buffer. * * Special vars are replaced: * - local variables of buffer ($plugin, $name, ..) * - date/time specifiers (see man strftime) * * Note: result must be freed after use. */ char * logger_get_mask_expanded (struct t_gui_buffer *buffer, const char *mask) { char *mask2, *mask3, *mask4, *mask5, *mask6, *mask7, *dir_separator; int length; time_t seconds; struct tm *date_tmp; mask2 = NULL; mask3 = NULL; mask4 = NULL; mask5 = NULL; mask6 = NULL; mask7 = NULL; dir_separator = weechat_info_get ("dir_separator", ""); if (!dir_separator) return NULL; /* replace date/time specifiers in mask */ length = strlen (mask) + 256 + 1; mask2 = malloc (length); if (!mask2) goto end; seconds = time (NULL); date_tmp = localtime (&seconds); mask2[0] = '\0'; if (strftime (mask2, length - 1, mask, date_tmp) == 0) mask2[0] = '\0'; /* * we first replace directory separator (commonly '/') by \01 because * buffer mask can contain this char, and will be replaced by replacement * char ('_' by default) */ mask3 = weechat_string_replace (mask2, dir_separator, "\01"); if (!mask3) goto end; mask4 = weechat_buffer_string_replace_local_var (buffer, mask3); if (!mask4) goto end; mask5 = weechat_string_replace (mask4, dir_separator, weechat_config_string (logger_config_file_replacement_char)); if (!mask5) goto end; #ifdef __CYGWIN__ mask6 = weechat_string_replace (mask5, "\\", weechat_config_string (logger_config_file_replacement_char)); #else mask6 = strdup (mask5); #endif /* __CYGWIN__ */ if (!mask6) goto end; /* restore directory separator */ mask7 = weechat_string_replace (mask6, "\01", dir_separator); if (!mask7) goto end; /* convert to lower case? */ if (weechat_config_boolean (logger_config_file_name_lower_case)) weechat_string_tolower (mask7); if (weechat_logger_plugin->debug) { weechat_printf_date_tags (NULL, 0, "no_log", "%s: buffer = \"%s\", mask = \"%s\", " "decoded mask = \"%s\"", LOGGER_PLUGIN_NAME, weechat_buffer_get_string (buffer, "name"), mask, mask7); } end: free (dir_separator); if (mask2) free (mask2); if (mask3) free (mask3); if (mask4) free (mask4); if (mask5) free (mask5); if (mask6) free (mask6); return mask7; } /* * Builds log filename for a buffer. * * Note: result must be freed after use. */ char * logger_get_filename (struct t_gui_buffer *buffer) { char *res, *mask_expanded, *file_path, *dir_separator, *weechat_dir; const char *mask; int length; res = NULL; mask_expanded = NULL; file_path = NULL; dir_separator = weechat_info_get ("dir_separator", ""); if (!dir_separator) return NULL; weechat_dir = weechat_info_get ("weechat_dir", ""); if (!weechat_dir) { free (dir_separator); return NULL; } /* get filename mask for buffer */ mask = logger_get_mask_for_buffer (buffer); if (!mask) { weechat_printf_date_tags ( NULL, 0, "no_log", _("%s%s: unable to find filename mask for buffer " "\"%s\", logging is disabled for this buffer"), weechat_prefix ("error"), LOGGER_PLUGIN_NAME, weechat_buffer_get_string (buffer, "name")); free (dir_separator); free (weechat_dir); return NULL; } mask_expanded = logger_get_mask_expanded (buffer, mask); if (!mask_expanded) goto end; file_path = logger_get_file_path (); if (!file_path) goto end; /* build string with path + mask */ length = strlen (file_path) + strlen (dir_separator) + strlen (mask_expanded) + 1; res = malloc (length); if (res) { snprintf (res, length, "%s%s%s", file_path, (file_path[strlen (file_path) - 1] == dir_separator[0]) ? "" : dir_separator, mask_expanded); } end: free (dir_separator); free (weechat_dir); if (mask_expanded) free (mask_expanded); if (file_path) free (file_path); return res; } /* * Sets log filename for a logger buffer. */ void logger_set_log_filename (struct t_logger_buffer *logger_buffer) { char *log_filename, *pos_last_sep; char *dir_separator; struct t_logger_buffer *ptr_logger_buffer; /* get log filename for buffer */ log_filename = logger_get_filename (logger_buffer->buffer); if (!log_filename) { weechat_printf_date_tags (NULL, 0, "no_log", _("%s%s: not enough memory"), weechat_prefix ("error"), LOGGER_PLUGIN_NAME); return; } /* log file is already used by another buffer? */ ptr_logger_buffer = logger_buffer_search_log_filename (log_filename); if (ptr_logger_buffer) { weechat_printf_date_tags ( NULL, 0, "no_log", _("%s%s: unable to start logging for buffer " "\"%s\": filename \"%s\" is already used by " "another buffer (check your log settings)"), weechat_prefix ("error"), LOGGER_PLUGIN_NAME, weechat_buffer_get_string (logger_buffer->buffer, "name"), log_filename); free (log_filename); return; } /* create directory for path in "log_filename" */ dir_separator = weechat_info_get ("dir_separator", ""); if (dir_separator) { pos_last_sep = strrchr (log_filename, dir_separator[0]); if (pos_last_sep) { pos_last_sep[0] = '\0'; weechat_mkdir_parents (log_filename, 0700); pos_last_sep[0] = dir_separator[0]; } free (dir_separator); } /* set log filename */ logger_buffer->log_filename = log_filename; } /* * Creates a log file. * * Returns: * 1: OK * 0: error */ int logger_create_log_file (struct t_logger_buffer *logger_buffer) { char *charset, *message, buf_time[256], buf_beginning[1024]; int log_level, rc; time_t seconds; struct tm *date_tmp; struct stat statbuf; if (logger_buffer->log_file) { /* * check that the inode has not changed, otherwise that means the file * was deleted, and we must reopen it */ rc = stat (logger_buffer->log_filename, &statbuf); if ((rc == 0) && (statbuf.st_ino == logger_buffer->log_file_inode)) { /* inode has not changed, we can write in this file */ return 1; } fclose (logger_buffer->log_file); logger_buffer->log_file = NULL; logger_buffer->log_file_inode = 0; } /* get log level */ log_level = logger_get_level_for_buffer (logger_buffer->buffer); if (log_level == 0) return 0; /* create directory */ if (!logger_create_directory ()) { weechat_printf_date_tags ( NULL, 0, "no_log", _("%s%s: unable to create directory for logs " "(\"%s\")"), weechat_prefix ("error"), LOGGER_PLUGIN_NAME, weechat_config_string (logger_config_file_path)); return 0; } if (!logger_buffer->log_filename) logger_set_log_filename (logger_buffer); if (!logger_buffer->log_filename) return 0; /* create or append to log file */ logger_buffer->log_file = fopen (logger_buffer->log_filename, "a"); if (!logger_buffer->log_file) { weechat_printf_date_tags ( NULL, 0, "no_log", _("%s%s: unable to write log file \"%s\": %s"), weechat_prefix ("error"), LOGGER_PLUGIN_NAME, logger_buffer->log_filename, strerror (errno)); return 0; } /* get file inode */ rc = stat (logger_buffer->log_filename, &statbuf); if (rc != 0) { weechat_printf_date_tags ( NULL, 0, "no_log", _("%s%s: unable to get file status of log file \"%s\": %s"), weechat_prefix ("error"), LOGGER_PLUGIN_NAME, logger_buffer->log_filename, strerror (errno)); fclose (logger_buffer->log_file); logger_buffer->log_file = NULL; logger_buffer->log_file_inode = 0; return 0; } logger_buffer->log_file_inode = statbuf.st_ino; /* write info line */ if (weechat_config_boolean (logger_config_file_info_lines) && logger_buffer->write_start_info_line) { buf_time[0] = '\0'; seconds = time (NULL); date_tmp = localtime (&seconds); if (date_tmp) { if (strftime (buf_time, sizeof (buf_time) - 1, weechat_config_string (logger_config_file_time_format), date_tmp) == 0) buf_time[0] = '\0'; } snprintf (buf_beginning, sizeof (buf_beginning), _("%s\t**** Beginning of log ****"), buf_time); charset = weechat_info_get ("charset_terminal", ""); message = (charset) ? weechat_iconv_from_internal (charset, buf_beginning) : NULL; fprintf (logger_buffer->log_file, "%s\n", (message) ? message : buf_beginning); if (charset) free (charset); if (message) free (message); logger_buffer->flush_needed = 1; } logger_buffer->write_start_info_line = 0; return 1; } /* * Writes a line to log file. */ void logger_write_line (struct t_logger_buffer *logger_buffer, const char *format, ...) { char *charset, *message; if (!logger_create_log_file (logger_buffer)) return; if (!logger_buffer->log_file) return; weechat_va_format (format); if (vbuffer) { charset = weechat_info_get ("charset_terminal", ""); message = (charset) ? weechat_iconv_from_internal (charset, vbuffer) : NULL; fprintf (logger_buffer->log_file, "%s\n", (message) ? message : vbuffer); if (charset) free (charset); if (message) free (message); logger_buffer->flush_needed = 1; if (!logger_hook_timer) { fflush (logger_buffer->log_file); if (weechat_config_boolean (logger_config_file_fsync)) fsync (fileno (logger_buffer->log_file)); logger_buffer->flush_needed = 0; } free (vbuffer); } } /* * Stops log for a logger buffer. */ void logger_stop (struct t_logger_buffer *logger_buffer, int write_info_line) { time_t seconds; struct tm *date_tmp; char buf_time[256]; if (!logger_buffer) return; if (logger_buffer->log_enabled && logger_buffer->log_file) { if (write_info_line && weechat_config_boolean (logger_config_file_info_lines)) { buf_time[0] = '\0'; seconds = time (NULL); date_tmp = localtime (&seconds); if (date_tmp) { if (strftime (buf_time, sizeof (buf_time) - 1, weechat_config_string (logger_config_file_time_format), date_tmp) == 0) buf_time[0] = '\0'; } logger_write_line (logger_buffer, _("%s\t**** End of log ****"), buf_time); } } logger_buffer_free (logger_buffer); } /* * Ends log for all buffers. */ void logger_stop_all (int write_info_line) { while (logger_buffers) { logger_stop (logger_buffers, write_info_line); } } /* * Starts logging for a buffer. */ void logger_start_buffer (struct t_gui_buffer *buffer, int write_info_line) { struct t_logger_buffer *ptr_logger_buffer; int log_level, log_enabled; if (!buffer) return; log_level = logger_get_level_for_buffer (buffer); log_enabled = weechat_config_boolean (logger_config_file_auto_log) && (log_level > 0); ptr_logger_buffer = logger_buffer_search_buffer (buffer); /* logging is disabled for buffer */ if (!log_enabled) { /* stop logger if it is active */ if (ptr_logger_buffer) logger_stop (ptr_logger_buffer, 1); } else { /* logging is enabled for buffer */ if (ptr_logger_buffer) ptr_logger_buffer->log_level = log_level; else { ptr_logger_buffer = logger_buffer_add (buffer, log_level); if (ptr_logger_buffer) { if (ptr_logger_buffer->log_filename) { if (ptr_logger_buffer->log_file) { fclose (ptr_logger_buffer->log_file); ptr_logger_buffer->log_file = NULL; ptr_logger_buffer->log_file_inode = 0; } } } } if (ptr_logger_buffer) ptr_logger_buffer->write_start_info_line = write_info_line; } } /* * Starts logging for all buffers. */ void logger_start_buffer_all (int write_info_line) { struct t_infolist *ptr_infolist; ptr_infolist = weechat_infolist_get ("buffer", NULL, NULL); if (ptr_infolist) { while (weechat_infolist_next (ptr_infolist)) { logger_start_buffer (weechat_infolist_pointer (ptr_infolist, "pointer"), write_info_line); } weechat_infolist_free (ptr_infolist); } } /* * Flushes all log files. */ void logger_flush () { struct t_logger_buffer *ptr_logger_buffer; for (ptr_logger_buffer = logger_buffers; ptr_logger_buffer; ptr_logger_buffer = ptr_logger_buffer->next_buffer) { if (ptr_logger_buffer->log_file && ptr_logger_buffer->flush_needed) { if (weechat_logger_plugin->debug >= 2) { weechat_printf_date_tags (NULL, 0, "no_log", "%s: flush file %s", LOGGER_PLUGIN_NAME, ptr_logger_buffer->log_filename); } fflush (ptr_logger_buffer->log_file); if (weechat_config_boolean (logger_config_file_fsync)) fsync (fileno (ptr_logger_buffer->log_file)); ptr_logger_buffer->flush_needed = 0; } } } /* * Callback for signal "buffer_opened". */ int logger_buffer_opened_signal_cb (const void *pointer, void *data, const char *signal, const char *type_data, void *signal_data) { /* make C compiler happy */ (void) pointer; (void) data; (void) signal; (void) type_data; logger_start_buffer (signal_data, 1); return WEECHAT_RC_OK; } /* * Callback for signal "buffer_closing". */ int logger_buffer_closing_signal_cb (const void *pointer, void *data, const char *signal, const char *type_data, void *signal_data) { /* make C compiler happy */ (void) pointer; (void) data; (void) signal; (void) type_data; logger_stop (logger_buffer_search_buffer (signal_data), 1); return WEECHAT_RC_OK; } /* * Callback for signal "buffer_renamed". */ int logger_buffer_renamed_signal_cb (const void *pointer, void *data, const char *signal, const char *type_data, void *signal_data) { /* make C compiler happy */ (void) pointer; (void) data; (void) signal; (void) type_data; logger_stop (logger_buffer_search_buffer (signal_data), 1); logger_start_buffer (signal_data, 1); return WEECHAT_RC_OK; } /* * Callback for signal "logger_start". */ int logger_start_signal_cb (const void *pointer, void *data, const char *signal, const char *type_data, void *signal_data) { /* make C compiler happy */ (void) pointer; (void) data; (void) signal; (void) type_data; logger_start_buffer (signal_data, 1); return WEECHAT_RC_OK; } /* * Callback for signal "logger_stop". */ int logger_stop_signal_cb (const void *pointer, void *data, const char *signal, const char *type_data, void *signal_data) { struct t_logger_buffer *ptr_logger_buffer; /* make C compiler happy */ (void) pointer; (void) data; (void) signal; (void) type_data; ptr_logger_buffer = logger_buffer_search_buffer (signal_data); if (ptr_logger_buffer) logger_stop (ptr_logger_buffer, 0); return WEECHAT_RC_OK; } /* * Adjusts log filenames for all buffers. * * Filename can change if configuration option is changed, or if day of system * date has changed. */ void logger_adjust_log_filenames () { struct t_infolist *ptr_infolist; struct t_logger_buffer *ptr_logger_buffer; struct t_gui_buffer *ptr_buffer; char *log_filename; ptr_infolist = weechat_infolist_get ("buffer", NULL, NULL); if (ptr_infolist) { while (weechat_infolist_next (ptr_infolist)) { ptr_buffer = weechat_infolist_pointer (ptr_infolist, "pointer"); ptr_logger_buffer = logger_buffer_search_buffer (ptr_buffer); if (ptr_logger_buffer && ptr_logger_buffer->log_filename) { log_filename = logger_get_filename (ptr_logger_buffer->buffer); if (log_filename) { if (strcmp (log_filename, ptr_logger_buffer->log_filename) != 0) { /* * log filename has changed (probably due to day * change),then we'll use new filename */ logger_stop (ptr_logger_buffer, 1); logger_start_buffer (ptr_buffer, 1); } free (log_filename); } } } weechat_infolist_free (ptr_infolist); } } /* * Callback for signal "day_changed". */ int logger_day_changed_signal_cb (const void *pointer, void *data, const char *signal, const char *type_data, void *signal_data) { /* make C compiler happy */ (void) pointer; (void) data; (void) signal; (void) type_data; (void) signal_data; logger_adjust_log_filenames (); return WEECHAT_RC_OK; } /* * Gets info with tags of line: log level and if prefix is a nick. */ void logger_get_line_tag_info (int tags_count, const char **tags, int *log_level, int *prefix_is_nick) { int i, log_level_set, prefix_is_nick_set; if (log_level) *log_level = LOGGER_LEVEL_DEFAULT; if (prefix_is_nick) *prefix_is_nick = 0; log_level_set = 0; prefix_is_nick_set = 0; for (i = 0; i < tags_count; i++) { if (log_level && !log_level_set) { if (strcmp (tags[i], "no_log") == 0) { /* log disabled on line: set level to -1 */ *log_level = -1; log_level_set = 1; } else if (strncmp (tags[i], "log", 3) == 0) { /* set log level for line */ if (isdigit ((unsigned char)tags[i][3])) { *log_level = (tags[i][3] - '0'); log_level_set = 1; } } } if (prefix_is_nick && !prefix_is_nick_set) { if (strncmp (tags[i], "prefix_nick", 11) == 0) { *prefix_is_nick = 1; prefix_is_nick_set = 1; } } } } /* * Callback for print hooked. */ int logger_print_cb (const void *pointer, void *data, struct t_gui_buffer *buffer, time_t date, int tags_count, const char **tags, int displayed, int highlight, const char *prefix, const char *message) { struct t_logger_buffer *ptr_logger_buffer; struct tm *date_tmp; char buf_time[256], *prefix_ansi, *message_ansi; const char *ptr_prefix, *ptr_message; int line_log_level, prefix_is_nick, color_lines; /* make C compiler happy */ (void) pointer; (void) data; (void) displayed; (void) highlight; logger_get_line_tag_info (tags_count, tags, &line_log_level, &prefix_is_nick); if (line_log_level < 0) return WEECHAT_RC_OK; ptr_logger_buffer = logger_buffer_search_buffer (buffer); if (ptr_logger_buffer && ptr_logger_buffer->log_enabled && (date > 0) && (line_log_level <= ptr_logger_buffer->log_level)) { prefix_ansi = NULL; message_ansi = NULL; color_lines = weechat_config_boolean (logger_config_file_color_lines); if (color_lines) { prefix_ansi = weechat_hook_modifier_exec ("color_encode_ansi", NULL, prefix); message_ansi = weechat_hook_modifier_exec ("color_encode_ansi", NULL, message); ptr_prefix = prefix_ansi; ptr_message = message_ansi; } else { ptr_prefix = prefix; ptr_message = message; } buf_time[0] = '\0'; date_tmp = localtime (&date); if (date_tmp) { if (strftime (buf_time, sizeof (buf_time) - 1, weechat_config_string (logger_config_file_time_format), date_tmp) == 0) buf_time[0] = '\0'; } logger_write_line ( ptr_logger_buffer, "%s\t%s%s%s\t%s%s", buf_time, (ptr_prefix && prefix_is_nick) ? weechat_config_string (logger_config_file_nick_prefix) : "", (ptr_prefix) ? ptr_prefix : "", (ptr_prefix && prefix_is_nick) ? weechat_config_string (logger_config_file_nick_suffix) : "", (color_lines) ? "\x1B[0m" : "", ptr_message); if (prefix_ansi) free (prefix_ansi); if (message_ansi) free (message_ansi); } return WEECHAT_RC_OK; } /* * Callback for logger timer. */ int logger_timer_cb (const void *pointer, void *data, int remaining_calls) { /* make C compiler happy */ (void) pointer; (void) data; (void) remaining_calls; logger_flush (); return WEECHAT_RC_OK; } /* * Initializes logger plugin. */ int weechat_plugin_init (struct t_weechat_plugin *plugin, int argc, char *argv[]) { /* make C compiler happy */ (void) argc; (void) argv; weechat_plugin = plugin; if (!logger_config_init ()) return WEECHAT_RC_ERROR; logger_config_read (); logger_command_init (); logger_start_buffer_all (1); weechat_hook_signal ("buffer_opened", &logger_buffer_opened_signal_cb, NULL, NULL); weechat_hook_signal ("buffer_closing", &logger_buffer_closing_signal_cb, NULL, NULL); weechat_hook_signal ("buffer_renamed", &logger_buffer_renamed_signal_cb, NULL, NULL); weechat_hook_signal ("logger_backlog", &logger_backlog_signal_cb, NULL, NULL); weechat_hook_signal ("logger_start", &logger_start_signal_cb, NULL, NULL); weechat_hook_signal ("logger_stop", &logger_stop_signal_cb, NULL, NULL); weechat_hook_signal ("day_changed", &logger_day_changed_signal_cb, NULL, NULL); logger_config_color_lines_change (NULL, NULL, NULL); logger_info_init (); return WEECHAT_RC_OK; } /* * Ends logger plugin. */ int weechat_plugin_end (struct t_weechat_plugin *plugin) { /* make C compiler happy */ (void) plugin; if (logger_hook_print) { weechat_unhook (logger_hook_print); logger_hook_print = NULL; } if (logger_hook_timer) { weechat_unhook (logger_hook_timer); logger_hook_timer = NULL; } logger_config_write (); logger_stop_all (1); logger_config_free (); return WEECHAT_RC_OK; }