src/common/log.c

   1 /*
   2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2021 the Claws Mail team and Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #include "claws-features.h"
  23 #endif
  24
  25 #include "defs.h"
  26
  27 #ifdef G_OS_WIN32
  28 #  include <w32lib.h>
  29 #endif
  30
  31 #include <glib.h>
  32 #include <glib/gi18n.h>
  33
  34 #include "utils.h"
  35 #include "log.h"
  36 #include "hooks.h"
  37 #include "file-utils.h"
  38
  39 #define FWRITE(_b,_s,_n,_f)     if (fwrite(_b,_s,_n,_f) != _n) { \
  40                                         g_message("log fwrite failed!\n"); \
  41                                         return; \
  42                                 }
  43 #define FPUTS(_b,_f)            if (fputs(_b,_f) == EOF) { \
  44                                         g_message("log fputs failed!\n"); \
  45                                         return; \
  46                                 }
  47 #define FFLUSH(_f)              if (fflush(_f) != 0) { \
  48                                         g_message("log fflush failed!\n"); \
  49                                         return; \
  50                                 }
  51
  52 static FILE *log_fp[LOG_INSTANCE_MAX] = {
  53         NULL,
  54         NULL
  55 };
  56
  57 static size_t log_size[LOG_INSTANCE_MAX] = {
  58         0,
  59         0
  60 };
  61
  62 static gchar *log_filename[LOG_INSTANCE_MAX] = {
  63         NULL,
  64         NULL
  65 };
  66
  67 /* read-only */
  68 static gboolean log_error_capability[LOG_INSTANCE_MAX] = {
  69         TRUE,
  70         FALSE
  71 };
  72
  73 typedef struct _LogInstanceData LogInstanceData;
  74
  75 struct _LogInstanceData {
  76         const char *hook;
  77         gchar *title;
  78         int *prefs_logwin_width;
  79         int *prefs_logwin_height;
  80 };
  81
  82 static LogInstanceData log_instances[LOG_INSTANCE_MAX] = {
  83         { LOG_APPEND_TEXT_HOOKLIST, NULL, NULL, NULL },
  84         { DEBUG_FILTERING_APPEND_TEXT_HOOKLIST, NULL, NULL, NULL }
  85 };
  86
  87 gboolean prefs_common_enable_log_standard(void);
  88 gboolean prefs_common_enable_log_warning(void);
  89 gboolean prefs_common_enable_log_error(void);
  90 gboolean prefs_common_enable_log_status(void);
  91
  92 static gboolean invoke_hook_cb (gpointer data)
  93 {
  94         LogText *logtext = (LogText *)data;
  95         hooks_invoke(get_log_hook(logtext->instance), logtext);
  96         g_free(logtext->text);
  97         g_free(logtext);
  98         return FALSE;
  99 }
 100
 101 void set_log_file(LogInstance instance, const gchar *filename)
 102 {
 103         gchar *fullname = NULL;
 104         if (log_fp[instance])
 105                 return;
 106
 107         if (!g_path_is_absolute(filename)) {
 108                 fullname = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
 109                                         filename, NULL);
 110         } else {
 111                 fullname = g_strdup(filename);
 112         }
 113         /* backup old logfile if existing */
 114         if (is_file_exist(fullname)) {
 115                 gchar *backupname;
 116
 117                 backupname = g_strconcat(fullname, ".bak", NULL);
 118                 claws_unlink(backupname);
 119                 if (g_rename(fullname, backupname) < 0)
 120                         FILE_OP_ERROR(fullname, "rename");
 121                 g_free(backupname);
 122         }
 123
 124         log_fp[instance] = fopen(fullname, "wb");
 125         if (!log_fp[instance]) {
 126                 FILE_OP_ERROR(fullname, "fopen");
 127                 log_filename[instance] = NULL;
 128                 g_free(fullname);
 129                 return;
 130         }
 131
 132         if (change_file_mode_rw(log_fp[instance], fullname) < 0) {
 133                 FILE_OP_ERROR(fullname, "chmod");
 134                 g_warning("can't change file mode: %s", fullname);
 135         }
 136
 137         log_filename[instance] = g_strdup(fullname);
 138         log_size[instance] = 0;
 139         g_free(fullname);
 140 }
 141
 142 void close_log_file(LogInstance instance)
 143 {
 144         if (log_fp[instance]) {
 145                 fclose(log_fp[instance]);
 146                 log_fp[instance] = NULL;
 147                 log_size[instance] = 0;
 148                 g_free(log_filename[instance]);
 149                 log_filename[instance] = NULL;
 150         }
 151 }
 152
 153 static void rotate_log(LogInstance instance)
 154 {
 155         if (log_size[instance] > 10 * 1024* 1024) {
 156                 gchar *filename = g_strdup(log_filename[instance]);
 157                 debug_print("rotating %s\n", filename);
 158                 close_log_file(instance);
 159                 set_log_file(instance, filename);
 160                 g_free(filename);
 161         }
 162 }
 163
 164 const char *get_log_hook(LogInstance instance)
 165 {
 166         return log_instances[instance].hook;
 167 }
 168
 169 void set_log_title(LogInstance instance, gchar *title)
 170 {
 171         log_instances[instance].title = title;
 172 }
 173
 174 gchar *get_log_title(LogInstance instance)
 175 {
 176         return log_instances[instance].title;
 177 }
 178
 179 void set_log_prefs(LogInstance instance, int* logwin_width, int* logwin_height)
 180 {
 181         log_instances[instance].prefs_logwin_width = logwin_width;
 182         log_instances[instance].prefs_logwin_height = logwin_height;
 183 }
 184
 185 void get_log_prefs(LogInstance instance, int** logwin_width, int** logwin_height)
 186 {
 187         if (logwin_width)
 188                 *logwin_width = log_instances[instance].prefs_logwin_width;
 189         if (logwin_height)
 190                 *logwin_height = log_instances[instance].prefs_logwin_height;
 191 }
 192
 193 gboolean get_log_error_capability(LogInstance instance)
 194 {
 195         return log_error_capability[instance];
 196
 197 }
 198
 199 void log_print(LogInstance instance, const gchar *format, ...)
 200 {
 201         va_list args;
 202         gchar buf[BUFFSIZE + LOG_TIME_LEN];
 203         time_t t;
 204         LogText *logtext = g_new0(LogText, 1);
 205         struct tm buft;
 206
 207         time(&t);
 208         strftime(buf, LOG_TIME_LEN + 1, LOG_TIME_FORMAT, localtime_r(&t, &buft));
 209
 210         va_start(args, format);
 211         g_vsnprintf(buf + LOG_TIME_LEN, BUFFSIZE, format, args);
 212         va_end(args);
 213
 214         if (debug_get_mode()) g_print("%s", buf);
 215
 216         logtext->instance = instance;
 217         logtext->text = g_strdup(buf);
 218         logtext->type = LOG_NORMAL;
 219
 220         g_timeout_add(0, invoke_hook_cb, logtext);
 221
 222         if (log_fp[instance] && prefs_common_enable_log_standard()) {
 223                 FPUTS(buf, log_fp[instance])
 224                 log_size[instance] += strlen(buf);
 225                 FFLUSH(log_fp[instance])
 226                 rotate_log(instance);
 227         }
 228 }
 229
 230 void log_message(LogInstance instance, const gchar *format, ...)
 231 {
 232         va_list args;
 233         gchar buf[BUFFSIZE + LOG_TIME_LEN];
 234         time_t t;
 235         LogText *logtext = g_new0(LogText, 1);
 236         struct tm buft;
 237
 238         time(&t);
 239         strftime(buf, LOG_TIME_LEN + 1, LOG_TIME_FORMAT, localtime_r(&t, &buft));
 240
 241         va_start(args, format);
 242         g_vsnprintf(buf + LOG_TIME_LEN, BUFFSIZE, format, args);
 243         va_end(args);
 244
 245         if (debug_get_mode()) g_message("%s", buf + LOG_TIME_LEN);
 246
 247         logtext->instance = instance;
 248         logtext->text = g_strdup(buf + LOG_TIME_LEN);
 249         logtext->type = LOG_MSG;
 250
 251         g_timeout_add(0, invoke_hook_cb, logtext);
 252
 253         if (log_fp[instance] && prefs_common_enable_log_standard()) {
 254                 FWRITE(buf, 1, LOG_TIME_LEN, log_fp[instance])
 255                 FPUTS("* message: ", log_fp[instance])
 256                 log_size[instance] += strlen("* message: ");
 257                 FPUTS(buf + LOG_TIME_LEN, log_fp[instance])
 258                 log_size[instance] += strlen(buf);
 259                 FFLUSH(log_fp[instance])
 260                 rotate_log(instance);
 261         }
 262 }
 263
 264 void log_warning(LogInstance instance, const gchar *format, ...)
 265 {
 266         va_list args;
 267         gchar buf[BUFFSIZE + LOG_TIME_LEN];
 268         time_t t;
 269         LogText *logtext = g_new0(LogText, 1);
 270         struct tm buft;
 271
 272         time(&t);
 273         strftime(buf, LOG_TIME_LEN + 1, LOG_TIME_FORMAT, localtime_r(&t, &buft));
 274
 275         va_start(args, format);
 276         g_vsnprintf(buf + LOG_TIME_LEN, BUFFSIZE, format, args);
 277         va_end(args);
 278
 279         g_warning("%s", buf);
 280
 281         logtext->instance = instance;
 282         logtext->text = g_strdup(buf + LOG_TIME_LEN);
 283         logtext->type = LOG_WARN;
 284
 285         g_timeout_add(0, invoke_hook_cb, logtext);
 286
 287         if (log_fp[instance] && prefs_common_enable_log_warning()) {
 288                 FWRITE(buf, 1, LOG_TIME_LEN, log_fp[instance])
 289                 FPUTS("** warning: ", log_fp[instance])
 290                 log_size[instance] += strlen("** warning: ");
 291                 FPUTS(buf + LOG_TIME_LEN, log_fp[instance])
 292                 log_size[instance] += strlen(buf);
 293                 FFLUSH(log_fp[instance])
 294                 rotate_log(instance);
 295         }
 296 }
 297
 298 void log_error(LogInstance instance, const gchar *format, ...)
 299 {
 300         va_list args;
 301         gchar buf[BUFFSIZE + LOG_TIME_LEN];
 302         time_t t;
 303         LogText *logtext = g_new0(LogText, 1);
 304         struct tm buft;
 305
 306         time(&t);
 307         strftime(buf, LOG_TIME_LEN + 1, LOG_TIME_FORMAT, localtime_r(&t, &buft));
 308
 309         va_start(args, format);
 310         g_vsnprintf(buf + LOG_TIME_LEN, BUFFSIZE, format, args);
 311         va_end(args);
 312
 313         g_warning("%s", buf);
 314
 315         logtext->instance = instance;
 316         logtext->text = g_strdup(buf + LOG_TIME_LEN);
 317         logtext->type = LOG_ERROR;
 318
 319         g_timeout_add(0, invoke_hook_cb, logtext);
 320
 321         if (log_fp[instance] && prefs_common_enable_log_error()) {
 322                 FWRITE(buf, 1, LOG_TIME_LEN, log_fp[instance])
 323                 FPUTS("*** error: ", log_fp[instance])
 324                 log_size[instance] += strlen("*** error: ");
 325                 FPUTS(buf + LOG_TIME_LEN, log_fp[instance])
 326                 log_size[instance] += strlen(buf);
 327                 FFLUSH(log_fp[instance])
 328                 rotate_log(instance);
 329         }
 330 }
 331
 332 void log_status_ok(LogInstance instance, const gchar *format, ...)
 333 {
 334         va_list args;
 335         gchar buf[BUFFSIZE + LOG_TIME_LEN];
 336         time_t t;
 337         LogText *logtext = g_new0(LogText, 1);
 338         struct tm buft;
 339
 340         time(&t);
 341         strftime(buf, LOG_TIME_LEN + 1, LOG_TIME_FORMAT, localtime_r(&t, &buft));
 342
 343         va_start(args, format);
 344         g_vsnprintf(buf + LOG_TIME_LEN, BUFFSIZE, format, args);
 345         va_end(args);
 346
 347         if (debug_get_mode()) g_message("%s", buf + LOG_TIME_LEN);
 348
 349         logtext->instance = instance;
 350         logtext->text = g_strdup(buf + LOG_TIME_LEN);
 351         logtext->type = LOG_STATUS_OK;
 352
 353         g_timeout_add(0, invoke_hook_cb, logtext);
 354
 355         if (log_fp[instance] && prefs_common_enable_log_status()) {
 356                 FWRITE(buf, 1, LOG_TIME_LEN, log_fp[instance])
 357                 FPUTS("* OK: ", log_fp[instance])
 358                 log_size[instance] += strlen("* OK: ");
 359                 FPUTS(buf + LOG_TIME_LEN, log_fp[instance])
 360                 log_size[instance] += strlen(buf);
 361                 FFLUSH(log_fp[instance])
 362                 rotate_log(instance);
 363         }
 364 }
 365
 366 void log_status_nok(LogInstance instance, const gchar *format, ...)
 367 {
 368         va_list args;
 369         gchar buf[BUFFSIZE + LOG_TIME_LEN];
 370         time_t t;
 371         LogText *logtext = g_new0(LogText, 1);
 372         struct tm buft;
 373
 374         time(&t);
 375         strftime(buf, LOG_TIME_LEN + 1, LOG_TIME_FORMAT, localtime_r(&t, &buft));
 376
 377         va_start(args, format);
 378         g_vsnprintf(buf + LOG_TIME_LEN, BUFFSIZE, format, args);
 379         va_end(args);
 380
 381         if (debug_get_mode()) g_message("%s", buf + LOG_TIME_LEN);
 382
 383         logtext->instance = instance;
 384         logtext->text = g_strdup(buf + LOG_TIME_LEN);
 385         logtext->type = LOG_STATUS_NOK;
 386
 387         g_timeout_add(0, invoke_hook_cb, logtext);
 388
 389         if (log_fp[instance] && prefs_common_enable_log_status()) {
 390                 FWRITE(buf, 1, LOG_TIME_LEN, log_fp[instance])
 391                 FPUTS("* NOT OK: ", log_fp[instance])
 392                 log_size[instance] += strlen("* NOT OK: ");
 393                 FPUTS(buf + LOG_TIME_LEN, log_fp[instance])
 394                 log_size[instance] += strlen(buf);
 395                 FFLUSH(log_fp[instance])
 396                 rotate_log(instance);
 397         }
 398 }
 399
 400 void log_status_skip(LogInstance instance, const gchar *format, ...)
 401 {
 402         va_list args;
 403         gchar buf[BUFFSIZE + LOG_TIME_LEN];
 404         time_t t;
 405         LogText *logtext = g_new0(LogText, 1);
 406         struct tm buft;
 407
 408         time(&t);
 409         strftime(buf, LOG_TIME_LEN + 1, LOG_TIME_FORMAT, localtime_r(&t, &buft));
 410
 411         va_start(args, format);
 412         g_vsnprintf(buf + LOG_TIME_LEN, BUFFSIZE, format, args);
 413         va_end(args);
 414
 415         if (debug_get_mode()) g_message("%s", buf + LOG_TIME_LEN);
 416
 417         logtext->instance = instance;
 418         logtext->text = g_strdup(buf + LOG_TIME_LEN);
 419         logtext->type = LOG_STATUS_SKIP;
 420
 421         g_timeout_add(0, invoke_hook_cb, logtext);
 422
 423         if (log_fp[instance] && prefs_common_enable_log_status()) {
 424                 FWRITE(buf, 1, LOG_TIME_LEN, log_fp[instance])
 425                 FPUTS("* SKIPPED: ", log_fp[instance])
 426                 log_size[instance] += strlen("* SKIPPED: ");
 427                 FPUTS(buf + LOG_TIME_LEN, log_fp[instance])
 428                 log_size[instance] += strlen(buf);
 429                 FFLUSH(log_fp[instance])
 430                 rotate_log(instance);
 431         }
 432 }
 433
 434 #undef FWRITE
 435 #undef FPUTS
 436 #undef FFLUSH
 437