New backlog option in logger plugin, added variable names in .h files, replaced "void *" pointers by structures

src/plugins/logger/CMakeLists.txt

@@ -14,7 +14,8 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-ADD_LIBRARY(logger MODULE logger.c logger-buffer.c logger-buffer.h)
+ADD_LIBRARY(logger MODULE logger.c logger.h logger-buffer.c logger-buffer.h
+logger-tail.c logger-tail.h)
 SET_TARGET_PROPERTIES(logger PROPERTIES PREFIX "")
 
 TARGET_LINK_LIBRARIES(logger)

src/plugins/logger/Makefile.am

@@ -20,6 +20,11 @@ libdir = ${weechat_libdir}/plugins
 
 lib_LTLIBRARIES = logger.la
 
-logger_la_SOURCES = logger.c logger-buffer.c logger-buffer.h
+logger_la_SOURCES = logger.c \
+                    logger.h \
+                    logger-buffer.c \
+                    logger-buffer.h \
+                    logger-tail.c \
+                    logger-tail.h
 logger_la_LDFLAGS = -module
 logger_la_LIBADD  = $(LOGGER_LFLAGS)

src/plugins/logger/logger-buffer.c

@@ -39,7 +39,7 @@ struct t_logger_buffer *last_logger_buffer = NULL;
  */
 
 struct t_logger_buffer *
-logger_buffer_add (void *buffer, char *log_filename)
+logger_buffer_add (struct t_gui_buffer *buffer, char *log_filename)
 {
     struct t_logger_buffer *new_logger_buffer;
     
@@ -52,6 +52,7 @@ logger_buffer_add (void *buffer, char *log_filename)
         new_logger_buffer->buffer = buffer;
         new_logger_buffer->log_filename = strdup (log_filename);
         new_logger_buffer->log_file = NULL;
+        new_logger_buffer->log_enabled = 1;
         
         new_logger_buffer->prev_buffer = last_logger_buffer;
         new_logger_buffer->next_buffer = NULL;
@@ -70,14 +71,14 @@ logger_buffer_add (void *buffer, char *log_filename)
  */
 
 struct t_logger_buffer *
-logger_buffer_search (void *buffer)
+logger_buffer_search (struct t_gui_buffer *buffer)
 {
     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->buffer == (struct t_gui_buffer *)buffer)
+        if (ptr_logger_buffer->buffer == buffer)
             return ptr_logger_buffer;
     }
     
@@ -116,25 +117,11 @@ logger_buffer_free (struct t_logger_buffer *logger_buffer)
 }
 
 /*
- * logger_buffer_remove: remove a buffer from list
+ * logger_buffer_free_all: remove all buffers from list
  */
 
 void
