src/plugins/libravatar/libravatar.c

   1 /*
   2  * Claws Mail -- a GTK based, lightweight, and fast e-mail client
   3  * Copyright (C) 2014-2015 Ricardo Mones and the Claws Mail Team
   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 #ifdef HAVE_CONFIG_H
  20 #  include "config.h"
  21 #include "claws-features.h"
  22 #endif
  23
  24 #include <glib.h>
  25 #include <glib/gi18n.h>
  26
  27 #include <curl/curl.h>
  28
  29 #include "version.h"
  30 #include "libravatar.h"
  31 #include "libravatar_prefs.h"
  32 #include "libravatar_cache.h"
  33 #include "libravatar_image.h"
  34 #include "libravatar_missing.h"
  35 #include "libravatar_federation.h"
  36 #include "prefs_common.h"
  37 #include "procheader.h"
  38 #include "procmsg.h"
  39 #include "utils.h"
  40 #include "md5.h"
  41
  42 /* indexes of keys are default_mode - 10 if applicable */
  43 static const char *def_mode[] = {
  44         "404",  /* not used, only useful in web pages */
  45         "mm",
  46         "identicon",
  47         "monsterid",
  48         "wavatar",
  49         "retro",
  50         "robohash",
  51         "pagan"
  52 };
  53
  54 static gulong update_hook_id = HOOK_NONE;
  55 static gulong render_hook_id = HOOK_NONE;
  56 static gchar *cache_dir = NULL; /* dir-separator terminated */
  57
  58 static gboolean libravatar_header_update_hook(gpointer source, gpointer data)
  59 {
  60         AvatarCaptureData *acd = (AvatarCaptureData *)source;
  61
  62         debug_print("libravatar avatar_header_update invoked\n");
  63
  64         if (!strcmp(acd->header, "From:")) {
  65                 gchar *a, *lower;
  66
  67                 a = g_strdup(acd->content);
  68                 extract_address(a);
  69
  70                 /* string to lower */
  71                 for (lower = a; *lower; lower++)
  72                         *lower = g_ascii_tolower(*lower);
  73
  74                 debug_print("libravatar added '%s'\n", a);
  75                 procmsg_msginfo_add_avatar(acd->msginfo, AVATAR_LIBRAVATAR, a);
  76                 g_free(a);
  77         }
  78
  79         return FALSE; /* keep getting */
  80 }
  81
  82 static gchar *federated_base_url_from_address(const gchar *address)
  83 {
  84 #if defined USE_GNUTLS
  85         gchar *base_url = NULL;
  86
  87         if (!libravatarprefs.allow_federated) {
  88                 debug_print("federated domains disabled by configuration\n");
  89                 goto default_url;
  90         }
  91
  92         base_url = federated_url_for_address(address);
  93         if (base_url != NULL) {
  94                 return base_url;
  95         }
  96
  97 default_url:
  98 #endif
  99         return g_strdup(libravatarprefs.base_url);
 100 }
 101
 102 static GtkWidget *image_widget_from_pixbuf(GdkPixbuf *picture)
 103 {
 104         GtkWidget *image = NULL;
 105
 106         if (picture) {
 107                 image = gtk_image_new_from_pixbuf(picture);
 108                 g_object_unref(picture);
 109         } else
 110                 g_warning("null picture returns null widget");
 111
 112         return image;
 113 }
 114
 115 static GtkWidget *image_widget_from_filename(const gchar *filename)
 116 {
 117         GdkPixbuf *picture = NULL;
 118         GError *error = NULL;
 119         gint w, h;
 120
 121         gdk_pixbuf_get_file_info(filename, &w, &h);
 122
 123         if (w != AVATAR_SIZE || h != AVATAR_SIZE)
 124                 /* server can provide a different size from the requested in URL */
 125                 picture = gdk_pixbuf_new_from_file_at_scale(
 126                                 filename, AVATAR_SIZE, AVATAR_SIZE, TRUE, &error);
 127         else    /* exact size */
 128                 picture = gdk_pixbuf_new_from_file(filename, &error);
 129
 130         if (error != NULL) {
 131                 g_warning("failed to load image '%s': %s", filename, error->message);
 132                 g_error_free(error);
 133                 return NULL;
 134         }
 135
 136         return image_widget_from_pixbuf(picture);
 137 }
 138
 139 static gchar *cache_name_for_md5(const gchar *md5)
 140 {
 141         if (libravatarprefs.default_mode >= DEF_MODE_MM
 142                         && libravatarprefs.default_mode <= DEF_MODE_RETRO) {
 143                 /* cache dir for generated avatars */
 144                 return g_strconcat(cache_dir, def_mode[libravatarprefs.default_mode - 10],
 145                                    G_DIR_SEPARATOR_S, md5, NULL);
 146         }
 147         /* default cache dir */
 148         return g_strconcat(cache_dir, md5, NULL);
 149 }
 150
 151 static GtkWidget *image_widget_from_url(const gchar *url, const gchar *md5)
 152 {
 153         GtkWidget *image = NULL;
 154         AvatarImageFetch aif;
 155
 156         aif.url = url;
 157         aif.md5 = md5;
 158         aif.filename = cache_name_for_md5(md5);
 159         libravatar_image_fetch(&aif);
 160         if (aif.pixbuf) {
 161                 image = gtk_image_new_from_pixbuf(aif.pixbuf);
 162                 g_object_unref(aif.pixbuf);
 163         }
 164         g_free(aif.filename);
 165
 166         return image;
 167 }
 168
 169 static gboolean is_recent_enough(const gchar *filename)
 170 {
 171         GStatBuf s;
 172         time_t t;
 173
 174         if (libravatarprefs.cache_icons) {
 175                 t = time(NULL);
 176                 if (t != (time_t)-1 && !g_stat(filename, &s)) {
 177                         if (t - s.st_ctime <= libravatarprefs.cache_interval * 3600)
 178                                 return TRUE;
 179                 }
 180         }
 181
 182         return FALSE; /* re-download */
 183 }
 184
 185 static GtkWidget *image_widget_from_cached_md5(const gchar *md5)
 186 {
 187         GtkWidget *image = NULL;
 188         gchar *filename;
 189
 190         filename = cache_name_for_md5(md5);
 191         if (is_file_exist(filename) && is_recent_enough(filename)) {
 192                 debug_print("found cached image for %s\n", md5);
 193                 image = image_widget_from_filename(filename);
 194         }
 195         g_free(filename);
 196
 197         return image;
 198 }
 199
 200 static gchar *libravatar_url_for_md5(const gchar *base, const gchar *md5)
 201 {
 202         if (libravatarprefs.default_mode >= DEF_MODE_404) {
 203                 return g_strdup_printf("%s/%s?s=%u&d=%s",
 204                                 base, md5, AVATAR_SIZE,
 205                                 def_mode[libravatarprefs.default_mode - 10]);
 206         } else if (libravatarprefs.default_mode == DEF_MODE_URL) {
 207                 gchar *escaped = g_uri_escape_string(libravatarprefs.default_mode_url, "/", TRUE);
 208                 gchar *url = g_strdup_printf("%s/%s?s=%u&d=%s",
 209                                 base, md5, AVATAR_SIZE, escaped);
 210                 g_free(escaped);
 211                 return url;
 212         } else if (libravatarprefs.default_mode == DEF_MODE_NONE) {
 213                 return g_strdup_printf("%s/%s?s=%u&d=404",
 214                                 base, md5, AVATAR_SIZE);
 215         }
 216
 217         g_warning("invalid libravatar default mode: %d", libravatarprefs.default_mode);
 218         return NULL;
 219 }
 220
 221 static gboolean libravatar_image_render_hook(gpointer source, gpointer data)
 222 {
 223         AvatarRender *ar = (AvatarRender *)source;
 224         GtkWidget *image = NULL;
 225         gchar *a = NULL, *url = NULL;
 226         gchar md5sum[33];
 227
 228         debug_print("libravatar avatar_image_render invoked\n");
 229
 230         a = procmsg_msginfo_get_avatar(ar->full_msginfo, AVATAR_LIBRAVATAR);
 231         if (a != NULL) {
 232                 gchar *base;
 233
 234                 md5_hex_digest(md5sum, a);
 235                 /* try missing cache */
 236                 if (is_missing_md5(libravatarmisses, md5sum)) {
 237                         return FALSE;
 238                 }
 239                 /* try disk cache */
 240                 image = image_widget_from_cached_md5(md5sum);
 241                 if (image != NULL) {
 242                         if (ar->image) /* previous plugin set one */
 243                                 gtk_widget_destroy(ar->image);
 244                         ar->image = image;
 245                         ar->type  = AVATAR_LIBRAVATAR;
 246                         return FALSE;
 247                 }
 248                 /* not cached copy: try network */
 249                 if (prefs_common_get_prefs()->work_offline) {
 250                         debug_print("working off-line: libravatar network retrieval skipped\n");
 251                         return FALSE;
 252                 }
 253                 base = federated_base_url_from_address(a);
 254                 url = libravatar_url_for_md5(base, md5sum);
 255                 if (url != NULL) {
 256                         image = image_widget_from_url(url, md5sum);
 257                         g_free(url);
 258                         if (image != NULL) {
 259                                 if (ar->image) /* previous plugin set one */
 260                                         gtk_widget_destroy(ar->image);
 261                                 ar->image = image;
 262                                 ar->type  = AVATAR_LIBRAVATAR;
 263                         }
 264                 }
 265                 g_free(base);
 266
 267                 return TRUE;
 268         }
 269
 270         return FALSE; /* keep rendering */
 271 }
 272
 273 static gint cache_dir_init()
 274 {
 275         cache_dir = libravatar_cache_init(def_mode, DEF_MODE_MM - 10, DEF_MODE_RETRO - 10);
 276         cm_return_val_if_fail (cache_dir != NULL, -1);
 277
 278         return 0;
 279 }
 280
 281 static gint missing_cache_init()
 282 {
 283         gchar *cache_file = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
 284                                         LIBRAVATAR_CACHE_DIR, G_DIR_SEPARATOR_S,
 285                                         LIBRAVATAR_MISSING_FILE, NULL);
 286
 287         libravatarmisses = missing_load_from_file(cache_file);
 288         g_free(cache_file);
 289
 290         if (libravatarmisses == NULL)
 291                 return -1;
 292
 293         return 0;
 294 }
 295
 296 static void missing_cache_done()
 297 {
 298         gchar *cache_file;
 299
 300         if (libravatarmisses != NULL) {
 301                 cache_file = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
 302                                         LIBRAVATAR_CACHE_DIR, G_DIR_SEPARATOR_S,
 303                                         LIBRAVATAR_MISSING_FILE, NULL);
 304                 missing_save_to_file(libravatarmisses, cache_file);
 305                 g_free(cache_file);
 306                 g_hash_table_destroy(libravatarmisses);
 307         }
 308 }
 309
 310 static void unregister_hooks()
 311 {
 312         if (render_hook_id != HOOK_NONE) {
 313                 hooks_unregister_hook(AVATAR_IMAGE_RENDER_HOOKLIST,
 314                                       render_hook_id);
 315                 render_hook_id = HOOK_NONE;
 316         }
 317         if (update_hook_id != HOOK_NONE) {
 318                 hooks_unregister_hook(AVATAR_HEADER_UPDATE_HOOKLIST,
 319                                       update_hook_id);
 320                 update_hook_id = HOOK_NONE;
 321         }
 322 }
 323
 324 /**
 325  * Initialize plugin.
 326  *
 327  * @param error  For storing the returned error message.
 328  *
 329  * @return 0 if initialization succeeds, -1 on failure.
 330  */
 331 gint plugin_init(gchar **error)
 332 {
 333         if (!check_plugin_version(MAKE_NUMERIC_VERSION(3,9,3,29),
 334                                   VERSION_NUMERIC, _("Libravatar"), error))
 335                 return -1;
 336         /* get info from headers */
 337         update_hook_id = hooks_register_hook(AVATAR_HEADER_UPDATE_HOOKLIST,
 338                                              libravatar_header_update_hook,
 339                                              NULL);
 340         if (update_hook_id == HOOK_NONE) {
 341                 *error = g_strdup(_("Failed to register avatar header update hook"));
 342                 return -1;
 343         }
 344         /* get image for displaying */
 345         render_hook_id = hooks_register_hook(AVATAR_IMAGE_RENDER_HOOKLIST,
 346                                              libravatar_image_render_hook,
 347                                              NULL);
 348         if (render_hook_id == HOOK_NONE) {
 349                 unregister_hooks();
 350                 *error = g_strdup(_("Failed to register avatar image render hook"));
 351                 return -1;
 352         }
 353         /* cache dir */
 354         if (cache_dir_init() == -1) {
 355                 unregister_hooks();
 356                 *error = g_strdup(_("Failed to create avatar image cache directory"));
 357                 return -1;
 358         }
 359         /* preferences page */
 360         libravatar_prefs_init();
 361         /* curl library */
 362         curl_global_init(CURL_GLOBAL_DEFAULT);
 363         /* missing cache */
 364         if (missing_cache_init() == -1) {
 365                 unregister_hooks();
 366                 *error = g_strdup(_("Failed to load missing items cache"));
 367                 return -1;
 368         }
 369         debug_print("Libravatar plugin loaded\n");
 370
 371         return 0;
 372 }
 373
 374 /**
 375  * Destructor for the plugin.
 376  * Unregister the callback function and frees matcher.
 377  *
 378  * @return Always TRUE.
 379  */
 380 gboolean plugin_done(void)
 381 {
 382         unregister_hooks();
 383         libravatar_prefs_done();
 384         missing_cache_done();
 385         if (cache_dir != NULL)
 386                 g_free(cache_dir);
 387         debug_print("Libravatar plugin unloaded\n");
 388
 389         return TRUE;
 390 }
 391
 392 /**
 393  * Get the name of the plugin.
 394  *
 395  * @return The plugin's name, maybe translated.
 396  */
 397 const gchar *plugin_name(void)
 398 {
 399         return _("Libravatar");
 400 }
 401
 402 /**
 403  * Get the description of the plugin.
 404  *
 405  * @return The plugin's description, maybe translated.
 406  */
 407 const gchar *plugin_desc(void)
 408 {
 409         return _("Display libravatar profiles' images for mail messages. More\n"
 410                  "info about libravatar at http://www.libravatar.org/. If you have\n"
 411                  "a gravatar.com profile but not a libravatar one, those will also\n"
 412                  "be retrieved (when redirections are allowed in plugin config).\n"
 413                  "Plugin config page is available from main window at:\n"
 414                  "/Configuration/Preferences/Plugins/Libravatar.\n\n"
 415                  "This plugin uses libcurl to retrieve images, so if you're behind a\n"
 416                  "proxy please refer to curl(1) manpage for details on 'http_proxy'\n"
 417                  "configuration. More details about this and others on README file.\n\n"
 418                  "Feedback to <ricardo@mones.org> is welcome.\n");
 419 }
 420
 421 /**
 422  * Get the kind of plugin.
 423  *
 424  * @return The "GTK3" constant.
 425  */
 426 const gchar *plugin_type(void)
 427 {
 428         return "GTK3";
 429 }
 430
 431 /**
 432  * Get the license acronym the plugin is released under.
 433  *
 434  * @return The "GPL3+" constant.
 435  */
 436 const gchar *plugin_licence(void)
 437 {
 438         return "GPL3+";
 439 }
 440
 441 /**
 442  * Get the version of the plugin.
 443  *
 444  * @return The current version string.
 445  */
 446 const gchar *plugin_version(void)
 447 {
 448         return VERSION;
 449 }
 450
 451 /**
 452  * Get the features implemented by the plugin.
 453  *
 454  * @return A constant PluginFeature structure with the features.
 455  */
 456 struct PluginFeature *plugin_provides(void)
 457 {
 458         static struct PluginFeature features[] =
 459                 { {PLUGIN_OTHER, N_("Libravatar")},
 460                   {PLUGIN_NOTHING, NULL}};
 461
 462         return features;
 463 }
 464