Add new features to logger plugin (command /logger, log level, level by buffer, mask by buffer, ..), fix some bugs

New features:
- new command /logger
- log level, to log only some messages, according to importance (task #8592)
- level by buffer: custom level for some buffers (or group of buffers)
- log filename mask by buffer (or group of buffers)
- marker line is added after display of backlog
- add "delete" callback for config file sections
- add "mkdir_parents" function to plugin API
- remove old log options in IRC plugin

Bug fix:
- marker line is set only when user switches buffer (not when a plugin force
  switch, like IRC plugin does when opening server or channel buffer)
- backlog fixed (sometimes lines were not properly displayed)

1 files changed, 578 insertions, 170 deletions

diff --git a/src/plugins/logger/logger.c b/src/plugins/logger/logger.c
index 9d3bbf597..fbf947fb4 100644
--- a/src/plugins/logger/logger.c
+++ b/src/plugins/logger/logger.c
@@ -29,6 +29,7 @@
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
+#include <ctype.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -51,10 +52,45 @@ WEECHAT_PLUGIN_LICENSE("GPL3");
 
 struct t_weechat_plugin *weechat_logger_plugin = NULL;
 
+int logger_debug = 0;
+
 char *logger_buf_write = NULL;         /* buffer for writing a line         */
 
 
 /*
+ * logger_debug_cb: callback for "debug" signal
+ */
+
+int
+logger_debug_cb (void *data, const char *signal, const char *type_data,
+                 void *signal_data)
+{
+    /* make C compiler happy */
+    (void) data;
+    (void) signal;
+    
+    if (strcmp (type_data, WEECHAT_HOOK_SIGNAL_STRING) == 0)
+    {
+        if (weechat_strcasecmp ((char *)signal_data, LOGGER_PLUGIN_NAME) == 0)
+        {
+            logger_debug ^= 1;
+            if (logger_debug)
+            {
+                weechat_printf (NULL, _("%s: debug enabled"),
+                                LOGGER_PLUGIN_NAME);
+            }
+            else
+            {
+                weechat_printf (NULL, _("%s: debug disabled"),
+                                LOGGER_PLUGIN_NAME);
+            }
+        }
+    }
+    
+    return WEECHAT_RC_OK;
+}
+
+/*
  * logger_create_directory: create logger directory
  *                          return 1 if success (directory created or already
  *                          exists), 0 if failed
@@ -78,13 +114,9 @@ logger_create_directory ()
             dir2 = weechat_string_replace (dir1, "%h", weechat_dir);
             if (dir2)
             {
-                if (mkdir (dir2, 0755) < 0)
-                {
-                    if (errno != EEXIST)
-                        rc = 0;
-                }
-                else
-                    chmod (dir2, 0700);
+                if (!weechat_mkdir_parents (dir2, 0700))
+                    rc = 0;
+                
                 free (dir2);
             }
             else
@@ -101,20 +133,179 @@ logger_create_directory ()
 }
 
 /*
+ * logger_build_option_name: build option name with a buffer
+ */
+
+char *
+logger_build_option_name (struct t_gui_buffer *buffer)
+{
+    char *plugin_name, *name, *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;
+}
+
+/*
+ * logger_get_level_for_buffer: get logging level for buffer (0 = disabled, 1..9)
+ */
+
+int
+logger_get_level_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 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;
+}
+
+/*
+ * logger_get_mask_for_buffer: get filename mask for a buffer
+ *                             we first try with all arguments, then remove one by
+ *                             one to find mask (from specific to general mask)
+ */
+
+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;
+}
+
+/*
  * logger_get_filename: build log filename for a buffer
  */
 
 char *
 logger_get_filename (struct t_gui_buffer *buffer)
 {
-    struct t_infolist *ptr_infolist;
-    char *res;
-    char *dir_separator, *weechat_dir, *log_path, *log_path2;
-    char *plugin_name, *plugin_name2, *name, *name2;
+    char *res, *mask, *mask_decoded, *dir_separator, *weechat_dir;
+    char *log_path, *log_path2, *pos_last_sep;
     int length;
     
     res = NULL;
     
+    /* get filename mask for buffer */
+    mask = logger_get_mask_for_buffer (buffer);
+    if (!mask)
+    {
+        weechat_printf (NULL,
+                        _("%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"));
+        return NULL;
+    }
+    mask_decoded = weechat_buffer_string_replace_local_var (buffer, mask);
+    if (!mask_decoded)
+        return NULL;
+    
+    if (logger_debug)
+    {
+        weechat_printf (NULL,
+                        "%s: buffer = \"%s\", mask = \"%s\", "
+                        "decoded mask = \"%s\"",
+                        LOGGER_PLUGIN_NAME,
+                        weechat_buffer_get_string (buffer, "name"),
+                        mask, mask_decoded);
+    }
+    
+    if (weechat_config_boolean (logger_config_file_name_lower_case))
+        weechat_string_tolower (mask_decoded);
+    
     dir_separator = weechat_info_get ("dir_separator", "");
     weechat_dir = weechat_info_get ("weechat_dir", "");
     log_path = weechat_string_replace (weechat_config_string (logger_config_file_path),
@@ -123,49 +314,17 @@ logger_get_filename (struct t_gui_buffer *buffer)
     
     if (dir_separator && weechat_dir && log_path && log_path2)
     {
-        ptr_infolist = weechat_infolist_get ("buffer", buffer, NULL);
-        if (ptr_infolist)
+        length = strlen (log_path2) + strlen (mask_decoded) + 1;
+        res = malloc (length);
+        if (res)
         {
-            plugin_name2 = NULL;
-            name2 = NULL;
-            if (weechat_infolist_next (ptr_infolist))
-            {
-                plugin_name = weechat_infolist_string (ptr_infolist, "plugin_name");
-                plugin_name2 = (plugin_name) ?
-                    weechat_string_replace (plugin_name, dir_separator, "_") : NULL;
-                name = weechat_infolist_string (ptr_infolist, "name");
-                name2 = (name) ?
-                    weechat_string_replace (name, dir_separator, "_") : NULL;
-            }
-            length = strlen (log_path2);
-            if (plugin_name2)
-                length += strlen (plugin_name2) + 1;
-            if (name2)
-                length += strlen (name2) + 1;
-            length += 16;
-            res = malloc (length);
-            if (res)
-            {
-                strcpy (res, log_path2);
-                if (plugin_name2)
-                {
-                    if (weechat_config_boolean (logger_config_file_name_lower_case))
-                        weechat_string_tolower (plugin_name2);
-                    strcat (res, plugin_name2);
-                    strcat (res, ".");
-                }
-                if (name2)
-                {
-                    if (weechat_config_boolean (logger_config_file_name_lower_case))
-                        weechat_string_tolower (name2);
-                    strcat (res, name2);
-                    strcat (res, ".");
-                }
-                strcat (res, "weechatlog");
-            }
-            if (name2)
-                free (name2);
-            weechat_infolist_free (ptr_infolist);
+            snprintf (res, length, "%s%s", log_path2, mask_decoded);
+            pos_last_sep = strrchr (res, dir_separator[0]);
+            if (pos_last_sep)
+                pos_last_sep[0] = '\0';
+            weechat_mkdir_parents (res, 0700);
+            if (pos_last_sep)
+                pos_last_sep[0] = dir_separator[0];
         }
     }
     
@@ -178,6 +337,44 @@ logger_get_filename (struct t_gui_buffer *buffer)
 }
 
 /*
+ * logger_set_log_filename: set log filename for a logger buffer
+ */
+
+void
+logger_set_log_filename (struct t_logger_buffer *logger_buffer)
+{
+    char *log_filename;
+    struct t_logger_buffer *ptr_logger_buffer;
+    
+    log_filename = logger_get_filename (logger_buffer->buffer);
+    if (!log_filename)
+    {
+        weechat_printf (NULL,
+                        _("%s%s: not enough memory"),
+                        weechat_prefix ("error"),
+                        LOGGER_PLUGIN_NAME);
+        return;
+    }
+    
+    ptr_logger_buffer = logger_buffer_search_log_filename (log_filename);
+    if (ptr_logger_buffer)
+    {
+        weechat_printf (NULL,
+                        _("%s%s: unable to start logging for buffer "
+                          "\"%s\": filename \"%s\" is already user 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;
+    }
+    
+    logger_buffer->log_filename = log_filename;
+}
+
+/*
  * logger_write_line: write a line to log file
  */
 
@@ -190,75 +387,130 @@ logger_write_line (struct t_logger_buffer *logger_buffer,
     time_t seconds;
     struct tm *date_tmp;
     char buf_time[256];
-
+    
     if (!logger_buf_write)
         logger_buf_write = malloc (LOGGER_BUF_WRITE_SIZE);
     if (!logger_buf_write)
         return;
     
-    if (logger_buffer->log_filename)
+    charset = weechat_info_get ("charset_terminal", "");
+    
+    if (!logger_buffer->log_file)
     {
-        charset = weechat_info_get ("charset_terminal", "");
+        if (!logger_create_directory ())
+        {
+            weechat_printf (NULL,
+                            _("%s%s: unable to create directory for logs "
+                              "(\"%s\")"),
+                            weechat_prefix ("error"), LOGGER_PLUGIN_NAME,
+                            weechat_config_string (logger_config_file_path));
+            logger_buffer_free (logger_buffer);
+            return;
+        }
+        if (!logger_buffer->log_filename)
+            logger_set_log_filename (logger_buffer);
         
-        if (!logger_buffer->log_file)
+        if (!logger_buffer->log_filename)
         {
-            if (!logger_create_directory ())
-            {
-                weechat_printf (NULL,
-                                _("%s%s: unable to create directory for logs "
-                                  "(\"%s\")"),
-                                weechat_prefix ("error"), LOGGER_PLUGIN_NAME,
-                                weechat_config_string (logger_config_file_path));
-                free (logger_buffer->log_filename);
-                logger_buffer->log_filename = NULL;
-                return;
-            }
-            logger_buffer->log_file =
-                fopen (logger_buffer->log_filename, "a");
-            if (!logger_buffer->log_file)
-            {
-                weechat_printf (NULL,
-                                _("%s%s: unable to write log file \"%s\""),
-                                weechat_prefix ("error"), LOGGER_PLUGIN_NAME,
-                                logger_buffer->log_filename);
-                free (logger_buffer->log_filename);
-                logger_buffer->log_filename = NULL;
-                return;
-            }
-            
-            if (weechat_config_boolean (logger_config_file_info_lines))
-            {
-                seconds = time (NULL);
-                date_tmp = localtime (&seconds);
-                buf_time[0] = '\0';
-                if (date_tmp)
-                    strftime (buf_time, sizeof (buf_time) - 1,
-                              weechat_config_string (logger_config_file_time_format),
-                              date_tmp);
-                snprintf (logger_buf_write, LOGGER_BUF_WRITE_SIZE,
-                          _("%s\t****  Beginning of log  ****"),
-                          buf_time);
-                message = (charset) ?
-                    weechat_iconv_from_internal (charset, logger_buf_write) : NULL;
-                fprintf (logger_buffer->log_file,
-                         "%s\n", (message) ? message : logger_buf_write);
-                if (message)
-                    free (message);
-            }
+            logger_buffer_free (logger_buffer);
+            return;
         }
-
-        va_start (argptr, format);
-        vsnprintf (logger_buf_write, LOGGER_BUF_WRITE_SIZE, format, argptr);
-        va_end (argptr);
         
-        message = (charset) ?
-            weechat_iconv_from_internal (charset, logger_buf_write) : NULL;
+        logger_buffer->log_file =
+            fopen (logger_buffer->log_filename, "a");
+        if (!logger_buffer->log_file)
+        {
+            weechat_printf (NULL,
+                            _("%s%s: unable to write log file \"%s\""),
+                            weechat_prefix ("error"), LOGGER_PLUGIN_NAME,
+                            logger_buffer->log_filename);
+            logger_buffer_free (logger_buffer);
+            return;
+        }
         
-        fprintf (logger_buffer->log_file,
-                 "%s\n", (message) ? message : logger_buf_write);
-        fflush (logger_buffer->log_file);
-        if (message)
-            free (message);
+        if (weechat_config_boolean (logger_config_file_info_lines))
+        {
+            seconds = time (NULL);
+            date_tmp = localtime (&seconds);
+            buf_time[0] = '\0';
+            if (date_tmp)
+                strftime (buf_time, sizeof (buf_time) - 1,
+                          weechat_config_string (logger_config_file_time_format),
+                          date_tmp);
+            snprintf (logger_buf_write, LOGGER_BUF_WRITE_SIZE,
+                      _("%s\t****  Beginning of log  ****"),
+                      buf_time);
+            message = (charset) ?
+                weechat_iconv_from_internal (charset, logger_buf_write) : NULL;
+            fprintf (logger_buffer->log_file,
+                     "%s\n", (message) ? message : logger_buf_write);
+            if (message)
+                free (message);
+        }
+    }
+    
+    va_start (argptr, format);
+    vsnprintf (logger_buf_write, LOGGER_BUF_WRITE_SIZE, format, argptr);
+    va_end (argptr);
+    
+    message = (charset) ?
+        weechat_iconv_from_internal (charset, logger_buf_write) : NULL;
+    
+    fprintf (logger_buffer->log_file,
+             "%s\n", (message) ? message : logger_buf_write);
+    fflush (logger_buffer->log_file);
+    if (message)
+        free (message);
+}
+
+/*
+ * logger_stop: stop 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))
+        {
+            seconds = time (NULL);
+            date_tmp = localtime (&seconds);
+            buf_time[0] = '\0';
+            if (date_tmp)
+                strftime (buf_time, sizeof (buf_time) - 1,
+                          weechat_config_string (logger_config_file_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_free (logger_buffer);
+}
+
+/*
+ * logger_stop_all: end log for all buffers
+ */
+
+void
+logger_stop_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)
+    {
+        logger_stop (ptr_logger_buffer, 1);
     }
 }
 
@@ -270,28 +522,43 @@ void
 logger_start_buffer (struct t_gui_buffer *buffer)
 {
     struct t_logger_buffer *ptr_logger_buffer;
-    char *log_filename;
+    int log_level, log_enabled;
     
-    if (!buffer || !weechat_config_boolean (logger_config_file_auto_log))
+    if (!buffer)
         return;
     
-    ptr_logger_buffer = logger_buffer_search (buffer);
-    if (!ptr_logger_buffer)
+    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)
     {
-        log_filename = logger_get_filename (buffer);
-        if (!log_filename)
-            return;
-        ptr_logger_buffer = logger_buffer_add (buffer, log_filename);
-        free (log_filename);
+        /* stop logger if it is active */
+        if (ptr_logger_buffer)
+            logger_stop (ptr_logger_buffer, 1);
     }
-    if (ptr_logger_buffer)
+    else
     {
-        if (ptr_logger_buffer->log_filename)
+        /* logging is enabled for buffer */
+        if (ptr_logger_buffer)
+            ptr_logger_buffer->log_level = log_level;
+        else
         {
-            if (ptr_logger_buffer->log_file)
+            ptr_logger_buffer = logger_buffer_add (buffer, log_level);
+            
+            if (ptr_logger_buffer)
             {
-                fclose (ptr_logger_buffer->log_file);
-                ptr_logger_buffer->log_file = NULL;
+                if (ptr_logger_buffer->log_filename)
+                {
+                    if (ptr_logger_buffer->log_file)
+                    {
+                        fclose (ptr_logger_buffer->log_file);
+                        ptr_logger_buffer->log_file = NULL;
+                    }
+                }
             }
         }
     }
@@ -319,54 +586,125 @@ logger_start_buffer_all ()
 }
 
 /*
- * logger_stop: stop log for a logger buffer
+ * logger_list: show logging status for buffers
  */
 
 void