-logger_buffer_remove (void *buffer)
-{
-    struct t_logger_buffer *ptr_logger_buffer;
-    
-    ptr_logger_buffer = logger_buffer_search (buffer);
-    if (ptr_logger_buffer)
-        logger_buffer_free (ptr_logger_buffer);
-}
-
-/*
- * logger_buffer_remove_all: remove all buffers from list
- */
-
-void
-logger_buffer_remove_all ()
+logger_buffer_free_all ()
 {
     while (logger_buffers)
     {

src/plugins/logger/logger-buffer.h

@@ -25,6 +25,7 @@ struct t_logger_buffer
     struct t_gui_buffer *buffer;          /* pointer to buffer              */
     char *log_filename;                   /* log filename                   */
     FILE *log_file;                       /* log file                       */
+    int log_enabled;                      /* log enabled ?                  */
     struct t_logger_buffer *prev_buffer;  /* link to previous buffer        */
     struct t_logger_buffer *next_buffer;  /* link to next buffer            */
 };
@@ -32,9 +33,10 @@ struct t_logger_buffer
 extern struct t_logger_buffer *logger_buffers;
 extern struct t_logger_buffer *last_logger_buffer;
 
-extern struct t_logger_buffer *logger_buffer_add (void *, char *);
-extern struct t_logger_buffer *logger_buffer_search (void *);
-extern void logger_buffer_remove (void *);
-extern void logger_buffer_remove_all ();
+extern struct t_logger_buffer *logger_buffer_add (struct t_gui_buffer *,
+                                                  char *log_filename);
+extern struct t_logger_buffer *logger_buffer_search (struct t_gui_buffer *buffer);
+extern void logger_buffer_free (struct t_logger_buffer *logger_buffer);
+extern void logger_buffer_free_all ();
 
 #endif /* logger-buffer.h */

src/plugins/logger/logger-tail.c

@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2003-2007 by FlashCode <flashcode@flashtux.org>
+ * See README for License detail, AUTHORS for developers list.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+/* logger-tail.c: return last lines of a file */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include "logger.h"
+#include "logger-tail.h"
+
+
+#define LOGGER_TAIL_BUFSIZE 4096
+
+
+/*
+ * logger_tail_last_eol: find last eol in a string
+ */
+
+char *
+logger_tail_last_eol (char *string_start, char *string_ptr)
+{
+    while (string_ptr >= string_start)
+    {
+        if ((string_ptr[0] == '\n') || (string_ptr[0] == '\r'))
+            return string_ptr;
+        string_ptr--;
+    }
+    
+    /* no end-of-line found in string */
+    return NULL;
+}
+
+/*
+ * logger_tail_file: return last lines of a file
+ */
+
+struct t_logger_line *
+logger_tail_file (char *filename, int n_lines)
+{
+    int fd;
+    off_t file_length, file_pos;
+    size_t to_read;
+    ssize_t bytes_read;
+    char buf[LOGGER_TAIL_BUFSIZE + 1];
+    char *ptr_buf, *pos_eol, *part_of_line, *new_part_of_line;
+    struct t_logger_line *ptr_line, *new_line;
+    
+    /* open file */
+    fd = open (filename, O_RDONLY);
+    if (fd == -1)
+        return NULL;
+    
+    /* seek to the end of file */
+    file_length = lseek (fd, (off_t)0, SEEK_END);
+    if (file_length <= 0)
+    {
+        close (fd);
+        return NULL;
+    }
+    to_read = file_length;
+    file_pos = file_length - LOGGER_TAIL_BUFSIZE;
+    if (file_pos < 0)
+        file_pos = 0;
+    else
+        to_read = LOGGER_TAIL_BUFSIZE;
+    lseek (fd, file_pos, SEEK_SET);
+    
+    /* loop until we have "n_lines" lines in list */
+    part_of_line = NULL;
+    ptr_line = NULL;
+    while (n_lines > 0)
+    {
+        lseek (fd, file_pos, SEEK_SET);
+        bytes_read = read (fd, buf, to_read);
+        if (bytes_read <= 0)
+        {
+            logger_tail_free (ptr_line);
+            close (fd);
+            return NULL;
+        }
+        buf[bytes_read] = '\0';
+        ptr_buf = buf + bytes_read - 1;
+        while (ptr_buf && (ptr_buf >= buf))
+        {
+            pos_eol = logger_tail_last_eol (buf, ptr_buf);
+            if ((pos_eol && pos_eol[1]) || (!pos_eol && (file_pos == 0)))
+            {
+                /* use data and part_of_line (if existing) to build a new line */
+                if (!pos_eol)
+                {
+                    ptr_buf = NULL;
+                    pos_eol = buf;
+                }
+                else
+                {
+                    ptr_buf = pos_eol - 1;
+                    pos_eol[0] = '\0';
+                    pos_eol++;
+                }
+                new_line = (struct t_logger_line *)malloc (sizeof (struct t_logger_line));
+                if (!new_line)
+                {
+                    logger_tail_free (ptr_line);
+                    ptr_line = NULL;
+                    break;
+                }
+                if (part_of_line)
+                {
+                    new_line->data = (char *)malloc (strlen (pos_eol) +
+                                                     strlen (part_of_line) + 1);
+                    if (!new_line->data)
+                    {
+                        free (part_of_line);
+                        logger_tail_free (ptr_line);
+                        close (fd);
+                        return NULL;
+                    }
+                    strcpy (new_line->data, pos_eol);
+                    strcat (new_line->data, part_of_line);
+                    free (part_of_line);
+                    part_of_line = NULL;
+                }
+                else
+                {
+                    new_line->data = strdup (pos_eol);
+                }
+                new_line->next_line = ptr_line;
+                ptr_line = new_line;
+                n_lines--;
+                if (n_lines <= 0)
+                    break;
+            }
+            else if (!pos_eol)
+            {
+                /* beginning of read buffer reached without EOL, then we
+                   add string to part_of_line, we'll use that later */
+                if (part_of_line)
+                {
+                    new_part_of_line = (char *)malloc (strlen (buf) +
+                                                       strlen (part_of_line) + 1);
+                    if (!new_part_of_line)
+                    {
+                        free (part_of_line);
+                        logger_tail_free (ptr_line);
+                        close (fd);
+                        return NULL;
+                    }
+                    strcpy (new_part_of_line, buf);
+                    strcat (new_part_of_line, part_of_line);
+                    free (part_of_line);
+                    part_of_line = new_part_of_line;
+                }
+                else
+                {
+                    part_of_line = (char *)malloc (strlen (buf) + 1);
+                    strcpy (part_of_line, buf);
+                }
+                ptr_buf = NULL;
+            }
+            else
+                ptr_buf = pos_eol - 1;
+        }
+        if (file_pos == 0)
+            break;
+        to_read = file_pos;
+        file_pos -= LOGGER_TAIL_BUFSIZE;
+        if (file_pos < 0)
+            file_pos = 0;
+        else
+            to_read = LOGGER_TAIL_BUFSIZE;
+    }
+    
+    if (part_of_line)
+        free (part_of_line);
+    
+    close (fd);
+    
+    return ptr_line;
+}
+
+/*
+ * logger_tail_free: free structure returned by "logger_tail_file" function
+ */
+
+void
+logger_tail_free (struct t_logger_line *lines)
+{
+    if (!lines)
+        return;
+    
+    while (lines->next_line)
+    {
+        if (lines->data)
+            free (lines->data);
+        lines = lines->next_line;
+    }
+    free (lines);
+}

src/plugins/logger/logger-tail.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2003-2007 by FlashCode <flashcode@flashtux.org>
+ * See README for License detail, AUTHORS for developers list.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef __WEECHAT_LOGGER_TAIL_H
+#define __WEECHAT_LOGGER_TAIL_H 1
+
+struct t_logger_line
+{
+    char *data;                        /* line content                      */
+    struct t_logger_line *next_line;   /* link to next line                 */
+};
+
+extern struct t_logger_line *logger_tail_file (char *filename, int n_lines);
+extern void logger_tail_free (struct t_logger_line *lines);
+
+#endif /* logger-tail.h */

src/plugins/logger/logger.c

@@ -34,8 +34,9 @@
 #include <fcntl.h>
 #include <time.h>
 
-#include "../weechat-plugin.h"
+#include "logger.h"
 #include "logger-buffer.h"
+#include "logger-tail.h"
 
 
 char plugin_name[] = "logger";
@@ -43,36 +44,74 @@ char plugin_version[]     = "0.1";
 char plugin_description[] = "Logger plugin for WeeChat";
 
 struct t_weechat_plugin *weechat_logger_plugin = NULL;
-#define weechat_plugin weechat_logger_plugin
 
-char *logger_path = NULL;
-char *logger_time_format = NULL;
+#define LOGGER_OPTION_PATH        "path"
+#define LOGGER_OPTION_TIME_FORMAT "time_format"
+#define LOGGER_OPTION_INFO_LINES  "info_lines"
+#define LOGGER_OPTION_BACKLOG     "backlog"
+
+char *logger_option_path = NULL;
+char *logger_option_time_format = NULL;
+int logger_option_info_lines;
+int logger_option_backlog;
 
 
 /*
  * logger_config_read: read config options for logger plugin
+ *                     return: 1 if ok
+ *                             0 if error
  */
 
-void
+int
 logger_config_read ()
 {
-    if (logger_path)
-        free (logger_path);
-    logger_path = weechat_plugin_config_get ("path");
-    if (!logger_path)
+    long number;
+    char *string, *error;
+    
+    logger_option_path = weechat_config_get_plugin (LOGGER_OPTION_PATH);
+    if (!logger_option_path)
     {
-        weechat_plugin_config_set ("path", "%h/logs/");
-        logger_path = weechat_plugin_config_get ("path");
+        weechat_config_set_plugin (LOGGER_OPTION_PATH, "%h/logs/");
+        logger_option_path = weechat_config_get_plugin ("path");
     }
-
-    if (logger_time_format)
-        free (logger_time_format);
-    logger_time_format = weechat_plugin_config_get ("time_format");
-    if (!logger_time_format)
+    
+    logger_option_time_format = weechat_config_get_plugin (LOGGER_OPTION_TIME_FORMAT);
+    if (!logger_option_time_format)
     {
-        weechat_plugin_config_set ("time_format", "%Y %b %d %H:%M:%S");
-        logger_time_format = weechat_plugin_config_get ("time_format");
+        weechat_config_set_plugin (LOGGER_OPTION_TIME_FORMAT,
+                                   "%Y %b %d %H:%M:%S");
+        logger_option_time_format = weechat_config_get_plugin (LOGGER_OPTION_TIME_FORMAT);
     }
+    
+    string = weechat_config_get_plugin (LOGGER_OPTION_INFO_LINES);
+    if (!string)
+    {
+        weechat_config_set_plugin (LOGGER_OPTION_INFO_LINES, "off");
+        string = weechat_config_get_plugin (LOGGER_OPTION_INFO_LINES);
+    }
+    if (string && (weechat_config_string_to_boolean (string) > 0))
+        logger_option_info_lines = 1;
+    else
+        logger_option_info_lines = 0;
+    
+    string = weechat_config_get_plugin (LOGGER_OPTION_BACKLOG);
+    if (!string)
+    {
+        weechat_config_set_plugin (LOGGER_OPTION_BACKLOG, "20");
+        string = weechat_config_get_plugin (LOGGER_OPTION_BACKLOG);
+    }
+    logger_option_backlog = 20;
+    if (string)
+    {
+        error = NULL;
+        number = strtol (string, &error, 10);
+        if (error && (error[0] == '\0'))
+            logger_option_backlog = number;
+    }
+    if (logger_option_path && logger_option_time_format && logger_option_backlog)
+        return 1;
+    else
+        return 0;
 }
 
 /*
@@ -88,7 +127,7 @@ logger_create_directory ()
     
     rc = 1;
     
-    dir1 = weechat_string_replace (logger_path, "~", getenv ("HOME"));
+    dir1 = weechat_string_replace (logger_option_path, "~", getenv ("HOME"));
     if (dir1)
     {
         weechat_dir = weechat_info_get ("weechat_dir");
@@ -99,7 +138,8 @@ logger_create_directory ()
             {
                 if (mkdir (dir2, 0755) < 0)
                 {
-                    if (errno != EEXIST)                        rc = 0;
+                    if (errno != EEXIST)
+                        rc = 0;
                 }
                 else
                     chmod (dir2, 0700);
@@ -124,7 +164,7 @@ logger_create_directory ()
  */
 
 char *
-logger_get_filename (void *buffer)
+logger_get_filename (struct t_gui_buffer *buffer)
 {
     struct t_plugin_infolist *ptr_infolist;
     char *res;
@@ -136,7 +176,8 @@ logger_get_filename (void *buffer)
     
     dir_separator = weechat_info_get ("dir_separator");
     weechat_dir = weechat_info_get ("weechat_dir");
-    log_path = weechat_string_replace (logger_path, "~", getenv ("HOME"));
+    log_path = weechat_string_replace (logger_option_path, "~",
+                                       getenv ("HOME"));
     log_path2 = weechat_string_replace (log_path, "%h", weechat_dir);
     
     if (dir_separator && weechat_dir && log_path && log_path2)
@@ -230,22 +271,25 @@ logger_write_line (struct t_logger_buffer *logger_buffer, char *format, ...)
                     free (charset);
                 return;
             }
-            
-            seconds = time (NULL);
-            date_tmp = localtime (&seconds);
-            buf_time[0] = '\0';
-            if (date_tmp)
-                strftime (buf_time, sizeof (buf_time) - 1,
-                          logger_time_format, date_tmp);
-            snprintf (buf, sizeof (buf) - 1,
-                      _("****  Beginning of log  %s  ****"),
-                      buf_time);
-            message = (charset) ?
-                weechat_iconv_from_internal (charset, buf) : NULL;
-            fprintf (logger_buffer->log_file,
-                     "%s\n", (message) ? message : buf);
-            if (message)
-                free (message);
+
+            if (logger_option_info_lines)
+            {
+                seconds = time (NULL);
+                date_tmp = localtime (&seconds);
+                buf_time[0] = '\0';
+                if (date_tmp)
+                    strftime (buf_time, sizeof (buf_time) - 1,
+                              logger_option_time_format, date_tmp);
+                snprintf (buf, sizeof (buf) - 1,
+                          _("%s\t****  Beginning of log  ****"),
+                          buf_time);
+                message = (charset) ?
+                    weechat_iconv_from_internal (charset, buf) : NULL;
+                fprintf (logger_buffer->log_file,
+                         "%s\n", (message) ? message : buf);
+                if (message)
+                    free (message);
+            }
         }
         
         va_start (argptr, format);
