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