apps/irssi/src/fe-common/core/fe-log.c

   1 /*
   2  fe-log.c : irssi
   3
   4     Copyright (C) 1999-2000 Timo Sirainen
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #include "module.h"
  22 #include "module-formats.h"
  23 #include "signals.h"
  24 #include "commands.h"
  25 #include "chat-protocols.h"
  26 #include "servers.h"
  27 #include "levels.h"
  28 #include "misc.h"
  29 #include "log.h"
  30 #include "special-vars.h"
  31 #include "settings.h"
  32 #include "lib-config/iconfig.h"
  33
  34 #include "fe-windows.h"
  35 #include "window-items.h"
  36 #include "formats.h"
  37 #include "themes.h"
  38 #include "printtext.h"
  39
  40 /* close autologs after 5 minutes of inactivity */
  41 #define AUTOLOG_INACTIVITY_CLOSE (60*5)
  42
  43 static int autolog_level;
  44 static int autoremove_tag;
  45 static const char *autolog_path;
  46
  47 static THEME_REC *log_theme;
  48 static int skip_next_printtext;
  49 static const char *log_theme_name;
  50
  51 static int log_dir_create_mode;
  52
  53 static char *log_colorizer_strip(const char *str)
  54 {
  55         return strip_codes(str);
  56 }
  57
  58 static void log_add_targets(LOG_REC *log, const char *targets, const char *tag)
  59 {
  60         char **tmp, **items;
  61
  62         g_return_if_fail(log != NULL);
  63         g_return_if_fail(targets != NULL);
  64
  65         items = g_strsplit(targets, " ", -1);
  66
  67         for (tmp = items; *tmp != NULL; tmp++)
  68                 log_item_add(log, LOG_ITEM_TARGET, *tmp, tag);
  69
  70         g_strfreev(items);
  71 }
  72
  73 /* SYNTAX: LOG OPEN [-noopen] [-autoopen] [-window] [-<server tag>]
  74                     [-targets <targets>] [-colors]
  75                     <fname> [<levels>] */
  76 static void cmd_log_open(const char *data)
  77 {
  78         SERVER_REC *server;
  79         GHashTable *optlist;
  80         char *targetarg, *fname, *levels, *servertag;
  81         void *free_arg;
  82         char window[MAX_INT_STRLEN];
  83         LOG_REC *log;
  84         int level;
  85
  86         if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST |
  87                             PARAM_FLAG_UNKNOWN_OPTIONS | PARAM_FLAG_OPTIONS,
  88                             "log open", &optlist, &fname, &levels))
  89                 return;
  90         if (*fname == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
  91
  92         level = level2bits(levels);
  93         log = log_create_rec(fname, level != 0 ? level : MSGLEVEL_ALL);
  94
  95         /* -<server tag> */
  96         server = cmd_options_get_server("log open", optlist, NULL);
  97         servertag = server == NULL ? NULL : server->tag;
  98
  99         if (g_hash_table_lookup(optlist, "window")) {
 100                 /* log by window ref# */
 101                 targetarg = g_hash_table_lookup(optlist, "targets");
 102                 if (targetarg == NULL || !is_numeric(targetarg, '\0')) {
 103                         ltoa(window, active_win->refnum);
 104                         targetarg = window;
 105                 }
 106                 log_item_add(log, LOG_ITEM_WINDOW_REFNUM, targetarg,
 107                              servertag);
 108         } else {
 109                 targetarg = g_hash_table_lookup(optlist, "targets");
 110                 if (targetarg != NULL && *targetarg != '\0')
 111                         log_add_targets(log, targetarg, servertag);
 112                 else if (servertag != NULL)
 113                         log_add_targets(log, "*", servertag);
 114         }
 115
 116         if (g_hash_table_lookup(optlist, "autoopen"))
 117                 log->autoopen = TRUE;
 118
 119         if (g_hash_table_lookup(optlist, "colors") == NULL)
 120                 log->colorizer = log_colorizer_strip;
 121
 122         log_update(log);
 123
 124         if (log->handle == -1 && g_hash_table_lookup(optlist, "noopen") == NULL) {
 125                 /* start logging */
 126                 if (log_start_logging(log)) {
 127                         printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE,
 128                                     TXT_LOG_OPENED, fname);
 129                 } else {
 130                         log_close(log);
 131                 }
 132         }
 133
 134         cmd_params_free(free_arg);
 135 }
 136
 137 static LOG_REC *log_find_from_data(const char *data)
 138 {
 139         GSList *tmp;
 140
 141         if (!is_numeric(data, ' '))
 142                 return log_find(data);
 143
 144         /* with index number */
 145         tmp = g_slist_nth(logs, atoi(data)-1);
 146         return tmp == NULL ? NULL : tmp->data;
 147 }
 148
 149 /* SYNTAX: LOG CLOSE <id>|<file> */
 150 static void cmd_log_close(const char *data)
 151 {
 152         LOG_REC *log;
 153
 154         log = log_find_from_data(data);
 155         if (log == NULL)
 156                 printformat(NULL, NULL, MSGLEVEL_CLIENTERROR, TXT_LOG_NOT_OPEN, data);
 157         else {
 158                 log_close(log);
 159                 printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_LOG_CLOSED, data);
 160         }
 161 }
 162
 163 /* SYNTAX: LOG START <id>|<file> */
 164 static void cmd_log_start(const char *data)
 165 {
 166         LOG_REC *log;
 167
 168         log = log_find_from_data(data);
 169         if (log != NULL) {
 170                 log_start_logging(log);
 171                 printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_LOG_OPENED, data);
 172         }
 173 }
 174
 175 /* SYNTAX: LOG STOP <id>|<file> */
 176 static void cmd_log_stop(const char *data)
 177 {
 178         LOG_REC *log;
 179
 180         log = log_find_from_data(data);
 181         if (log == NULL || log->handle == -1)
 182                 printformat(NULL, NULL, MSGLEVEL_CLIENTERROR, TXT_LOG_NOT_OPEN, data);
 183         else {
 184                 log_stop_logging(log);
 185                 printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_LOG_CLOSED, data);
 186         }
 187 }
 188
 189 static char *log_items_get_list(LOG_REC *log)
 190 {
 191         GSList *tmp;
 192         GString *str;
 193         char *ret;
 194         LOG_ITEM_REC *rec = NULL;
 195
 196         g_return_val_if_fail(log != NULL, NULL);
 197         g_return_val_if_fail(log->items != NULL, NULL);
 198
 199         str = g_string_new(NULL);
 200         for (tmp = log->items; tmp != NULL; tmp = tmp->next) {
 201                 rec = tmp->data;
 202
 203                 g_string_sprintfa(str, "%s, ", rec->name);
 204         }
 205         g_string_truncate(str, str->len-2);
 206         if(rec->servertag != NULL)
 207                 g_string_sprintfa(str, " (%s)", rec->servertag);
 208
 209         ret = str->str;
 210         g_string_free(str, FALSE);
 211         return ret;
 212 }
 213
 214 static void cmd_log_list(void)
 215 {
 216         GSList *tmp;
 217         char *levelstr, *items;
 218         int index;
 219
 220         printformat(NULL, NULL, MSGLEVEL_CLIENTCRAP, TXT_LOG_LIST_HEADER);
 221         for (tmp = logs, index = 1; tmp != NULL; tmp = tmp->next, index++) {
 222                 LOG_REC *rec = tmp->data;
 223
 224                 levelstr = bits2level(rec->level);
 225                 items = rec->items == NULL ? NULL :
 226                         log_items_get_list(rec);
 227
 228                 printformat(NULL, NULL, MSGLEVEL_CLIENTCRAP, TXT_LOG_LIST,
 229                             index, rec->fname, items != NULL ? items : "",
 230                             levelstr, rec->autoopen ? " -autoopen" : "");
 231
 232                 g_free_not_null(items);
 233                 g_free(levelstr);
 234         }
 235         printformat(NULL, NULL, MSGLEVEL_CLIENTCRAP, TXT_LOG_LIST_FOOTER);
 236 }
 237
 238 static void cmd_log(const char *data, SERVER_REC *server, void *item)
 239 {
 240         if (*data == '\0')
 241                 cmd_log_list();
 242         else
 243                 command_runsub("log", data, server, item);
 244 }
 245
 246 static LOG_REC *logs_find_item(int type, const char *item,
 247                                const char *servertag, LOG_ITEM_REC **ret_item)
 248 {
 249         LOG_ITEM_REC *logitem;
 250         GSList *tmp;
 251
 252         for (tmp = logs; tmp != NULL; tmp = tmp->next) {
 253                 LOG_REC *log = tmp->data;
 254
 255                 logitem = log_item_find(log, type, item, servertag);
 256                 if (logitem != NULL) {
 257                         if (ret_item != NULL) *ret_item = logitem;
 258                         return log;
 259                 }
 260         }
 261
 262         return NULL;
 263 }
 264
 265 /* SYNTAX: WINDOW LOG on|off|toggle [<filename>] */
 266 static void cmd_window_log(const char *data)
 267 {
 268         LOG_REC *log;
 269         char *set, *fname, window[MAX_INT_STRLEN];
 270         void *free_arg;
 271         int open_log, close_log;
 272
 273         if (!cmd_get_params(data, &free_arg, 2, &set, &fname))
 274                 return;
 275
 276         ltoa(window, active_win->refnum);
 277         log = logs_find_item(LOG_ITEM_WINDOW_REFNUM, window, NULL, NULL);
 278
 279         open_log = close_log = FALSE;
 280         if (g_strcasecmp(set, "ON") == 0)
 281                 open_log = TRUE;
 282         else if (g_strcasecmp(set, "OFF") == 0) {
 283                 close_log = TRUE;
 284         } else if (g_strcasecmp(set, "TOGGLE") == 0) {
 285                 open_log = log == NULL;
 286                 close_log = log != NULL;
 287         } else {
 288                 printformat(NULL, NULL, MSGLEVEL_CLIENTERROR, TXT_NOT_TOGGLE);
 289                 cmd_params_free(free_arg);
 290                 return;
 291         }
 292
 293         if (open_log && log == NULL) {
 294                 /* irc.log.<windowname> or irc.log.Window<ref#> */
 295                 fname = *fname != '\0' ? g_strdup(fname) :
 296                         g_strdup_printf("~/irc.log.%s%s",
 297                                         active_win->name != NULL ? active_win->name : "Window",
 298                                         active_win->name != NULL ? "" : window);
 299                 log = log_create_rec(fname, MSGLEVEL_ALL);
 300                 log->colorizer = log_colorizer_strip;
 301                 log_item_add(log, LOG_ITEM_WINDOW_REFNUM, window, NULL);
 302                 log_update(log);
 303                 g_free(fname);
 304         }
 305
 306         if (open_log && log != NULL) {
 307                 log_start_logging(log);
 308                 printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_LOG_OPENED, log->fname);
 309         } else if (close_log && log != NULL && log->handle != -1) {
 310                 log_stop_logging(log);
 311                 printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_LOG_CLOSED, log->fname);
 312         }
 313
 314         cmd_params_free(free_arg);
 315 }
 316
 317 /* Create log file entry to window, but don't start logging */
 318 /* SYNTAX: WINDOW LOGFILE <file> */
 319 static void cmd_window_logfile(const char *data)
 320 {
 321         LOG_REC *log;
 322         char window[MAX_INT_STRLEN];
 323
 324         ltoa(window, active_win->refnum);
 325         log = logs_find_item(LOG_ITEM_WINDOW_REFNUM, window, NULL, NULL);
 326
 327         if (log != NULL) {
 328                 printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_WINDOWLOG_FILE_LOGGING);
 329                 return;
 330         }
 331
 332         log = log_create_rec(data, MSGLEVEL_ALL);
 333         log->colorizer = log_colorizer_strip;
 334         log_item_add(log, LOG_ITEM_WINDOW_REFNUM, window, NULL);
 335         log_update(log);
 336
 337         printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_WINDOWLOG_FILE, data);
 338 }
 339
 340 /* window's refnum changed - update the logs to log the new window refnum */
 341 static void sig_window_refnum_changed(WINDOW_REC *window, gpointer old_refnum)
 342 {
 343         char winnum[MAX_INT_STRLEN];
 344         LOG_REC *log;
 345         LOG_ITEM_REC *item;
 346
 347         ltoa(winnum, GPOINTER_TO_INT(old_refnum));
 348         log = logs_find_item(LOG_ITEM_WINDOW_REFNUM, winnum, NULL, &item);
 349
 350         if (log != NULL) {
 351                 ltoa(winnum, window->refnum);
 352
 353                 g_free(item->name);
 354                 item->name = g_strdup(winnum);
 355         }
 356 }
 357
 358 static void sig_server_disconnected(SERVER_REC *server)
 359 {
 360         LOG_ITEM_REC *logitem;
 361         GSList *tmp, *next;
 362
 363         for (tmp = logs; tmp != NULL; tmp = next) {
 364                 LOG_REC *log = tmp->data;
 365                 next = tmp->next;
 366
 367                 if (!log->temp || log->items == NULL)
 368                         continue;
 369
 370                 logitem = log->items->data;
 371                 if (logitem->type == LOG_ITEM_TARGET &&
 372                     logitem->servertag != NULL &&
 373                     g_strcasecmp(logitem->servertag, server->tag) == 0 &&
 374                     server_ischannel(server, logitem->name)) /* kludge again.. so we won't close dcc chats */
 375                         log_close(log);
 376         }
 377 }
 378
 379 static void autologs_close_all(void)
 380 {
 381         GSList *tmp, *next;
 382
 383         for (tmp = logs; tmp != NULL; tmp = next) {
 384                 LOG_REC *rec = tmp->data;
 385
 386                 next = tmp->next;
 387                 if (rec->temp) log_close(rec);
 388         }
 389 }
 390
 391 /* '%' -> '%%', '/' -> '_' */
 392 static char *escape_target(const char *target)
 393 {
 394         char *str, *p;
 395
 396         p = str = g_malloc(strlen(target)*2+1);
 397         while (*target != '\0') {
 398                 if (*target == '/')
 399                         *p++ = '_';
 400                 else {
 401                         if (*target == '%')
 402                                 *p++ = '%';
 403                         *p++ = *target;
 404                 }
 405
 406                 target++;
 407         }
 408         *p = '\0';
 409
 410         return str;
 411 }
 412
 413 static void autolog_open(SERVER_REC *server, const char *server_tag,
 414                          const char *target)
 415 {
 416         LOG_REC *log;
 417         char *fname, *dir, *fixed_target, *params;
 418
 419         log = logs_find_item(LOG_ITEM_TARGET, target, server_tag, NULL);
 420         if (log != NULL && !log->failed) {
 421                 log_start_logging(log);
 422                 return;
 423         }
 424
 425         /* '/' -> '_' - don't even accidentally try to log to
 426            #../../../file if you happen to join to such channel..
 427
 428            '%' -> '%%' - so strftime() won't mess with them */
 429         fixed_target = escape_target(target);
 430         if (CHAT_PROTOCOL(server)->case_insensitive)
 431                 g_strdown(fixed_target);
 432
 433         /* $0 = target, $1 = server tag */
 434         params = g_strconcat(fixed_target, " ", server_tag, NULL);
 435         g_free(fixed_target);
 436
 437         fname = parse_special_string(autolog_path, server, NULL,
 438                                      params, NULL, 0);
 439         g_free(params);
 440
 441         if (log_find(fname) == NULL) {
 442                 log = log_create_rec(fname, autolog_level);
 443                 if (!settings_get_bool("autolog_colors"))
 444                         log->colorizer = log_colorizer_strip;
 445                 log_item_add(log, LOG_ITEM_TARGET, target, server_tag);
 446
 447                 dir = g_dirname(log->real_fname);
 448                 mkpath(dir, log_dir_create_mode);
 449                 g_free(dir);
 450
 451                 log->temp = TRUE;
 452                 log_update(log);
 453                 log_start_logging(log);
 454         }
 455         g_free(fname);
 456 }
 457
 458 static void autolog_open_check(SERVER_REC *server, const char *server_tag,
 459                                const char *target, int level)
 460 {
 461         char **targets, **tmp;
 462
 463         /* FIXME: kind of a kludge, but we don't want to reopen logs when
 464            we're parting the channel with /WINDOW CLOSE.. Maybe a small
 465            timeout would be nice instead of immediately closing the log file
 466            after "window item destroyed" */
 467         if (level == MSGLEVEL_PARTS ||
 468             (autolog_level & level) == 0 || target == NULL || *target == '\0')
 469                 return;
 470
 471         /* there can be multiple targets separated with comma */
 472         targets = g_strsplit(target, ",", -1);
 473         for (tmp = targets; *tmp != NULL; tmp++)
 474                 autolog_open(server, server_tag, *tmp);
 475         g_strfreev(targets);
 476 }
 477
 478 static void log_single_line(WINDOW_REC *window, const char *server_tag,
 479                             const char *target, int level, const char *text)
 480 {
 481         char windownum[MAX_INT_STRLEN];
 482         char **targets, **tmp;
 483         LOG_REC *log;
 484
 485         if (window != NULL) {
 486                 /* save to log created with /WINDOW LOG */
 487                 ltoa(windownum, window->refnum);
 488                 log = logs_find_item(LOG_ITEM_WINDOW_REFNUM,
 489                                      windownum, NULL, NULL);
 490                 if (log != NULL)
 491                         log_write_rec(log, text, level);
 492         }
 493
 494         if (target == NULL)
 495                 log_file_write(server_tag, NULL, level, text, FALSE);
 496         else {
 497                 /* there can be multiple items separated with comma */
 498                 targets = g_strsplit(target, ",", -1);
 499                 for (tmp = targets; *tmp != NULL; tmp++)
 500                         log_file_write(server_tag, *tmp, level, text, FALSE);
 501                 g_strfreev(targets);
 502         }
 503 }
 504
 505 static void log_line(TEXT_DEST_REC *dest, const char *text)
 506 {
 507         char **lines, **tmp;
 508
 509         if (dest->level == MSGLEVEL_NEVER)
 510                 return;
 511
 512         /* let autolog open the log records */
 513         autolog_open_check(dest->server, dest->server_tag,
 514                            dest->target, dest->level);
 515
 516         if (logs == NULL)
 517                 return;
 518
 519         /* text may contain one or more lines, log wants to eat them one
 520            line at a time */
 521         lines = g_strsplit(text, "\n", -1);
 522         for (tmp = lines; *tmp != NULL; tmp++)
 523                 log_single_line(dest->window, dest->server_tag,
 524                                 dest->target, dest->level, *tmp);
 525         g_strfreev(lines);
 526 }
 527
 528 static void sig_printtext(TEXT_DEST_REC *dest, const char *text,
 529                           const char *stripped)
 530 {
 531         if (skip_next_printtext) {
 532                 skip_next_printtext = FALSE;
 533                 return;
 534         }
 535
 536         log_line(dest, text);
 537 }
 538
 539 static void sig_print_format(THEME_REC *theme, const char *module,
 540                              TEXT_DEST_REC *dest, void *formatnum, char **args)
 541 {
 542         char *str, *linestart, *tmp;
 543
 544         if (log_theme == NULL) {
 545                 /* theme isn't loaded for some reason (/reload destroys it),
 546                    reload it. */
 547                 log_theme = theme_load(log_theme_name);
 548                 if (log_theme == NULL) return;
 549         }
 550
 551         if (theme == log_theme)
 552                 return;
 553
 554         str = format_get_text_theme_charargs(log_theme, module, dest,
 555                                              GPOINTER_TO_INT(formatnum), args);
 556         skip_next_printtext = TRUE;
 557
 558         if (*str != '\0') {
 559                 /* add the line start format */
 560                 linestart = format_get_level_tag(log_theme, dest);
 561                 tmp = str;
 562                 str = format_add_linestart(tmp, linestart);
 563                 g_free_not_null(linestart);
 564                 g_free(tmp);
 565
 566                 /* strip colors from text, log it. */
 567                 log_line(dest, str);
 568         }
 569         g_free(str);
 570
 571 }
 572
 573 static int sig_autoremove(void)
 574 {
 575         SERVER_REC *server;
 576         LOG_ITEM_REC *logitem;
 577         GSList *tmp, *next;
 578         time_t removetime;
 579
 580         removetime = time(NULL)-AUTOLOG_INACTIVITY_CLOSE;
 581         for (tmp = logs; tmp != NULL; tmp = next) {
 582                 LOG_REC *log = tmp->data;
 583
 584                 next = tmp->next;
 585
 586                 if (!log->temp || log->last > removetime || log->items == NULL)
 587                         continue;
 588
 589                 /* Close only logs with private messages */
 590                 logitem = log->items->data;
 591                 if (logitem->servertag == NULL)
 592                         continue;
 593
 594                 server = server_find_tag(logitem->servertag);
 595                 if (logitem->type == LOG_ITEM_TARGET &&
 596                     server != NULL && !server_ischannel(server, logitem->name))
 597                         log_close(log);
 598         }
 599         return 1;
 600 }
 601
 602 static void sig_window_item_remove(WINDOW_REC *window, WI_ITEM_REC *item)
 603 {
 604         LOG_REC *log;
 605
 606         log = logs_find_item(LOG_ITEM_TARGET, item->visible_name,
 607                              item->server == NULL ? NULL :
 608                              item->server->tag, NULL);
 609         if (log != NULL && log->temp)
 610                 log_close(log);
 611 }
 612
 613 static void sig_log_locked(LOG_REC *log)
 614 {
 615         printformat(NULL, NULL, MSGLEVEL_CLIENTERROR,
 616                     TXT_LOG_LOCKED, log->fname);
 617 }
 618
 619 static void sig_log_create_failed(LOG_REC *log)
 620 {
 621         printformat(NULL, NULL, MSGLEVEL_CLIENTERROR,
 622                     TXT_LOG_CREATE_FAILED,
 623                     log->real_fname, g_strerror(errno));
 624 }
 625
 626 static void sig_log_new(LOG_REC *log)
 627 {
 628         if (!settings_get_bool("awaylog_colors") &&
 629             strcmp(log->fname, settings_get_str("awaylog_file")) == 0)
 630                 log->colorizer = log_colorizer_strip;
 631 }
 632
 633 static void sig_log_config_read(LOG_REC *log, CONFIG_NODE *node)
 634 {
 635         if (!config_node_get_bool(node, "colors", FALSE))
 636                 log->colorizer = log_colorizer_strip;
 637 }
 638
 639 static void sig_log_config_save(LOG_REC *log, CONFIG_NODE *node)
 640 {
 641         if (log->colorizer == NULL)
 642                 iconfig_node_set_bool(node, "colors", TRUE);
 643         else
 644                 iconfig_node_set_str(node, "colors", NULL);
 645 }
 646
 647 static void sig_awaylog_show(LOG_REC *log, gpointer pmsgs, gpointer pfilepos)
 648 {
 649         char *str;
 650         int msgs, filepos;
 651
 652         msgs = GPOINTER_TO_INT(pmsgs);
 653         filepos = GPOINTER_TO_INT(pfilepos);
 654
 655         if (msgs == 0)
 656                 printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_LOG_NO_AWAY_MSGS, log->fname);
 657         else {
 658                 printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_LOG_AWAY_MSGS, log->fname, msgs);
 659
 660                 str = g_strdup_printf("\"%s\" %d", log->fname, filepos);
 661                 signal_emit("command cat", 1, str);
 662                 g_free(str);
 663         }
 664 }
 665
 666 static void sig_theme_destroyed(THEME_REC *theme)
 667 {
 668         if (theme == log_theme)
 669                 log_theme = NULL;
 670 }
 671
 672 static void read_settings(void)
 673 {
 674         int old_autolog = autolog_level;
 675         int log_file_create_mode;
 676
 677         autolog_path = settings_get_str("autolog_path");
 678         autolog_level = !settings_get_bool("autolog") ? 0 :
 679                 settings_get_level("autolog_level");
 680
 681         if (old_autolog && !autolog_level)
 682                 autologs_close_all();
 683
 684         /* write to log files with different theme? */
 685         if (log_theme_name != NULL)
 686                 signal_remove("print format", (SIGNAL_FUNC) sig_print_format);
 687         log_theme_name = settings_get_str("log_theme");
 688         if (*log_theme_name == '\0')
 689                 log_theme_name = NULL;
 690         else
 691                 signal_add("print format", (SIGNAL_FUNC) sig_print_format);
 692
 693         log_theme = log_theme_name == NULL ? NULL :
 694                 theme_load(log_theme_name);
 695
 696         log_file_create_mode = octal2dec(settings_get_int("log_create_mode"));
 697         log_dir_create_mode = log_file_create_mode;
 698         if (log_file_create_mode & 0400) log_dir_create_mode |= 0100;
 699         if (log_file_create_mode & 0040) log_dir_create_mode |= 0010;
 700         if (log_file_create_mode & 0004) log_dir_create_mode |= 0001;
 701 }
 702
 703 void fe_log_init(void)
 704 {
 705         autoremove_tag = g_timeout_add(60000, (GSourceFunc) sig_autoremove, NULL);
 706         skip_next_printtext = FALSE;
 707
 708         settings_add_bool("log", "awaylog_colors", TRUE);
 709         settings_add_bool("log", "autolog", FALSE);
 710         settings_add_bool("log", "autolog_colors", FALSE);
 711         settings_add_str("log", "autolog_path", "~/irclogs/$tag/$0.log");
 712         settings_add_level("log", "autolog_level", "all -crap -clientcrap -ctcps");
 713         settings_add_str("log", "log_theme", "");
 714
 715         autolog_level = 0;
 716         log_theme_name = NULL;
 717         read_settings();
 718
 719         command_bind("log", NULL, (SIGNAL_FUNC) cmd_log);
 720         command_bind("log open", NULL, (SIGNAL_FUNC) cmd_log_open);
 721         command_bind("log close", NULL, (SIGNAL_FUNC) cmd_log_close);
 722         command_bind("log start", NULL, (SIGNAL_FUNC) cmd_log_start);
 723         command_bind("log stop", NULL, (SIGNAL_FUNC) cmd_log_stop);
 724         command_bind("window log", NULL, (SIGNAL_FUNC) cmd_window_log);
 725         command_bind("window logfile", NULL, (SIGNAL_FUNC) cmd_window_logfile);
 726         signal_add_first("print text", (SIGNAL_FUNC) sig_printtext);
 727         signal_add("window item remove", (SIGNAL_FUNC) sig_window_item_remove);
 728         signal_add("window refnum changed", (SIGNAL_FUNC) sig_window_refnum_changed);
 729         signal_add("server disconnected", (SIGNAL_FUNC) sig_server_disconnected);
 730         signal_add("log locked", (SIGNAL_FUNC) sig_log_locked);
 731         signal_add("log create failed", (SIGNAL_FUNC) sig_log_create_failed);
 732         signal_add("log new", (SIGNAL_FUNC) sig_log_new);
 733         signal_add("log config read", (SIGNAL_FUNC) sig_log_config_read);
 734         signal_add("log config save", (SIGNAL_FUNC) sig_log_config_save);
 735         signal_add("awaylog show", (SIGNAL_FUNC) sig_awaylog_show);
 736         signal_add("theme destroyed", (SIGNAL_FUNC) sig_theme_destroyed);
 737         signal_add("setup changed", (SIGNAL_FUNC) read_settings);
 738
 739         command_set_options("log open", "noopen autoopen -targets window colors");
 740 }
 741
 742 void fe_log_deinit(void)
 743 {
 744         g_source_remove(autoremove_tag);
 745         if (log_theme_name != NULL)
 746                 signal_remove("print format", (SIGNAL_FUNC) sig_print_format);
 747
 748         command_unbind("log", (SIGNAL_FUNC) cmd_log);
 749         command_unbind("log open", (SIGNAL_FUNC) cmd_log_open);
 750         command_unbind("log close", (SIGNAL_FUNC) cmd_log_close);
 751         command_unbind("log start", (SIGNAL_FUNC) cmd_log_start);
 752         command_unbind("log stop", (SIGNAL_FUNC) cmd_log_stop);
 753         command_unbind("window log", (SIGNAL_FUNC) cmd_window_log);
 754         command_unbind("window logfile", (SIGNAL_FUNC) cmd_window_logfile);
 755         signal_remove("print text", (SIGNAL_FUNC) sig_printtext);
 756         signal_remove("window item remove", (SIGNAL_FUNC) sig_window_item_remove);
 757         signal_remove("window refnum changed", (SIGNAL_FUNC) sig_window_refnum_changed);
 758         signal_remove("server disconnected", (SIGNAL_FUNC) sig_server_disconnected);
 759         signal_remove("log locked", (SIGNAL_FUNC) sig_log_locked);
 760         signal_remove("log create failed", (SIGNAL_FUNC) sig_log_create_failed);
 761         signal_remove("log new", (SIGNAL_FUNC) sig_log_new);
 762         signal_remove("log config read", (SIGNAL_FUNC) sig_log_config_read);
 763         signal_remove("log config save", (SIGNAL_FUNC) sig_log_config_save);
 764         signal_remove("awaylog show", (SIGNAL_FUNC) sig_awaylog_show);
 765         signal_remove("theme destroyed", (SIGNAL_FUNC) sig_theme_destroyed);
 766         signal_remove("setup changed", (SIGNAL_FUNC) read_settings);
 767 }