@@ -270,7 +314,7 @@ logger_write_line (struct t_logger_buffer *logger_buffer, char *format, ...)
  */
 
 void
-logger_start_buffer (void *buffer)
+logger_start_buffer (struct t_gui_buffer *buffer)
 {
     struct t_logger_buffer *ptr_logger_buffer;
     char *log_filename;
@@ -333,18 +377,21 @@ logger_end (struct t_logger_buffer *logger_buffer)
     
     if (logger_buffer->log_file)
     {
-        seconds = time (NULL);
-        date_tmp = localtime (&seconds);
-        buf_time[0] = '\0';
-        if (date_tmp)
-            strftime (buf_time, sizeof (buf_time) - 1,
-                      logger_time_format, date_tmp);
-        logger_write_line (logger_buffer,
-                           _("****  End of log  %s  ****"),
-                           buf_time);
+        if (logger_option_info_lines)
+        {
+            seconds = time (NULL);
+            date_tmp = localtime (&seconds);
+            buf_time[0] = '\0';
+            if (date_tmp)
+                strftime (buf_time, sizeof (buf_time) - 1,
+                          logger_option_time_format, date_tmp);
+            logger_write_line (logger_buffer,
+                               _("%s\t****  End of log  ****"),
+                               buf_time);
+        }
         fclose (logger_buffer->log_file);
         logger_buffer->log_file = NULL;
-        logger_buffer_remove (logger_buffer);
+        logger_buffer_free (logger_buffer);
     }
 }
 
