* @file log.c Logging API * Purple is the legal property of its developers, whose names are too numerous * to list here. Please refer to the COPYRIGHT file distributed with this * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA static GSList *loggers = NULL; static PurpleLogLogger *html_logger; static PurpleLogLogger *txt_logger; static PurpleLogLogger *old_logger; struct _purple_logsize_user { static GHashTable *logsize_users = NULL; static GHashTable *logsize_users_decayed = NULL; static void log_get_log_sets_common(GHashTable *sets); static gsize html_logger_write(PurpleLog *log, PurpleMessageFlags type, const char *from, time_t time, const char *message); static void html_logger_finalize(PurpleLog *log); static GList *html_logger_list(PurpleLogType type, const char *sn, PurpleAccount *account); static GList *html_logger_list_syslog(PurpleAccount *account); static char *html_logger_read(PurpleLog *log, PurpleLogReadFlags *flags); static int html_logger_total_size(PurpleLogType type, const char *name, PurpleAccount *account); static GList *old_logger_list(PurpleLogType type, const char *sn, PurpleAccount *account); static int old_logger_total_size(PurpleLogType type, const char *name, PurpleAccount *account); static char * old_logger_read (PurpleLog *log, PurpleLogReadFlags *flags); static int old_logger_size (PurpleLog *log); static void old_logger_get_log_sets(PurpleLogSetCallback cb, GHashTable *sets); static void old_logger_finalize(PurpleLog *log); static gsize txt_logger_write(PurpleLog *log, const char *from, time_t time, const char *message); static void txt_logger_finalize(PurpleLog *log); static GList *txt_logger_list(PurpleLogType type, const char *sn, PurpleAccount *account); static GList *txt_logger_list_syslog(PurpleAccount *account); static char *txt_logger_read(PurpleLog *log, PurpleLogReadFlags *flags); static int txt_logger_total_size(PurpleLogType type, const char *name, PurpleAccount *account); /************************************************************************** * PUBLIC LOGGING FUNCTIONS *********************************************** **************************************************************************/ PurpleLog *purple_log_new(PurpleLogType type, const char *name, PurpleAccount *account, PurpleConversation *conv, time_t time, const struct tm *tm) /* IMPORTANT: Make sure to initialize all the members of PurpleLog */ log = g_slice_new(PurpleLog); PURPLE_DBUS_REGISTER_POINTER(log, PurpleLog); log->name = g_strdup(purple_normalize(account, name)); log->logger = purple_log_logger_get(); /* There's no need to zero this as we immediately do a direct copy. */ log->tm = g_slice_new(struct tm); #ifdef HAVE_STRUCT_TM_TM_ZONE /* XXX: This is so wrong... */ if (log->tm->tm_zone != NULL) char *tmp = g_locale_from_utf8(log->tm->tm_zone, -1, NULL, NULL, NULL); /* Just shove the UTF-8 bytes in and hope... */ log->tm->tm_zone = g_strdup(log->tm->tm_zone); if (log->logger && log->logger->create) log->logger->create(log); void purple_log_free(PurpleLog *log) if (log->logger && log->logger->finalize) log->logger->finalize(log); #ifdef HAVE_STRUCT_TM_TM_ZONE /* XXX: This is so wrong... */ g_free((char *)log->tm->tm_zone); g_slice_free(struct tm, log->tm); PURPLE_DBUS_UNREGISTER_POINTER(log); g_slice_free(PurpleLog, log); void purple_log_write(PurpleLog *log, PurpleMessageFlags type, const char *from, time_t time, const char *message) struct _purple_logsize_user *lu; gsize written, total = 0; g_return_if_fail(log->logger); g_return_if_fail(log->logger->write); written = (log->logger->write)(log, type, from, time, message); lu = g_new(struct _purple_logsize_user, 1); lu->name = g_strdup(purple_normalize(log->account, log->name)); lu->account = log->account; if(g_hash_table_lookup_extended(logsize_users, lu, NULL, &ptrsize)) { total = GPOINTER_TO_INT(ptrsize); g_hash_table_replace(logsize_users, lu, GINT_TO_POINTER(total)); /* The hash table takes ownership of lu, so create a new one * for the logsize_users_decayed check below. */ lu = g_new(struct _purple_logsize_user, 1); lu->name = g_strdup(tmp); lu->account = log->account; if(g_hash_table_lookup_extended(logsize_users_decayed, lu, NULL, &ptrsize)) { total = GPOINTER_TO_INT(ptrsize); g_hash_table_replace(logsize_users_decayed, lu, GINT_TO_POINTER(total)); char *purple_log_read(PurpleLog *log, PurpleLogReadFlags *flags) PurpleLogReadFlags mflags; g_return_val_if_fail(log && log->logger, NULL); char *ret = (log->logger->read)(log, flags ? flags : &mflags); purple_str_strip_char(ret, '\r'); return g_strdup(_("<b><font color=\"red\">The logger has no read function</font></b>")); int purple_log_get_size(PurpleLog *log) g_return_val_if_fail(log && log->logger, 0); return log->logger->size(log); static guint _purple_logsize_user_hash(struct _purple_logsize_user *lu) return g_str_hash(lu->name); static guint _purple_logsize_user_equal(struct _purple_logsize_user *lu1, struct _purple_logsize_user *lu2) return (lu1->account == lu2->account && purple_strequal(lu1->name, lu2->name)); static void _purple_logsize_user_free_key(struct _purple_logsize_user *lu) int purple_log_get_total_size(PurpleLogType type, const char *name, PurpleAccount *account) struct _purple_logsize_user *lu; lu = g_new(struct _purple_logsize_user, 1); lu->name = g_strdup(purple_normalize(account, name)); if(g_hash_table_lookup_extended(logsize_users, lu, NULL, &ptrsize)) { size = GPOINTER_TO_INT(ptrsize); for (n = loggers; n; n = n->next) { PurpleLogLogger *logger = n->data; size += (logger->total_size)(type, name, account); } else if(logger->list) { GList *logs = (logger->list)(type, name, account); PurpleLog *log = (PurpleLog*)(logs->data); this_size += purple_log_get_size(log); logs = g_list_delete_link(logs, logs); g_hash_table_replace(logsize_users, lu, GINT_TO_POINTER(size)); gint purple_log_get_activity_score(PurpleLogType type, const char *name, PurpleAccount *account) struct _purple_logsize_user *lu; lu = g_new(struct _purple_logsize_user, 1); lu->name = g_strdup(purple_normalize(account, name)); if(g_hash_table_lookup_extended(logsize_users_decayed, lu, NULL, &ptrscore)) { score = GPOINTER_TO_INT(ptrscore); double score_double = 0.0; for (n = loggers; n; n = n->next) { PurpleLogLogger *logger = n->data; GList *logs = (logger->list)(type, name, account); PurpleLog *log = (PurpleLog*)(logs->data); /* Activity score counts bytes in the log, exponentially decayed with a half-life of 14 days. */ score_double += purple_log_get_size(log) * pow(0.5, difftime(now, log->time)/1209600.0); logs = g_list_delete_link(logs, logs); score = (gint) ceil(score_double); g_hash_table_replace(logsize_users_decayed, lu, GINT_TO_POINTER(score)); gboolean purple_log_is_deletable(PurpleLog *log) g_return_val_if_fail(log != NULL, FALSE); g_return_val_if_fail(log->logger != NULL, FALSE); if (log->logger->remove == NULL) if (log->logger->is_deletable != NULL) return log->logger->is_deletable(log); gboolean purple_log_delete(PurpleLog *log) g_return_val_if_fail(log != NULL, FALSE); g_return_val_if_fail(log->logger != NULL, FALSE); if (log->logger->remove != NULL) return log->logger->remove(log); purple_log_get_log_dir(PurpleLogType type, const char *name, PurpleAccount *account) PurplePluginProtocolInfo *prpl_info; prpl = purple_find_prpl(purple_account_get_protocol_id(account)); prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); prpl_name = prpl_info->list_icon(account, NULL); acct_name = g_strdup(purple_escape_filename(purple_normalize(account, purple_account_get_username(account)))); if (type == PURPLE_LOG_CHAT) { char *temp = g_strdup_printf("%s.chat", purple_normalize(account, name)); target = purple_escape_filename(temp); } else if(type == PURPLE_LOG_SYSTEM) { target = purple_escape_filename(purple_normalize(account, name)); dir = g_build_filename(purple_user_dir(), "logs", prpl_name, acct_name, target, NULL); /**************************************************************************** * LOGGER FUNCTIONS ********************************************************* ****************************************************************************/ static PurpleLogLogger *current_logger = NULL; static void logger_pref_cb(const char *name, PurplePrefType type, gconstpointer value, gpointer data) if (purple_strequal(logger->id, value)) { purple_log_logger_set(logger); purple_log_logger_set(txt_logger); PurpleLogLogger *purple_log_logger_new(const char *id, const char *name, int functions, ...) void(*create)(PurpleLog *), gsize(*write)(PurpleLog *, PurpleMessageFlags, const char *, time_t, const char *), void(*finalize)(PurpleLog *), GList*(*list)(PurpleLogType type, const char*, PurpleAccount*), char*(*read)(PurpleLog*, PurpleLogReadFlags*), int(*total_size)(PurpleLogType type, const char *name, PurpleAccount *account), GList*(*list_syslog)(PurpleAccount *account), void(*get_log_sets)(PurpleLogSetCallback cb, GHashTable *sets), gboolean(*remove)(PurpleLog *log), gboolean(*is_deletable)(PurpleLog *log)) g_return_val_if_fail(id != NULL, NULL); g_return_val_if_fail(name != NULL, NULL); g_return_val_if_fail(functions >= 1, NULL); logger = g_new0(PurpleLogLogger, 1); logger->id = g_strdup(id); logger->name = g_strdup(name); va_start(args, functions); logger->create = va_arg(args, void *); logger->write = va_arg(args, void *); logger->finalize = va_arg(args, void *); logger->list = va_arg(args, void *); logger->read = va_arg(args, void *); logger->size = va_arg(args, void *); logger->total_size = va_arg(args, void *); logger->list_syslog = va_arg(args, void *); logger->get_log_sets = va_arg(args, void *); logger->remove = va_arg(args, void *); logger->is_deletable = va_arg(args, void *); purple_debug_info("log", "Dropping new functions for logger: %s (%s)\n", name, id); void purple_log_logger_free(PurpleLogLogger *logger) void purple_log_logger_add (PurpleLogLogger *logger) g_return_if_fail(logger); if (g_slist_find(loggers, logger)) loggers = g_slist_append(loggers, logger); if (purple_strequal(purple_prefs_get_string("/purple/logging/format"), logger->id)) { purple_prefs_trigger_callback("/purple/logging/format"); void purple_log_logger_remove (PurpleLogLogger *logger) g_return_if_fail(logger); loggers = g_slist_remove(loggers, logger); void purple_log_logger_set (PurpleLogLogger *logger) g_return_if_fail(logger); PurpleLogLogger *purple_log_logger_get() GList *purple_log_logger_get_options(void) for (n = loggers; n; n = n->next) { list = g_list_append(list, data->name); list = g_list_append(list, data->id); gint purple_log_compare(gconstpointer y, gconstpointer z) return b->time - a->time; GList *purple_log_get_logs(PurpleLogType type, const char *name, PurpleAccount *account) for (n = loggers; n; n = n->next) { PurpleLogLogger *logger = n->data; logs = g_list_concat(logger->list(type, name, account), logs); return g_list_sort(logs, purple_log_compare); gint purple_log_set_compare(gconstpointer y, gconstpointer z) const PurpleLogSet *a = y; const PurpleLogSet *b = z; /* This logic seems weird at first... * If either account is NULL, we pretend the accounts are * equal. This allows us to detect duplicates that will * exist if one logger knows the account and another if (a->account != NULL && b->account != NULL) { ret = strcmp(purple_account_get_username(a->account), purple_account_get_username(b->account)); ret = strcmp(a->normalized_name, b->normalized_name); return (gint)b->type - (gint)a->type; log_set_hash(gconstpointer key) const PurpleLogSet *set = key; /* The account isn't hashed because we need PurpleLogSets with NULL accounts * to be found when we search by a PurpleLogSet that has a non-NULL account * but the same type and name. */ return g_int_hash(&set->type) + g_str_hash(set->name); log_set_equal(gconstpointer a, gconstpointer b) /* I realize that the choices made for GList and GHashTable * make sense for those data types, but I wish the comparison * functions were compatible. */ return !purple_log_set_compare(a, b); log_add_log_set_to_hash(GHashTable *sets, PurpleLogSet *set) PurpleLogSet *existing_set = g_hash_table_lookup(sets, set); if (existing_set == NULL) g_hash_table_insert(sets, set, set); else if (existing_set->account == NULL && set->account != NULL) g_hash_table_replace(sets, set, set); purple_log_set_free(set); GHashTable *purple_log_get_log_sets(void) GHashTable *sets = g_hash_table_new_full(log_set_hash, log_set_equal, (GDestroyNotify)purple_log_set_free, NULL); /* Get the log sets from all the loggers. */ for (n = loggers; n; n = n->next) { PurpleLogLogger *logger = n->data; if (!logger->get_log_sets) logger->get_log_sets(log_add_log_set_to_hash, sets); log_get_log_sets_common(sets); /* Return the GHashTable of unique PurpleLogSets. */ void purple_log_set_free(PurpleLogSet *set) g_return_if_fail(set != NULL); if (set->normalized_name != set->name) g_free(set->normalized_name); g_slice_free(PurpleLogSet, set); GList *purple_log_get_system_logs(PurpleAccount *account) for (n = loggers; n; n = n->next) { PurpleLogLogger *logger = n->data; if (!logger->list_syslog) logs = g_list_concat(logger->list_syslog(account), logs); return g_list_sort(logs, purple_log_compare); /**************************************************************************** * LOG SUBSYSTEM ************************************************************ ****************************************************************************/ purple_log_get_handle(void) void purple_log_init(void) void *handle = purple_log_get_handle(); purple_prefs_add_none("/purple/logging"); purple_prefs_add_bool("/purple/logging/log_ims", TRUE); purple_prefs_add_bool("/purple/logging/log_chats", TRUE); purple_prefs_add_bool("/purple/logging/log_system", FALSE); purple_prefs_add_string("/purple/logging/format", "html"); html_logger = purple_log_logger_new("html", _("HTML"), 11, purple_log_common_deleter, purple_log_common_is_deletable); purple_log_logger_add(html_logger); txt_logger = purple_log_logger_new("txt", _("Plain text"), 11, purple_log_common_deleter, purple_log_common_is_deletable); purple_log_logger_add(txt_logger); old_logger = purple_log_logger_new("old", _("Old flat format"), 9, old_logger_get_log_sets); purple_log_logger_add(old_logger); purple_signal_register(handle, "log-timestamp", purple_marshal_POINTER__POINTER_INT_BOOLEAN, purple_marshal_POINTER__POINTER_INT64_BOOLEAN, #error Unknown size of time_t purple_value_new(PURPLE_TYPE_STRING), 3, purple_value_new(PURPLE_TYPE_SUBTYPE, purple_value_new(PURPLE_TYPE_INT), purple_value_new(PURPLE_TYPE_INT64), # error Unknown size of time_t purple_value_new(PURPLE_TYPE_BOOLEAN)); purple_prefs_connect_callback(NULL, "/purple/logging/format", purple_prefs_trigger_callback("/purple/logging/format"); logsize_users = g_hash_table_new_full((GHashFunc)_purple_logsize_user_hash, (GEqualFunc)_purple_logsize_user_equal, (GDestroyNotify)_purple_logsize_user_free_key, NULL); logsize_users_decayed = g_hash_table_new_full((GHashFunc)_purple_logsize_user_hash, (GEqualFunc)_purple_logsize_user_equal, (GDestroyNotify)_purple_logsize_user_free_key, NULL); purple_signals_unregister_by_instance(purple_log_get_handle()); purple_log_logger_remove(html_logger); purple_log_logger_free(html_logger); purple_log_logger_remove(txt_logger); purple_log_logger_free(txt_logger); purple_log_logger_remove(old_logger); purple_log_logger_free(old_logger); g_hash_table_destroy(logsize_users); g_hash_table_destroy(logsize_users_decayed); /**************************************************************************** * LOGGERS ****************************************************************** ****************************************************************************/ static char *log_get_timestamp(PurpleLog *log, time_t when) show_date = (log->type == PURPLE_LOG_SYSTEM) || (time(NULL) > when + 20*60); date = purple_signal_emit_return_1(purple_log_get_handle(), return g_strdup(purple_date_format_long(tm)); return g_strdup(purple_time_format(tm)); /* NOTE: This can return msg (which you may or may not want to g_free()) * NOTE: or a newly allocated string which you MUST g_free(). */ convert_image_tags(const PurpleLog *log, const char *msg) while (purple_markup_find_tag("img", tmp, &start, &end, &attributes)) { newmsg = g_string_new(""); /* copy any text before the img tag */ g_string_append_len(newmsg, tmp, start - tmp); if ((idstr = g_datalist_get_data(&attributes, "id")) != NULL) PurpleStoredImage *image; gconstpointer image_data; char *new_filename = NULL; image = purple_imgstore_find_by_id(imgid); /* This should never happen. */ /* This *does* happen for failed Direct-IMs -DAA */ g_string_free(newmsg, TRUE); g_return_val_if_reached((char *)msg); image_data = purple_imgstore_get_data(image); image_byte_count = purple_imgstore_get_size(image); dir = purple_log_get_log_dir(log->type, log->name, log->account); new_filename = purple_util_get_image_filename(image_data, image_byte_count); path = g_build_filename(dir, new_filename, NULL); /* Only save unique files. */ if (!g_file_test(path, G_FILE_TEST_EXISTS)) if ((image_file = g_fopen(path, "wb")) != NULL) if (!fwrite(image_data, image_byte_count, 1, image_file)) purple_debug_error("log", "Error writing %s: %s\n", path, g_strerror(errno)); /* Attempt to not leave half-written files around. */ purple_debug_info("log", "Wrote image file: %s\n", path); purple_debug_error("log", "Unable to create file %s: %s\n", path, g_strerror(errno)); /* Write the new image tag */ g_string_append_printf(newmsg, "<IMG SRC=\"%s\">", new_filename); /* Continue from the end of the tag */ /* No images were found to change. */ /* Append any remaining message data */ g_string_append(newmsg, tmp); return g_string_free(newmsg, FALSE); void purple_log_common_writer(PurpleLog *log, const char *ext) PurpleLogCommonLoggerData *data = log->logger_data; dir = purple_log_get_log_dir(log->type, log->name, log->account); purple_build_dir (dir, S_IRUSR | S_IWUSR | S_IXUSR); tm = localtime(&log->time); tz = purple_escape_filename(purple_utf8_strftime("%Z", tm)); date = purple_utf8_strftime("%Y-%m-%d.%H%M%S%z", tm); filename = g_strdup_printf("%s%s%s", date, tz, ext ? ext : ""); path = g_build_filename(dir, filename, NULL); log->logger_data = data = g_slice_new0(PurpleLogCommonLoggerData); data->file = g_fopen(path, "a"); purple_debug(PURPLE_DEBUG_ERROR, "log", "Could not create log file %s\n", path); purple_conversation_write(log->conv, NULL, _("Logging of this conversation failed."), PURPLE_MESSAGE_ERROR, time(NULL)); GList *purple_log_common_lister(PurpleLogType type, const char *name, PurpleAccount *account, const char *ext, PurpleLogLogger *logger) path = purple_log_get_log_dir(type, name, account); if (!(dir = g_dir_open(path, 0, NULL))) while ((filename = g_dir_read_name(dir))) if (purple_str_has_suffix(filename, ext) && strlen(filename) >= (17 + strlen(ext))) PurpleLogCommonLoggerData *data; #if defined (HAVE_TM_GMTOFF) && defined (HAVE_STRUCT_TM_TM_ZONE) time_t stamp = purple_str_to_time(purple_unescape_filename(filename), FALSE, &tm, &tz_off, &rest); /* As zero is a valid offset, PURPLE_NO_TZ_OFF means no offset was * provided. See util.h. Yes, it's kinda ugly. */ if (tz_off != PURPLE_NO_TZ_OFF) tm.tm_gmtoff = tz_off - tm.tm_gmtoff; if (stamp == 0 || rest == NULL || (end = strchr(rest, '.')) == NULL || strchr(rest, ' ') != NULL) log = purple_log_new(type, name, account, NULL, stamp, NULL); char *tmp = g_strndup(rest, end - rest); log = purple_log_new(type, name, account, NULL, stamp, &tm); time_t stamp = purple_str_to_time(filename, FALSE, &tm, NULL, NULL); log = purple_log_new(type, name, account, NULL, stamp, (stamp != 0) ? &tm : NULL); log->logger_data = data = g_slice_new0(PurpleLogCommonLoggerData); data->path = g_build_filename(path, filename, NULL); list = g_list_prepend(list, log); int purple_log_common_total_sizer(PurpleLogType type, const char *name, PurpleAccount *account, const char *ext) path = purple_log_get_log_dir(type, name, account); if (!(dir = g_dir_open(path, 0, NULL))) while ((filename = g_dir_read_name(dir))) if (purple_str_has_suffix(filename, ext) && strlen(filename) >= (17 + strlen(ext))) char *tmp = g_build_filename(path, filename, NULL); purple_debug_error("log", "Error stating log file: %s\n", tmp); int purple_log_common_sizer(PurpleLog *log) PurpleLogCommonLoggerData *data = log->logger_data; g_return_val_if_fail(data != NULL, 0); if (!data->path || g_stat(data->path, &st)) /* This will build log sets for all loggers that use the common logger * functions because they use the same directory structure. */ static void log_get_log_sets_common(GHashTable *sets) gchar *log_path = g_build_filename(purple_user_dir(), "logs", NULL); GDir *log_dir = g_dir_open(log_path, 0, NULL); while ((protocol = g_dir_read_name(log_dir)) != NULL) { gchar *protocol_path = g_build_filename(log_path, protocol, NULL); gchar *protocol_unescaped; if ((protocol_dir = g_dir_open(protocol_path, 0, NULL)) == NULL) { /* Using g_strdup() to cover the one-in-a-million chance that a * prpl's list_icon function uses purple_unescape_filename(). */ protocol_unescaped = g_strdup(purple_unescape_filename(protocol)); /* Find all the accounts for protocol. */ for (account_iter = purple_accounts_get_all() ; account_iter != NULL ; account_iter = account_iter->next) { PurplePluginProtocolInfo *prpl_info; prpl = purple_find_prpl(purple_account_get_protocol_id((PurpleAccount *)account_iter->data)); prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); if (purple_strequal(protocol_unescaped, prpl_info->list_icon((PurpleAccount *)account_iter->data, NULL))) accounts = g_list_prepend(accounts, account_iter->data); g_free(protocol_unescaped); while ((username = g_dir_read_name(protocol_dir)) != NULL) { gchar *username_path = g_build_filename(protocol_path, username, NULL); const gchar *username_unescaped; PurpleAccount *account = NULL; if ((username_dir = g_dir_open(username_path, 0, NULL)) == NULL) { /* Find the account for username in the list of accounts for protocol. */ username_unescaped = purple_unescape_filename(username); for (account_iter = g_list_first(accounts) ; account_iter != NULL ; account_iter = account_iter->next) { if (purple_strequal(((PurpleAccount *)account_iter->data)->username, username_unescaped)) { account = account_iter->data; /* Don't worry about the cast, name will point to dynamically allocated memory shortly. */ while ((name = (gchar *)g_dir_read_name(username_dir)) != NULL) { /* IMPORTANT: Always initialize all members of PurpleLogSet */ set = g_slice_new(PurpleLogSet); /* Unescape the filename. */ name = g_strdup(purple_unescape_filename(name)); /* Get the (possibly new) length of name. */ set->type = PURPLE_LOG_IM; /* set->buddy is always set below */ set->normalized_name = g_strdup(purple_normalize(account, name)); /* Check for .chat or .system at the end of the name to determine the type. */ gchar *tmp = &name[len - 7]; if (purple_strequal(tmp, ".system")) { set->type = PURPLE_LOG_SYSTEM; gchar *tmp = &name[len - 5]; if (purple_strequal(tmp, ".chat")) { set->type = PURPLE_LOG_CHAT; /* Determine if this (account, name) combination exists as a buddy. */ if (account != NULL && *name != '\0') set->buddy = (purple_find_buddy(account, name) != NULL); log_add_log_set_to_hash(sets, set); g_dir_close(username_dir); g_dir_close(protocol_dir); gboolean purple_log_common_deleter(PurpleLog *log) PurpleLogCommonLoggerData *data; g_return_val_if_fail(log != NULL, FALSE); ret = g_unlink(data->path); purple_debug_error("log", "Failed to delete: %s - %s\n", data->path, g_strerror(errno)); /* I'm not sure that g_unlink() will ever return * something other than 0 or -1. -- rlaager */ purple_debug_error("log", "Failed to delete: %s\n", data->path); gboolean purple_log_common_is_deletable(PurpleLog *log) PurpleLogCommonLoggerData *data; g_return_val_if_fail(log != NULL, FALSE); dirname = g_path_get_dirname(data->path); if (g_access(dirname, W_OK) == 0) purple_debug_info("log", "access(%s) failed: %s\n", dirname, g_strerror(errno)); /* Unless and until someone writes equivalent win32 code, * we'll assume the file is deletable. */ static char *process_txt_log(char *txt, char *to_free) /* The to_free argument allows us to save a * g_strdup() in some cases. */ /* g_markup_escape_text requires valid UTF-8 */ if (!g_utf8_validate(txt, -1, NULL)) tmp = purple_utf8_salvage(txt); tmp = g_markup_escape_text(txt, -1); txt = purple_markup_linkify(tmp); #if 0 /* Maybe some other time. */ static const char *str_from_msg_type (PurpleMessageFlags type) static void xml_logger_write(PurpleLog *log, const char *from, time_t time, const char *message) /* This log is new. We could use the loggers 'new' function, but * creating a new file there would result in empty files in the case * that you open a convo with someone, but don't say anything. char *dir = purple_log_get_log_dir(log->type, log->name, log->account); tm = localtime(&log->time); tz = purple_escape_filename(purple_utf8_strftime("%Z", tm); date = purple_utf8_strftime("%Y-%m-%d.%H%M%S%z", tm); name = g_strdup_printf("%s%s%s", date, tz, ext ? ext : ""); purple_build_dir (dir, S_IRUSR | S_IWUSR | S_IXUSR); filename = g_build_filename(dir, name, NULL); log->logger_data = g_fopen(filename, "a"); purple_debug(PURPLE_DEBUG_ERROR, "log", "Could not create log file %s\n", filename); fprintf(log->logger_data, "<?xml version='1.0' encoding='UTF-8' ?>\n" "<?xml-stylesheet href='file:///usr/src/web/htdocs/log-stylesheet.xsl' type='text/xml' ?>\n"); date = purple_utf8_strftime("%Y-%m-%d %H:%M:%S", localtime(&log->time)); fprintf(log->logger_data, "<conversation time='%s' screenname='%s' protocol='%s'>\n", /* if we can't write to the file, give up before we hurt ourselves */ date = log_get_timestamp(log, time); purple_markup_html_to_xhtml(message, &xhtml, NULL); fprintf(log->logger_data, "<message %s %s from='%s' time='%s'>%s</message>\n", type & PURPLE_MESSAGE_SEND ? "direction='sent'" : type & PURPLE_MESSAGE_RECV ? "direction='received'" : "", fprintf(log->logger_data, "<message %s %s time='%s'>%s</message>\n", type & PURPLE_MESSAGE_SEND ? "direction='sent'" : type & PURPLE_MESSAGE_RECV ? "direction='received'" : "", fflush(log->logger_data); static void xml_logger_finalize(PurpleLog *log) fprintf(log->logger_data, "</conversation>\n"); fclose(log->logger_data); static GList *xml_logger_list(PurpleLogType type, const char *sn, PurpleAccount *account) return purple_log_common_lister(type, sn, account, ".xml", &xml_logger); static PurpleLogLogger xml_logger = { /**************************** ** HTML LOGGER ************* ****************************/ static gsize html_logger_write(PurpleLog *log, PurpleMessageFlags type, const char *from, time_t time, const char *message) char *image_corrected_msg; PurplePlugin *plugin = purple_find_prpl(purple_account_get_protocol_id(log->account)); PurpleLogCommonLoggerData *data = log->logger_data; PURPLE_PLUGIN_PROTOCOL_INFO(plugin)->list_icon(log->account, NULL); purple_log_common_writer(log, ".html"); /* if we can't write to the file, give up before we hurt ourselves */ date = purple_date_format_full(localtime(&log->time)); written += fprintf(data->file, "<html><head>"); written += fprintf(data->file, "<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">"); written += fprintf(data->file, "<title>"); if (log->type == PURPLE_LOG_SYSTEM) header = g_strdup_printf("System log for account %s (%s) connected at %s", purple_account_get_username(log->account), prpl, date); header = g_strdup_printf("Conversation with %s at %s on %s (%s)", log->name, date, purple_account_get_username(log->account), prpl); written += fprintf(data->file, "%s", header); written += fprintf(data->file, "</title></head><body>"); written += fprintf(data->file, "<h3>%s</h3>\n", header); /* if we can't write to the file, give up before we hurt ourselves */ escaped_from = g_markup_escape_text(from, -1); image_corrected_msg = convert_image_tags(log, message); purple_markup_html_to_xhtml(image_corrected_msg, &msg_fixed, NULL); /* Yes, this breaks encapsulation. But it's a static function and * this saves a needless strdup(). */ if (image_corrected_msg != message) g_free(image_corrected_msg); date = log_get_timestamp(log, time); if(log->type == PURPLE_LOG_SYSTEM){ written += fprintf(data->file, "---- %s @ %s ----<br/>\n", msg_fixed, date); if (type & PURPLE_MESSAGE_SYSTEM) written += fprintf(data->file, "<font size=\"2\">(%s)</font><b> %s</b><br/>\n", date, msg_fixed); else if (type & PURPLE_MESSAGE_RAW) written += fprintf(data->file, "<font size=\"2\">(%s)</font> %s<br/>\n", date, msg_fixed); else if (type & PURPLE_MESSAGE_ERROR) written += fprintf(data->file, "<font color=\"#FF0000\"><font size=\"2\">(%s)</font><b> %s</b></font><br/>\n", date, msg_fixed); else if (type & PURPLE_MESSAGE_WHISPER) written += fprintf(data->file, "<font color=\"#6C2585\"><font size=\"2\">(%s)</font><b> %s:</b></font> %s<br/>\n", date, escaped_from, msg_fixed); else if (type & PURPLE_MESSAGE_AUTO_RESP) { if (type & PURPLE_MESSAGE_SEND) written += fprintf(data->file, _("<font color=\"#16569E\"><font size=\"2\">(%s)</font> <b>%s <AUTO-REPLY>:</b></font> %s<br/>\n"), date, escaped_from, msg_fixed); else if (type & PURPLE_MESSAGE_RECV) written += fprintf(data->file, _("<font color=\"#A82F2F\"><font size=\"2\">(%s)</font> <b>%s <AUTO-REPLY>:</b></font> %s<br/>\n"), date, escaped_from, msg_fixed); } else if (type & PURPLE_MESSAGE_RECV) { if(purple_message_meify(msg_fixed, -1)) written += fprintf(data->file, "<font color=\"#062585\"><font size=\"2\">(%s)</font> <b>***%s</b></font> %s<br/>\n", date, escaped_from, msg_fixed); written += fprintf(data->file, "<font color=\"#A82F2F\"><font size=\"2\">(%s)</font> <b>%s:</b></font> %s<br/>\n", date, escaped_from, msg_fixed); } else if (type & PURPLE_MESSAGE_SEND) { if(purple_message_meify(msg_fixed, -1)) written += fprintf(data->file, "<font color=\"#062585\"><font size=\"2\">(%s)</font> <b>***%s</b></font> %s<br/>\n", date, escaped_from, msg_fixed); written += fprintf(data->file, "<font color=\"#16569E\"><font size=\"2\">(%s)</font> <b>%s:</b></font> %s<br/>\n", date, escaped_from, msg_fixed); purple_debug_error("log", "Unhandled message type.\n"); written += fprintf(data->file, "<font size=\"2\">(%s)</font><b> %s:</b></font> %s<br/>\n", date, escaped_from, msg_fixed); static void html_logger_finalize(PurpleLog *log) PurpleLogCommonLoggerData *data = log->logger_data; fprintf(data->file, "</body></html>\n"); g_slice_free(PurpleLogCommonLoggerData, data); static GList *html_logger_list(PurpleLogType type, const char *sn, PurpleAccount *account) return purple_log_common_lister(type, sn, account, ".html", html_logger); static GList *html_logger_list_syslog(PurpleAccount *account) return purple_log_common_lister(PURPLE_LOG_SYSTEM, ".system", account, ".html", html_logger); static char *html_logger_read(PurpleLog *log, PurpleLogReadFlags *flags) PurpleLogCommonLoggerData *data = log->logger_data; *flags = PURPLE_LOG_READ_NO_NEWLINE; if (!data || !data->path) return g_strdup(_("<font color=\"red\"><b>Unable to find log path!</b></font>")); if (g_file_get_contents(data->path, &read, NULL, NULL)) { char *minus_header = strchr(read, '\n'); minus_header = g_strdup(minus_header + 1); return g_strdup_printf(_("<font color=\"red\"><b>Could not read file: %s</b></font>"), data->path); static int html_logger_total_size(PurpleLogType type, const char *name, PurpleAccount *account) return purple_log_common_total_sizer(type, name, account, ".html"); /**************************** ** PLAIN TEXT LOGGER ******* ****************************/ static gsize txt_logger_write(PurpleLog *log, const char *from, time_t time, const char *message) PurplePlugin *plugin = purple_find_prpl(purple_account_get_protocol_id(log->account)); PurpleLogCommonLoggerData *data = log->logger_data; /* This log is new. We could use the loggers 'new' function, but * creating a new file there would result in empty files in the case * that you open a convo with someone, but don't say anything. PURPLE_PLUGIN_PROTOCOL_INFO(plugin)->list_icon(log->account, NULL); purple_log_common_writer(log, ".txt"); /* if we can't write to the file, give up before we hurt ourselves */ if (log->type == PURPLE_LOG_SYSTEM) written += fprintf(data->file, "System log for account %s (%s) connected at %s\n", purple_account_get_username(log->account), prpl, purple_date_format_full(localtime(&log->time))); written += fprintf(data->file, "Conversation with %s at %s on %s (%s)\n", log->name, purple_date_format_full(localtime(&log->time)), purple_account_get_username(log->account), prpl); /* if we can't write to the file, give up before we hurt ourselves */ stripped = purple_markup_strip_html(message); date = log_get_timestamp(log, time); if(log->type == PURPLE_LOG_SYSTEM){ written += fprintf(data->file, "---- %s @ %s ----\n", stripped, date); if (type & PURPLE_MESSAGE_SEND || type & PURPLE_MESSAGE_RECV) { if (type & PURPLE_MESSAGE_AUTO_RESP) { written += fprintf(data->file, _("(%s) %s <AUTO-REPLY>: %s\n"), date, if(purple_message_meify(stripped, -1)) written += fprintf(data->file, "(%s) ***%s %s\n", date, from, written += fprintf(data->file, "(%s) %s: %s\n", date, from, } else if (type & PURPLE_MESSAGE_SYSTEM || type & PURPLE_MESSAGE_ERROR || type & PURPLE_MESSAGE_RAW) written += fprintf(data->file, "(%s) %s\n", date, stripped); else if (type & PURPLE_MESSAGE_NO_LOG) { /* This shouldn't happen */ } else if (type & PURPLE_MESSAGE_WHISPER) written += fprintf(data->file, "(%s) *%s* %s", date, from, stripped); written += fprintf(data->file, "(%s) %s%s %s\n", date, from ? from : "", from ? ":" : "", stripped); static void txt_logger_finalize(PurpleLog *log) PurpleLogCommonLoggerData *data = log->logger_data; g_slice_free(PurpleLogCommonLoggerData, data); static GList *txt_logger_list(PurpleLogType type, const char *sn, PurpleAccount *account) return purple_log_common_lister(type, sn, account, ".txt", txt_logger); static GList *txt_logger_list_syslog(PurpleAccount *account) return purple_log_common_lister(PURPLE_LOG_SYSTEM, ".system", account, ".txt", txt_logger); static char *txt_logger_read(PurpleLog *log, PurpleLogReadFlags *flags) char *read, *minus_header; PurpleLogCommonLoggerData *data = log->logger_data; if (!data || !data->path) return g_strdup(_("<font color=\"red\"><b>Unable to find log path!</b></font>")); if (g_file_get_contents(data->path, &read, NULL, NULL)) { minus_header = strchr(read, '\n'); return process_txt_log(minus_header + 1, read); return process_txt_log(read, NULL); return g_strdup_printf(_("<font color=\"red\"><b>Could not read file: %s</b></font>"), data->path); static int txt_logger_total_size(PurpleLogType type, const char *name, PurpleAccount *account) return purple_log_common_total_sizer(type, name, account, ".txt"); /* The old logger doesn't write logs, only reads them. This is to include * old logs in the log viewer transparently. PurpleStringref *pathref; static GList *old_logger_list(PurpleLogType type, const char *sn, PurpleAccount *account) char *logfile = g_strdup_printf("%s.log", purple_normalize(account, sn)); char *pathstr = g_build_filename(purple_user_dir(), "logs", logfile, NULL); PurpleStringref *pathref = purple_stringref_new(pathstr); time_t log_last_modified; struct old_logger_data *data = NULL; file_fd = g_open(purple_stringref_value(pathref), 0, O_RDONLY); if (file_fd == -1 || (file = fdopen(file_fd, "rb")) == NULL) { purple_debug_error("log", "Failed to open log file \"%s\" for reading: %s\n", purple_stringref_value(pathref), g_strerror(errno)); purple_stringref_unref(pathref); if (fstat(file_fd, &st) == -1) { purple_stringref_unref(pathref); log_last_modified = st.st_mtime; /* Change the .log extension to .idx */ strcpy(pathstr + strlen(pathstr) - 3, "idx"); index_fd = g_open(pathstr, 0, O_RDONLY); if (fstat(index_fd, &st) != 0) { if (st.st_mtime < log_last_modified) purple_debug_warning("log", "Index \"%s\" exists, but is older than the log.\n", pathstr); /* The index file exists and is at least as new as the log, so open it. */ if (!(index = fdopen(index_fd, "rb"))) { purple_debug_error("log", "Failed to open index file \"%s\" for reading: %s\n", pathstr, g_strerror(errno)); /* Fall through so that we'll parse the log file. */ purple_debug_info("log", "Using index: %s\n", pathstr); while (fgets(buf, BUF_LONG, index)) if (sscanf(buf, "%d\t%d\t%lu", &lastoff, &newlen, &idx_time) == 3) log = purple_log_new(PURPLE_LOG_IM, sn, account, NULL, -1, NULL); log->logger = old_logger; log->time = (time_t)idx_time; /* IMPORTANT: Always set all members of struct old_logger_data */ data = g_slice_new(struct old_logger_data); data->pathref = purple_stringref_ref(pathref); list = g_list_prepend(list, log); purple_stringref_unref(pathref); index_tmp = g_strdup_printf("%s.XXXXXX", pathstr); if ((index_fd = g_mkstemp(index_tmp)) == -1) { purple_debug_error("log", "Failed to open index temp file: %s\n", if ((index = fdopen(index_fd, "wb")) == NULL) purple_debug_error("log", "Failed to fdopen() index temp file: %s\n", while (fgets(buf, BUF_LONG, file)) { if (strstr(buf, "---- New C") != NULL) { char *temp = strchr(buf, '@'); if (temp == NULL || strlen(temp) < 2) length = strcspn(temp, "-"); if (length > 31) length = 31; newlen = offset - lastoff - length; if(strstr(buf, "----</H3><BR>")) { sizeof("<HR><BR><H3 Align=Center> ---- New Conversation @ ") + sizeof("----</H3><BR>") - 2; sizeof("---- New Conversation @ ") + sizeof("----") - 2; log = purple_log_new(PURPLE_LOG_IM, sn, account, NULL, -1, NULL); log->logger = old_logger; /* IMPORTANT: Always set all members of struct old_logger_data */ data = g_slice_new(struct old_logger_data); data->pathref = purple_stringref_ref(pathref); list = g_list_prepend(list, log); fprintf(index, "%d\t%d\t%lu\n", data->offset, data->length, (unsigned long)log->time); g_snprintf(convostart, length, "%s", temp); memset(&tm, 0, sizeof(tm)); if (sscanf(convostart, "%*s %3s %d %d:%d:%d %d", month, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &tm.tm_year) != 6) purple_debug_warning("log", "invalid date format\n"); /* Ugly hack, in case current locale is not English */ if (purple_strequal(month, "Jan")) { } else if (purple_strequal(month, "Feb")) { } else if (purple_strequal(month, "Mar")) { } else if (purple_strequal(month, "Apr")) { } else if (purple_strequal(month, "May")) { } else if (purple_strequal(month, "Jun")) { } else if (purple_strequal(month, "Jul")) { } else if (purple_strequal(month, "Aug")) { } else if (purple_strequal(month, "Sep")) { } else if (purple_strequal(month, "Oct")) { } else if (purple_strequal(month, "Nov")) { } else if (purple_strequal(month, "Dec")) { if ((newlen = ftell(file) - lastoff) != 0) { log = purple_log_new(PURPLE_LOG_IM, sn, account, NULL, -1, NULL); log->logger = old_logger; /* IMPORTANT: Always set all members of struct old_logger_data */ data = g_slice_new(struct old_logger_data); data->pathref = purple_stringref_ref(pathref); list = g_list_prepend(list, log); fprintf(index, "%d\t%d\t%lu\n", data->offset, data->length, (unsigned long)log->time); purple_stringref_unref(pathref); g_return_val_if_reached(list); if (g_rename(index_tmp, pathstr)) purple_debug_warning("log", "Failed to rename index temp file \"%s\" to \"%s\": %s\n", index_tmp, pathstr, g_strerror(errno)); purple_debug_info("log", "Built index: %s\n", pathstr); static int old_logger_total_size(PurpleLogType type, const char *name, PurpleAccount *account) char *logfile = g_strdup_printf("%s.log", purple_normalize(account, name)); char *pathstr = g_build_filename(purple_user_dir(), "logs", logfile, NULL); if (g_stat(pathstr, &st)) static char * old_logger_read (PurpleLog *log, PurpleLogReadFlags *flags) struct old_logger_data *data = log->logger_data; const char *path = purple_stringref_value(data->pathref); FILE *file = g_fopen(path, "rb"); g_return_val_if_fail(file, g_strdup("")); read = g_malloc(data->length + 1); if (fseek(file, data->offset, SEEK_SET) != 0) result = fread(read, data->length, 1, file); purple_debug_error("log", "Unable to read from log file: %s\n", path); read[data->length] = '\0'; if (strstr(read, "<BR>")) *flags |= PURPLE_LOG_READ_NO_NEWLINE; return process_txt_log(read, NULL); static int old_logger_size (PurpleLog *log) struct old_logger_data *data = log->logger_data; return data ? data->length : 0; static void old_logger_get_log_sets(PurpleLogSetCallback cb, GHashTable *sets) char *log_path = g_build_filename(purple_user_dir(), "logs", NULL); GDir *log_dir = g_dir_open(log_path, 0, NULL); PurpleBlistNode *gnode, *cnode, *bnode; /* Don't worry about the cast, name will be filled with a dynamically allocated data shortly. */ while ((name = (gchar *)g_dir_read_name(log_dir)) != NULL) { /* Unescape the filename. */ name = g_strdup(purple_unescape_filename(name)); /* Get the (possibly new) length of name. */ /* Make sure we're dealing with a log file. */ if (!purple_strequal(ext, ".log")) { /* IMPORTANT: Always set all members of PurpleLogSet */ set = g_slice_new(PurpleLogSet); /* Chat for .chat at the end of the name to determine the type. */ set->type = PURPLE_LOG_IM; char *tmp = &name[len - 9]; if (purple_strequal(tmp, ".chat")) { set->type = PURPLE_LOG_CHAT; set->name = set->normalized_name = name; /* Search the buddy list to find the account and to determine if this is a buddy. */ for (gnode = purple_blist_get_root(); gnode = purple_blist_node_get_sibling_next(gnode)) if (!PURPLE_BLIST_NODE_IS_GROUP(gnode)) for (cnode = purple_blist_node_get_first_child(gnode); cnode = purple_blist_node_get_sibling_next(cnode)) if (!PURPLE_BLIST_NODE_IS_CONTACT(cnode)) for (bnode = purple_blist_node_get_first_child(cnode); bnode = purple_blist_node_get_sibling_next(bnode)) PurpleBuddy *buddy = (PurpleBuddy *)bnode; if (purple_strequal(purple_buddy_get_name(buddy), name)) { set->account = purple_buddy_get_account(buddy); static void old_logger_finalize(PurpleLog *log) struct old_logger_data *data = log->logger_data; purple_stringref_unref(data->pathref); g_slice_free(struct old_logger_data, data);