-logger_stop (struct t_logger_buffer *logger_buffer, int write_info_line)
+logger_list ()
 {
-    time_t seconds;
-    struct tm *date_tmp;
-    char buf_time[256];
+    struct t_infolist *ptr_infolist;
+    struct t_logger_buffer *ptr_logger_buffer;
+    struct t_gui_buffer *ptr_buffer;
+    char status[128];
     
-    if (!logger_buffer)
-        return;
+    weechat_printf (NULL, "");
+    weechat_printf (NULL, _("Logging on buffers:"));
     
-    if (logger_buffer->log_file)
+    ptr_infolist = weechat_infolist_get ("buffer", NULL, NULL);
+    if (ptr_infolist)
     {
-        if (write_info_line && weechat_config_boolean (logger_config_file_info_lines))
+        while (weechat_infolist_next (ptr_infolist))
         {
-            seconds = time (NULL);
-            date_tmp = localtime (&seconds);
-            buf_time[0] = '\0';
-            if (date_tmp)
-                strftime (buf_time, sizeof (buf_time) - 1,
-                          weechat_config_string (logger_config_file_time_format),
-                          date_tmp);
-            logger_write_line (logger_buffer,
-                               _("%s\t****  End of log  ****"),
-                               buf_time);
+            ptr_buffer = weechat_infolist_pointer (ptr_infolist, "pointer");
+            if (ptr_buffer)
+            {
+                ptr_logger_buffer = logger_buffer_search_buffer (ptr_buffer);
+                if (ptr_logger_buffer)
+                {
+                    snprintf (status, sizeof (status),
+                              _("logging (level: %d)"),
+                              ptr_logger_buffer->log_level);
+                }
+                else
+                {
+                    snprintf (status, sizeof (status), _("not logging"));
+                }
+                weechat_printf (NULL,
+                                "  %s[%s%d%s]%s (%s) %s%s%s: %s%s%s%s",
+                                weechat_color("chat_delimiters"),
+                                weechat_color("chat"),
+                                weechat_infolist_integer (ptr_infolist, "number"),
+                                weechat_color("chat_delimiters"),
+                                weechat_color("chat"),
+                                weechat_infolist_string (ptr_infolist, "plugin_name"),
+                                weechat_color("chat_buffer"),
+                                weechat_infolist_string (ptr_infolist, "name"),
+                                weechat_color("chat"),
+                                status,
+                                (ptr_logger_buffer) ? " (" : "",
+                                (ptr_logger_buffer) ?
+                                ((ptr_logger_buffer->log_filename) ?
+                                 ptr_logger_buffer->log_filename : _("log not started")) : "",
+                                (ptr_logger_buffer) ? ")" : "");
+            }
         }
-        fclose (logger_buffer->log_file);
-        logger_buffer->log_file = NULL;
+        weechat_infolist_free (ptr_infolist);
     }
-    logger_buffer_free (logger_buffer);
 }
 
 /*
- * logger_stop_all: end log for all buffers
+ * logger_set_buffer: enable/disable log on a buffer
  */
 
 void