@@ -356,7 +403,7 @@ void
 logger_end_all ()
 {
     struct t_logger_buffer *ptr_logger_buffer;
-
+    
     for (ptr_logger_buffer = logger_buffers; ptr_logger_buffer;
          ptr_logger_buffer = ptr_logger_buffer->next_buffer)
     {
@@ -365,7 +412,7 @@ logger_end_all ()
 }
 
 /*
- * logger_buffer_open_signal_cb: callback for buffer_open signal
+ * logger_buffer_open_signal_cb: callback for "buffer_open" signal
  */
 
 int
@@ -382,7 +429,7 @@ logger_buffer_open_signal_cb (void *data, char *signal, void *pointer)
 }
 
 /*
- * logger_buffer_close_signal_cb: callback for buffer_close signal
+ * logger_buffer_close_signal_cb: callback for "buffer_close" signal
  */
 
 int
@@ -398,13 +445,96 @@ logger_buffer_close_signal_cb (void *data, char *signal, void *pointer)
     return WEECHAT_RC_OK;
 }
 
+/*
+ * logger_backlog: display backlog for a buffer (by reading end of log file)
+ */
+
+void
+logger_backlog (struct t_gui_buffer *buffer, char *filename, int lines)
+{
+    struct t_logger_line *last_lines, *ptr_lines;
+    char *pos_message, *error;
+    time_t datetime;
+    struct tm tm_line;
+    int num_lines;
+    
+    num_lines = 0;
+    last_lines = logger_tail_file (filename, lines);
+    ptr_lines = last_lines;
+    while (ptr_lines)
+    {
+        datetime = 0;
+        pos_message = strchr (ptr_lines->data, '\t');
+        if (pos_message)
+        {
+            pos_message[0] = '\0';
+            error = strptime (ptr_lines->data, logger_option_time_format,
+                              &tm_line);
+            if (error && !error[0])
+                datetime = mktime (&tm_line);
+            pos_message[0] = '\t';
+        }
+        if (pos_message)
+        {
+            if (datetime != 0)
+                weechat_printf_date (buffer, datetime, pos_message + 1);
+            else
+                weechat_printf (buffer, ptr_lines->data);
+        }
+        else
+        {
+            weechat_printf (buffer, ptr_lines->data);
+        }
+        num_lines++;
+        ptr_lines = ptr_lines->next_line;
+    }
+    if (last_lines)
+        logger_tail_free (last_lines);
+    if (num_lines > 0)
+        weechat_printf (buffer,
+                        _("===\t========== End of backlog (%d lines) =========="),
+                        num_lines);
+}
+
+/*
+ * logger_backlog_signal_cb: callback for "logger_backlog" signal
+ */
+
+int
+logger_backlog_signal_cb (void *data, char *signal, void *pointer)
+{
+    struct t_logger_buffer *ptr_logger_buffer;
+    
+    /* make C compiler happy */
+    (void) data;
+    (void) signal;
+
+    if (logger_option_backlog >= 0)
+    {
+        ptr_logger_buffer = logger_buffer_search (pointer);
+        if (ptr_logger_buffer && ptr_logger_buffer->log_filename
+            && ptr_logger_buffer->log_enabled)
+        {
+            ptr_logger_buffer->log_enabled = 0;
+            
+            logger_backlog (pointer,
+                            ptr_logger_buffer->log_filename,
+                            logger_option_backlog);
+            
+            ptr_logger_buffer->log_enabled = 1;
+        }
+    }
+    
+    return WEECHAT_RC_OK;
+}
+
 /*
  * logger_print_cb: callback for print hook
  */
 
 int
-logger_print_cb (void *data, void *buffer, time_t date, char *prefix,
-                 char *message)
+logger_print_cb (void *data, struct t_gui_buffer *buffer, time_t date,
+                 char *prefix, char *message)
 {
     struct t_logger_buffer *ptr_logger_buffer;
     struct tm *date_tmp;
@@ -414,26 +544,43 @@ logger_print_cb (void *data, void *buffer, time_t date, char *prefix,
     (void) data;
 
     ptr_logger_buffer = logger_buffer_search (buffer);
-    if (ptr_logger_buffer && ptr_logger_buffer->log_filename)
+    if (ptr_logger_buffer && ptr_logger_buffer->log_filename
+        && ptr_logger_buffer->log_enabled)
     {
         date_tmp = localtime (&date);
         buf_time[0] = '\0';
         if (date_tmp)
             strftime (buf_time, sizeof (buf_time) - 1,
-                      logger_time_format, date_tmp);
+                      logger_option_time_format, date_tmp);
         
         logger_write_line (ptr_logger_buffer,
-                           "%s%s%s%s%s",
+                           "%s\t%s\t%s",
                            buf_time,
-                           (buf_time[0]) ? "  " : "",
                            (prefix) ? prefix : "",
-                           (prefix && prefix[0]) ? " " : "",
                            message);
     }
     
     return WEECHAT_RC_OK;
 }
 