-logger_stop_all ()
+logger_set_buffer (struct t_gui_buffer *buffer, const char *value)
 {
-    struct t_logger_buffer *ptr_logger_buffer;
+    char *name;
+    struct t_config_option *ptr_option;
     
-    for (ptr_logger_buffer = logger_buffers; ptr_logger_buffer;
-         ptr_logger_buffer = ptr_logger_buffer->next_buffer)
+    name = logger_build_option_name (buffer);
+    if (!name)
+        return;
+    
+    if (logger_config_set_level (name, value) != WEECHAT_CONFIG_OPTION_SET_ERROR)
     {
-        logger_stop (ptr_logger_buffer, 1);
+        ptr_option = logger_config_get_level (name);
+        if (ptr_option)
+        {
+            weechat_printf (NULL, _("%s: \"%s\" => level %d"),
+                            LOGGER_PLUGIN_NAME, name,
+                            weechat_config_integer (ptr_option));
+        }
+    }
+    
+    free (name);
+}
+
+/*
+ * logger_command_cb: callback for /logger command
+ */
+
+int
+logger_command_cb (void *data, struct t_gui_buffer *buffer,
+                   int argc, char **argv, char **argv_eol)
+{
+    /* make C compiler happy */
+    (void) data;
+    (void) argv_eol;
+    
+    if ((argc == 1)
+        || ((argc == 2) && (weechat_strcasecmp (argv[1], "list") == 0)))
+    {
+        logger_list ();
+        return WEECHAT_RC_OK;
     }
+    
+    if (argc > 1)
+    {
+        if (weechat_strcasecmp (argv[1], "set") == 0)
+        {
+            if (argc > 2)
+                logger_set_buffer (buffer, argv[2]);
+            return WEECHAT_RC_OK;
+        }
+        
+        if (weechat_strcasecmp (argv[1], "disable") == 0)
+        {
+            logger_set_buffer (buffer, "0");
+        }
+    }
+    
+    return WEECHAT_RC_OK;
 }
 
 /*
@@ -400,7 +738,7 @@ logger_buffer_closing_signal_cb (void *data, const char *signal,
     (void) signal;
     (void) type_data;
     
-    logger_stop (logger_buffer_search (signal_data), 1);
+    logger_stop (logger_buffer_search_buffer (signal_data), 1);
     
     return WEECHAT_RC_OK;
 }
@@ -452,9 +790,12 @@ logger_backlog (struct t_gui_buffer *buffer, const char *filename, int lines)
     if (last_lines)
         logger_tail_free (last_lines);
     if (num_lines > 0)
+    {
         weechat_printf (buffer,
                         _("===\t========== End of backlog (%d lines) =========="),
                         num_lines);
+        weechat_buffer_set (buffer, "unread", "");
+    }
 }
 
 /*
@@ -474,17 +815,22 @@ logger_backlog_signal_cb (void *data, const char *signal,
 
     if (weechat_config_integer (logger_config_look_backlog) >= 0)
     {
-        ptr_logger_buffer = logger_buffer_search (signal_data);
-        if (ptr_logger_buffer && ptr_logger_buffer->log_filename
-            && ptr_logger_buffer->log_enabled)
+        ptr_logger_buffer = logger_buffer_search_buffer (signal_data);
+        if (ptr_logger_buffer && ptr_logger_buffer->log_enabled)
         {
-            ptr_logger_buffer->log_enabled = 0;
+            if (!ptr_logger_buffer->log_filename)
+                logger_set_log_filename (ptr_logger_buffer);
             
-            logger_backlog (signal_data,
-                            ptr_logger_buffer->log_filename,
-                            weechat_config_integer (logger_config_look_backlog));
-            
-            ptr_logger_buffer->log_enabled = 1;
+            if (ptr_logger_buffer->log_filename)
+            {
+                ptr_logger_buffer->log_enabled = 0;
+                
+                logger_backlog (signal_data,
+                                ptr_logger_buffer->log_filename,
+                                weechat_config_integer (logger_config_look_backlog));
+                
+                ptr_logger_buffer->log_enabled = 1;
+            }
         }
     }
     
@@ -524,7 +870,7 @@ logger_stop_signal_cb (void *data, const char *signal, const char *type_data,
     (void) signal;
     (void) type_data;
     
-    ptr_logger_buffer = logger_buffer_search (signal_data);
+    ptr_logger_buffer = logger_buffer_search_buffer (signal_data);
     if (ptr_logger_buffer)
         logger_stop (ptr_logger_buffer, 0);
     
@@ -532,27 +878,52 @@ logger_stop_signal_cb (void *data, const char *signal, const char *type_data,
 }
 
 /*
+ * logger_line_log_level: get log level for a line (with its tags)
+ */
+
+int
+logger_line_log_level (int tags_count, const char **tags)
+{
+    int i;
+    
+    for (i = 0; i < tags_count; i++)
+    {
+        if (strncmp (tags[i], "log", 3) == 0)
+        {
+            if (isdigit (tags[i][3]))
+            {
+                return (tags[i][3] - '0');
+            }
+        }
+    }
+    
+    return 9;
+}
+
+/*
  * logger_print_cb: callback for print hook
  */
 
 int
 logger_print_cb (void *data, struct t_gui_buffer *buffer, time_t date,
-                 int tags_count, char **tags,
+                 int tags_count, const char **tags,
                  const char *prefix, const char *message)
 {
     struct t_logger_buffer *ptr_logger_buffer;
     struct tm *date_tmp;
     char buf_time[256];
+    int line_log_level;
     
     /* make C compiler happy */
     (void) data;
-    (void) tags_count;
-    (void) tags;
     
-    ptr_logger_buffer = logger_buffer_search (buffer);
-    if (ptr_logger_buffer && ptr_logger_buffer->log_filename
+    line_log_level = logger_line_log_level (tags_count, tags);
+    
+    ptr_logger_buffer = logger_buffer_search_buffer (buffer);
+    if (ptr_logger_buffer
         && ptr_logger_buffer->log_enabled
-        && (date > 0))
+        && (date > 0)
+        && (line_log_level <= ptr_logger_buffer->log_level))
     {
         date_tmp = localtime (&date);
         buf_time[0] = '\0';
@@ -592,6 +963,43 @@ weechat_plugin_init (struct t_weechat_plugin *plugin, int argc, char *argv[])
     if (logger_config_read () < 0)
         return WEECHAT_RC_ERROR;
     
+    /* callback for debug */
+    weechat_hook_signal ("debug", &logger_debug_cb, NULL);
+    
+    /* command /logger */
+    weechat_hook_command ("logger",
+                          N_("logger plugin configuration"),
+                          N_("[list | set level | disable]"),
+                          N_("   list: show logging status for open buffers\n"
+                             "    set: set logging level on current buffer\n"
+                             "  level: level for messages to be logged (0 = "
+                             "logging disabled, 1 = a few messages (most "
+                             "important) .. 9 = all messages)\n"
+                             "disable: disable logging on current buffer (set "
+                             "level to 0)\n\n"
+                             "Options \"logger.level.*\" and \"logger.mask.*\" "
+                             "can be used to set level or mask for a buffer, "
+                             "or buffers beginning with name.\n\n"
+                             "Examples:\n"
+                             "  set level to 5 for current buffer:\n"
+                             "    /logger set 5\n"
+                             "  disable logging for current buffer:\n"
+                             "    /logger disable\n\n"
+                             "  set level to 3 for all IRC buffers:\n"
+                             "    /set logger.level.irc = 3\n"
+                             "  disable logging for main WeeChat buffer:\n"
+                             "    /set logger.level.core.weechat = 0\n"
+                             "  use a directory per IRC server and a file per channel inside:\n"
+                             "    /set logger.mask.irc = $server/$channel.weechatlog\n\n"
+                             "Log levels used by IRC plugin:\n"
+                             "  1: user message, notice, private\n"
+                             "  2: nick change\n"
+                             "  3: server message\n"
+                             "  4: join/part/quit\n"
+                             "  9: all other messages"),
+                          "list|set|disable",
+                          &logger_command_cb, NULL);
+    
     logger_start_buffer_all ();
     
     weechat_hook_signal ("buffer_open", &logger_buffer_open_signal_cb, NULL);