+/*
+ * logger_config_cb: callback for config hook
+ */
+
+int
+logger_config_cb (void *data, char *type, char *option, char *value)
+{
+    /* make C compiler happy */
+    (void) data;
+    (void) type;
+    (void) option;
+    (void) value;
+    
+    logger_config_read ();
+    
+    return WEECHAT_RC_OK;
+}
+
 /*
  * weechat_plugin_init: initialize logger plugin
  */
@@ -443,8 +590,7 @@ weechat_plugin_init (struct t_weechat_plugin *plugin)
 {
     weechat_plugin = plugin;
     
-    logger_config_read ();
-    if (!logger_path || !logger_time_format)
+    if (!logger_config_read ())
         return WEECHAT_RC_ERROR;
     if (!logger_create_directory ())
         return WEECHAT_RC_ERROR;
@@ -453,9 +599,19 @@ weechat_plugin_init (struct t_weechat_plugin *plugin)
     
     weechat_hook_signal ("buffer_open", &logger_buffer_open_signal_cb, NULL);
     weechat_hook_signal ("buffer_close", &logger_buffer_close_signal_cb, NULL);
+    weechat_hook_signal ("logger_backlog", &logger_backlog_signal_cb, NULL);
     
     weechat_hook_print (NULL, NULL, 1, &logger_print_cb, NULL);
     
+    weechat_hook_config ("plugin", "logger." LOGGER_OPTION_PATH,
+                         &logger_config_cb, NULL);
+    weechat_hook_config ("plugin", "logger." LOGGER_OPTION_TIME_FORMAT,
+                         &logger_config_cb, NULL);
+    weechat_hook_config ("plugin", "logger." LOGGER_OPTION_INFO_LINES,
+                         &logger_config_cb, NULL);
+    weechat_hook_config ("plugin", "logger." LOGGER_OPTION_BACKLOG,
+                         &logger_config_cb, NULL);
+    
     return WEECHAT_RC_OK;
 }
 

src/plugins/logger/logger.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2003-2007 by FlashCode <flashcode@flashtux.org>
+ * See README for License detail, AUTHORS for developers list.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef __WEECHAT_LOGGER_H
+#define __WEECHAT_LOGGER_H 1
+
+#include "../weechat-plugin.h"
+
+#define weechat_plugin weechat_logger_plugin
+
+extern struct t_weechat_plugin *weechat_logger_plugin;
+
+#endif /* logger.h */