libpurple/buddyicon.c

   1 /**
   2  * @file buddyicon.c Buddy Icon API
   3  * @ingroup core
   4  */
   5
   6 /* purple
   7  *
   8  * Purple is the legal property of its developers, whose names are too numerous
   9  * to list here.  Please refer to the COPYRIGHT file distributed with this
  10  * source distribution.
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  25  */
  26 #define _PURPLE_BUDDYICON_C_
  27
  28 #include "internal.h"
  29 #include "buddyicon.h"
  30 #include "conversation.h"
  31 #include "dbus-maybe.h"
  32 #include "debug.h"
  33 #include "imgstore.h"
  34 #include "util.h"
  35
  36 /* NOTE: Instances of this struct are allocated without zeroing the memory, so
  37  * NOTE: be sure to update purple_buddy_icon_new() if you add members. */
  38 struct _PurpleBuddyIcon
  39 {
  40         PurpleAccount *account;    /**< The account the user is on.          */
  41         PurpleStoredImage *img;    /**< The stored image containing
  42                                         the icon data.                       */
  43         char *username;            /**< The username the icon belongs to.    */
  44         char *checksum;            /**< The protocol checksum.               */
  45         int ref_count;             /**< The buddy icon reference count.      */
  46 };
  47
  48 /**
  49  * This is the big grand daddy hash table that contains references to
  50  * everybody's buddy icons.
  51  *
  52  * Key is a PurpleAccount.
  53  * Value is another hash table, usually referred to as "icon_cache."
  54  * For this inner hash table:
  55  *    Key is the username of the buddy whose icon is being stored.
  56  *    Value is the PurpleBuddyIcon for this buddy.
  57  */
  58 static GHashTable *account_cache = NULL;
  59
  60 /**
  61  * This hash table contains a bunch of PurpleStoredImages that are
  62  * shared across all accounts.
  63  *
  64  * Key is the filename for this image as constructed by
  65  * purple_util_get_image_filename().  So it is the base16 encoded
  66  * sha-1 hash plus an appropriate file extension.  For example:
  67  *   "0f4972d17d1e70e751c43c90c948e72efbff9796.gif"
  68  *
  69  * The value is a PurpleStoredImage containing the icon data.  These
  70  * images are reference counted, and when the count reaches 0
  71  * imgstore.c emits the image-deleting signal and we remove the image
  72  * from the hash table (but it might still be saved on disk, if the
  73  * icon is being used by offline accounts or some such).
  74  */
  75 static GHashTable *icon_data_cache = NULL;
  76
  77 /**
  78  * This hash table contains references counts for how many times each
  79  * icon in the ~/.purple/icons/ directory is being used.  It's pretty
  80  * crazy.  It maintains the reference count across sessions, too, so
  81  * if you exit Pidgin then this hash table is reconstructed the next
  82  * time Pidgin starts.
  83  *
  84  * Key is the filename for this image as constructed by
  85  * purple_util_get_image_filename().  So it is the base16 encoded
  86  * sha-1 hash plus an appropriate file extension.  For example:
  87  *   "0f4972d17d1e70e751c43c90c948e72efbff9796.gif"
  88  *
  89  * The value is a GINT_TO_POINTER count of the number of times this
  90  * icon is used.  So if four of your buddies are using an icon, and
  91  * you have the icon set for two of your accounts, then this number
  92  * will be six.  When this reference count reaches 0 the icon will
  93  * be deleted from disk.
  94  */
  95 static GHashTable *icon_file_cache = NULL;
  96
  97 /**
  98  * This hash table is used for both custom buddy icons on PurpleBlistNodes and
  99  * account icons.
 100  */
 101 static GHashTable *pointer_icon_cache = NULL;
 102
 103 static char       *cache_dir     = NULL;
 104
 105 /** "Should icons be cached to disk?" */
 106 static gboolean    icon_caching  = TRUE;
 107
 108 /* For ~/.gaim to ~/.purple migration. */
 109 static char *old_icons_dir = NULL;
 110
 111 static void delete_buddy_icon_settings(PurpleBlistNode *node, const char *setting_name);
 112
 113 /*
 114  * Begin functions for dealing with the on-disk icon cache
 115  */
 116
 117 static void
 118 ref_filename(const char *filename)
 119 {
 120         int refs;
 121
 122         g_return_if_fail(filename != NULL);
 123
 124         refs = GPOINTER_TO_INT(g_hash_table_lookup(icon_file_cache, filename));
 125
 126         g_hash_table_insert(icon_file_cache, g_strdup(filename),
 127                             GINT_TO_POINTER(refs + 1));
 128 }
 129
 130 static void
 131 unref_filename(const char *filename)
 132 {
 133         int refs;
 134
 135         if (filename == NULL)
 136                 return;
 137
 138         refs = GPOINTER_TO_INT(g_hash_table_lookup(icon_file_cache, filename));
 139
 140         if (refs == 1)
 141         {
 142                 g_hash_table_remove(icon_file_cache, filename);
 143         }
 144         else
 145         {
 146                 g_hash_table_insert(icon_file_cache, g_strdup(filename),
 147                                     GINT_TO_POINTER(refs - 1));
 148         }
 149 }
 150
 151 static void
 152 purple_buddy_icon_data_cache(PurpleStoredImage *img)
 153 {
 154         const char *dirname;
 155         char *path;
 156
 157         g_return_if_fail(img != NULL);
 158
 159         if (!purple_buddy_icons_is_caching())
 160                 return;
 161
 162         dirname  = purple_buddy_icons_get_cache_dir();
 163         path = g_build_filename(dirname, purple_imgstore_get_filename(img), NULL);
 164
 165         if (!g_file_test(dirname, G_FILE_TEST_IS_DIR))
 166         {
 167                 purple_debug_info("buddyicon", "Creating icon cache directory.\n");
 168
 169                 if (g_mkdir(dirname, S_IRUSR | S_IWUSR | S_IXUSR) < 0)
 170                 {
 171                         purple_debug_error("buddyicon",
 172                                            "Unable to create directory %s: %s\n",
 173                                            dirname, g_strerror(errno));
 174                 }
 175         }
 176
 177         purple_util_write_data_to_file_absolute(path, purple_imgstore_get_data(img),
 178                                                                                         purple_imgstore_get_size(img));
 179         g_free(path);
 180 }
 181
 182 static void
 183 purple_buddy_icon_data_uncache_file(const char *filename)
 184 {
 185         const char *dirname;
 186         char *path;
 187
 188         g_return_if_fail(filename != NULL);
 189
 190         /* It's possible that there are other references to this icon
 191          * cache file that are not currently loaded into memory. */
 192         if (GPOINTER_TO_INT(g_hash_table_lookup(icon_file_cache, filename)))
 193                 return;
 194
 195         dirname  = purple_buddy_icons_get_cache_dir();
 196         path = g_build_filename(dirname, filename, NULL);
 197
 198         if (g_file_test(path, G_FILE_TEST_EXISTS))
 199         {
 200                 if (g_unlink(path))
 201                 {
 202                         purple_debug_error("buddyicon", "Failed to delete %s: %s\n",
 203                                            path, g_strerror(errno));
 204                 }
 205                 else
 206                 {
 207                         purple_debug_info("buddyicon", "Deleted cache file: %s\n", path);
 208                 }
 209         }
 210
 211         g_free(path);
 212 }
 213
 214 /*
 215  * End functions for dealing with the on-disk icon cache
 216  */
 217
 218 /*
 219  * Begin functions for dealing with the in-memory icon cache
 220  */
 221
 222 static gboolean
 223 value_equals(gpointer key, gpointer value, gpointer user_data)
 224 {
 225         return (value == user_data);
 226 }
 227
 228 static void
 229 image_deleting_cb(const PurpleStoredImage *img, gpointer data)
 230 {
 231         const char *filename = purple_imgstore_get_filename(img);
 232
 233         /* If there's no filename, it can't be one of our images. */
 234         if (filename == NULL)
 235                 return;
 236
 237         if (img == g_hash_table_lookup(icon_data_cache, filename))
 238         {
 239                 purple_buddy_icon_data_uncache_file(filename);
 240                 g_hash_table_remove(icon_data_cache, filename);
 241
 242                 /* We could make this O(1) by using another hash table, but
 243                  * this is probably good enough. */
 244                 g_hash_table_foreach_remove(pointer_icon_cache, value_equals, (gpointer)img);
 245         }
 246 }
 247
 248 static PurpleStoredImage *
 249 purple_buddy_icon_data_new(guchar *icon_data, size_t icon_len, const char *filename)
 250 {
 251         char *file;
 252         PurpleStoredImage *img;
 253
 254         g_return_val_if_fail(icon_data != NULL, NULL);
 255         g_return_val_if_fail(icon_len  > 0,     NULL);
 256
 257         if (filename == NULL)
 258         {
 259                 file = purple_util_get_image_filename(icon_data, icon_len);
 260                 if (file == NULL)
 261                 {
 262                         g_free(icon_data);
 263                         return NULL;
 264                 }
 265         }
 266         else
 267                 file = g_strdup(filename);
 268
 269         if ((img = g_hash_table_lookup(icon_data_cache, file)))
 270         {
 271                 g_free(file);
 272                 g_free(icon_data);
 273                 return purple_imgstore_ref(img);
 274         }
 275
 276         img = purple_imgstore_add(icon_data, icon_len, file);
 277
 278         /* This will take ownership of file and g_free it either now or later. */
 279         g_hash_table_insert(icon_data_cache, file, img);
 280
 281         purple_buddy_icon_data_cache(img);
 282
 283         return img;
 284 }
 285
 286 /*
 287  * End functions for dealing with the in-memory icon cache
 288  */
 289
 290 static PurpleBuddyIcon *
 291 purple_buddy_icon_create(PurpleAccount *account, const char *username)
 292 {
 293         PurpleBuddyIcon *icon;
 294         GHashTable *icon_cache;
 295
 296         /* This does not zero.  See purple_buddy_icon_new() for
 297          * information on which function allocates which member. */
 298         icon = g_slice_new(PurpleBuddyIcon);
 299         PURPLE_DBUS_REGISTER_POINTER(icon, PurpleBuddyIcon);
 300
 301         icon->account = account;
 302         icon->username = g_strdup(username);
 303         icon->checksum = NULL;
 304         icon->ref_count = 1;
 305
 306         icon_cache = g_hash_table_lookup(account_cache, account);
 307
 308         if (icon_cache == NULL)
 309         {
 310                 icon_cache = g_hash_table_new(g_str_hash, g_str_equal);
 311
 312                 g_hash_table_insert(account_cache, account, icon_cache);
 313         }
 314
 315         g_hash_table_insert(icon_cache,
 316                             (char *)purple_buddy_icon_get_username(icon), icon);
 317         return icon;
 318 }
 319
 320 PurpleBuddyIcon *
 321 purple_buddy_icon_new(PurpleAccount *account, const char *username,
 322                       void *icon_data, size_t icon_len,
 323                       const char *checksum)
 324 {
 325         PurpleBuddyIcon *icon;
 326
 327         g_return_val_if_fail(account   != NULL, NULL);
 328         g_return_val_if_fail(username  != NULL, NULL);
 329         g_return_val_if_fail(icon_data != NULL, NULL);
 330         g_return_val_if_fail(icon_len  > 0,    NULL);
 331
 332         /* purple_buddy_icons_find() does allocation, so be
 333          * sure to update it as well when members are added. */
 334         icon = purple_buddy_icons_find(account, username);
 335
 336         /* purple_buddy_icon_create() sets account & username */
 337         if (icon == NULL)
 338                 icon = purple_buddy_icon_create(account, username);
 339
 340         /* purple_buddy_icon_set_data() sets img, but it
 341          * references img first, so we need to initialize it */
 342         icon->img = NULL;
 343         purple_buddy_icon_set_data(icon, icon_data, icon_len, checksum);
 344
 345         return icon;
 346 }
 347
 348 PurpleBuddyIcon *
 349 purple_buddy_icon_ref(PurpleBuddyIcon *icon)
 350 {
 351         g_return_val_if_fail(icon != NULL, NULL);
 352
 353         icon->ref_count++;
 354
 355         return icon;
 356 }
 357
 358 PurpleBuddyIcon *
 359 purple_buddy_icon_unref(PurpleBuddyIcon *icon)
 360 {
 361         if (icon == NULL)
 362                 return NULL;
 363
 364         g_return_val_if_fail(icon->ref_count > 0, NULL);
 365
 366         icon->ref_count--;
 367
 368         if (icon->ref_count == 0)
 369         {
 370                 GHashTable *icon_cache = g_hash_table_lookup(account_cache, purple_buddy_icon_get_account(icon));
 371
 372                 if (icon_cache != NULL)
 373                         g_hash_table_remove(icon_cache, purple_buddy_icon_get_username(icon));
 374
 375                 g_free(icon->username);
 376                 g_free(icon->checksum);
 377                 purple_imgstore_unref(icon->img);
 378
 379                 PURPLE_DBUS_UNREGISTER_POINTER(icon);
 380                 g_slice_free(PurpleBuddyIcon, icon);
 381
 382                 return NULL;
 383         }
 384
 385         return icon;
 386 }
 387
 388 void
 389 purple_buddy_icon_update(PurpleBuddyIcon *icon)
 390 {
 391         PurpleConversation *conv;
 392         PurpleAccount *account;
 393         const char *username;
 394         PurpleBuddyIcon *icon_to_set;
 395         GSList *buddies;
 396
 397         g_return_if_fail(icon != NULL);
 398
 399         account  = purple_buddy_icon_get_account(icon);
 400         username = purple_buddy_icon_get_username(icon);
 401
 402         /* If no data exists (icon->img == NULL), then call the functions below
 403          * with NULL to unset the icon.  They will then unref the icon and it should
 404          * be destroyed.  The only way it wouldn't be destroyed is if someone
 405          * else is holding a reference to it, in which case they can kill
 406          * the icon when they realize it has no data. */
 407         icon_to_set = icon->img ? icon : NULL;
 408
 409         /* Ensure that icon remains valid throughout */
 410         if (icon) purple_buddy_icon_ref(icon);
 411
 412         buddies = purple_find_buddies(account, username);
 413         while (buddies != NULL)
 414         {
 415                 PurpleBuddy *buddy = (PurpleBuddy *)buddies->data;
 416                 char *old_icon;
 417
 418                 purple_buddy_set_icon(buddy, icon_to_set);
 419                 old_icon = g_strdup(purple_blist_node_get_string((PurpleBlistNode *)buddy,
 420                                                                  "buddy_icon"));
 421                 if (icon->img && purple_buddy_icons_is_caching())
 422                 {
 423                         const char *filename = purple_imgstore_get_filename(icon->img);
 424                         purple_blist_node_set_string((PurpleBlistNode *)buddy,
 425                                                      "buddy_icon",
 426                                                      filename);
 427
 428                         if (icon->checksum && *icon->checksum)
 429                         {
 430                                 purple_blist_node_set_string((PurpleBlistNode *)buddy,
 431                                                              "icon_checksum",
 432                                                              icon->checksum);
 433                         }
 434                         else
 435                         {
 436                                 purple_blist_node_remove_setting((PurpleBlistNode *)buddy,
 437                                                                  "icon_checksum");
 438                         }
 439                         ref_filename(filename);
 440                 }
 441                 else if (!icon->img)
 442                 {
 443                         purple_blist_node_remove_setting((PurpleBlistNode *)buddy, "buddy_icon");
 444                         purple_blist_node_remove_setting((PurpleBlistNode *)buddy, "icon_checksum");
 445                 }
 446                 unref_filename(old_icon);
 447                 g_free(old_icon);
 448
 449                 buddies = g_slist_delete_link(buddies, buddies);
 450         }
 451
 452         conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, username, account);
 453
 454         if (conv != NULL)
 455                 purple_conv_im_set_icon(PURPLE_CONV_IM(conv), icon_to_set);
 456
 457         /* icon's refcount was incremented above */
 458         if (icon) purple_buddy_icon_unref(icon);
 459 }
 460
 461 void
 462 purple_buddy_icon_set_data(PurpleBuddyIcon *icon, guchar *data,
 463                            size_t len, const char *checksum)
 464 {
 465         PurpleStoredImage *old_img;
 466
 467         g_return_if_fail(icon != NULL);
 468
 469         old_img = icon->img;
 470         icon->img = NULL;
 471
 472         if (data != NULL)
 473         {
 474                 if (len > 0)
 475                         icon->img = purple_buddy_icon_data_new(data, len, NULL);
 476                 else
 477                         g_free(data);
 478         }
 479
 480         g_free(icon->checksum);
 481         icon->checksum = g_strdup(checksum);
 482
 483         purple_buddy_icon_update(icon);
 484
 485         purple_imgstore_unref(old_img);
 486 }
 487
 488 PurpleAccount *
 489 purple_buddy_icon_get_account(const PurpleBuddyIcon *icon)
 490 {
 491         g_return_val_if_fail(icon != NULL, NULL);
 492
 493         return icon->account;
 494 }
 495
 496 const char *
 497 purple_buddy_icon_get_username(const PurpleBuddyIcon *icon)
 498 {
 499         g_return_val_if_fail(icon != NULL, NULL);
 500
 501         return icon->username;
 502 }
 503
 504 const char *
 505 purple_buddy_icon_get_checksum(const PurpleBuddyIcon *icon)
 506 {
 507         g_return_val_if_fail(icon != NULL, NULL);
 508
 509         return icon->checksum;
 510 }
 511
 512 gconstpointer
 513 purple_buddy_icon_get_data(const PurpleBuddyIcon *icon, size_t *len)
 514 {
 515         g_return_val_if_fail(icon != NULL, NULL);
 516
 517         if (icon->img)
 518         {
 519                 if (len != NULL)
 520                         *len = purple_imgstore_get_size(icon->img);
 521
 522                 return purple_imgstore_get_data(icon->img);
 523         }
 524
 525         return NULL;
 526 }
 527
 528 const char *
 529 purple_buddy_icon_get_extension(const PurpleBuddyIcon *icon)
 530 {
 531         if (icon->img != NULL)
 532                 return purple_imgstore_get_extension(icon->img);
 533
 534         return NULL;
 535 }
 536
 537 void
 538 purple_buddy_icons_set_for_user(PurpleAccount *account, const char *username,
 539                                 void *icon_data, size_t icon_len,
 540                                 const char *checksum)
 541 {
 542         GHashTable *icon_cache;
 543         PurpleBuddyIcon *icon = NULL;
 544
 545         g_return_if_fail(account  != NULL);
 546         g_return_if_fail(username != NULL);
 547
 548         icon_cache = g_hash_table_lookup(account_cache, account);
 549
 550         if (icon_cache != NULL)
 551                 icon = g_hash_table_lookup(icon_cache, username);
 552
 553         if (icon != NULL)
 554                 purple_buddy_icon_set_data(icon, icon_data, icon_len, checksum);
 555         else if (icon_data && icon_len > 0)
 556         {
 557                 PurpleBuddyIcon *icon = purple_buddy_icon_new(account, username, icon_data, icon_len, checksum);
 558
 559                 /* purple_buddy_icon_new() calls
 560                  * purple_buddy_icon_set_data(), which calls
 561                  * purple_buddy_icon_update(), which has the buddy list
 562                  * and conversations take references as appropriate.
 563                  * This function doesn't return icon, so we can't
 564                  * leave a reference dangling. */
 565                 purple_buddy_icon_unref(icon);
 566         }
 567         else
 568         {
 569                 /* If the buddy list or a conversation was holding a
 570                  * reference, we'd have found the icon in the cache.
 571                  * Since we know we're deleting the icon, we only
 572                  * need a subset of purple_buddy_icon_update(). */
 573
 574                 GSList *buddies = purple_find_buddies(account, username);
 575                 while (buddies != NULL)
 576                 {
 577                         PurpleBuddy *buddy = (PurpleBuddy *)buddies->data;
 578
 579                         unref_filename(purple_blist_node_get_string((PurpleBlistNode *)buddy, "buddy_icon"));
 580                         purple_blist_node_remove_setting((PurpleBlistNode *)buddy, "buddy_icon");
 581                         purple_blist_node_remove_setting((PurpleBlistNode *)buddy, "icon_checksum");
 582
 583                         buddies = g_slist_delete_link(buddies, buddies);
 584                 }
 585         }
 586 }
 587
 588 char *purple_buddy_icon_get_full_path(PurpleBuddyIcon *icon)
 589 {
 590         char *path;
 591
 592         g_return_val_if_fail(icon != NULL, NULL);
 593
 594         if (icon->img == NULL)
 595                 return NULL;
 596
 597         path = g_build_filename(purple_buddy_icons_get_cache_dir(),
 598                                 purple_imgstore_get_filename(icon->img), NULL);
 599         if (!g_file_test(path, G_FILE_TEST_EXISTS))
 600         {
 601                 g_free(path);
 602                 return NULL;
 603         }
 604         return path;
 605 }
 606
 607 const char *
 608 purple_buddy_icons_get_checksum_for_user(PurpleBuddy *buddy)
 609 {
 610         return purple_blist_node_get_string((PurpleBlistNode*)buddy,
 611                                             "icon_checksum");
 612 }
 613
 614 static gboolean
 615 read_icon_file(const char *path, guchar **data, size_t *len)
 616 {
 617         GError *err = NULL;
 618
 619         if (!g_file_get_contents(path, (gchar **)data, len, &err))
 620         {
 621                 purple_debug_error("buddyicon", "Error reading %s: %s\n",
 622                                    path, err->message);
 623                 g_error_free(err);
 624
 625                 return FALSE;
 626         }
 627
 628         return TRUE;
 629 }
 630
 631 PurpleBuddyIcon *
 632 purple_buddy_icons_find(PurpleAccount *account, const char *username)
 633 {
 634         GHashTable *icon_cache;
 635         PurpleBuddyIcon *icon = NULL;
 636
 637         g_return_val_if_fail(account  != NULL, NULL);
 638         g_return_val_if_fail(username != NULL, NULL);
 639
 640         icon_cache = g_hash_table_lookup(account_cache, account);
 641
 642         if ((icon_cache == NULL) || ((icon = g_hash_table_lookup(icon_cache, username)) == NULL))
 643         {
 644                 PurpleBuddy *b = purple_find_buddy(account, username);
 645                 const char *protocol_icon_file;
 646                 const char *dirname;
 647                 gboolean caching;
 648                 guchar *data;
 649                 size_t len;
 650
 651                 if (!b)
 652                         return NULL;
 653
 654                 protocol_icon_file = purple_blist_node_get_string((PurpleBlistNode*)b, "buddy_icon");
 655
 656                 if (protocol_icon_file == NULL)
 657                         return NULL;
 658
 659                 dirname = purple_buddy_icons_get_cache_dir();
 660
 661                 caching = purple_buddy_icons_is_caching();
 662                 /* By disabling caching temporarily, we avoid a loop
 663                  * and don't have to add special code through several
 664                  * functions. */
 665                 purple_buddy_icons_set_caching(FALSE);
 666
 667                 if (protocol_icon_file != NULL)
 668                 {
 669                         char *path = g_build_filename(dirname, protocol_icon_file, NULL);
 670                         if (read_icon_file(path, &data, &len))
 671                         {
 672                                 const char *checksum;
 673
 674                                 icon = purple_buddy_icon_create(account, username);
 675                                 icon->img = NULL;
 676                                 checksum = purple_blist_node_get_string((PurpleBlistNode*)b, "icon_checksum");
 677                                 purple_buddy_icon_set_data(icon, data, len, checksum);
 678                         }
 679                         else
 680                                 delete_buddy_icon_settings((PurpleBlistNode*)b, "buddy_icon");
 681
 682                         g_free(path);
 683                 }
 684
 685                 purple_buddy_icons_set_caching(caching);
 686         }
 687
 688         return (icon ? purple_buddy_icon_ref(icon) : NULL);
 689 }
 690
 691 PurpleStoredImage *
 692 purple_buddy_icons_find_account_icon(PurpleAccount *account)
 693 {
 694         PurpleStoredImage *img;
 695         const char *account_icon_file;
 696         const char *dirname;
 697         char *path;
 698         guchar *data;
 699         size_t len;
 700
 701         g_return_val_if_fail(account != NULL, NULL);
 702
 703         if ((img = g_hash_table_lookup(pointer_icon_cache, account)))
 704         {
 705                 return purple_imgstore_ref(img);
 706         }
 707
 708         account_icon_file = purple_account_get_string(account, "buddy_icon", NULL);
 709
 710         if (account_icon_file == NULL)
 711                 return NULL;
 712
 713         dirname = purple_buddy_icons_get_cache_dir();
 714         path = g_build_filename(dirname, account_icon_file, NULL);
 715
 716         if (read_icon_file(path, &data, &len))
 717         {
 718                 g_free(path);
 719                 img = purple_buddy_icon_data_new(data, len, account_icon_file);
 720                 g_hash_table_insert(pointer_icon_cache, account, img);
 721                 return img;
 722         }
 723         g_free(path);
 724
 725         return NULL;
 726 }
 727
 728 PurpleStoredImage *
 729 purple_buddy_icons_set_account_icon(PurpleAccount *account,
 730                                     guchar *icon_data, size_t icon_len)
 731 {
 732         PurpleStoredImage *old_img;
 733         PurpleStoredImage *img = NULL;
 734         char *old_icon;
 735
 736         if (icon_data != NULL && icon_len > 0)
 737         {
 738                 img = purple_buddy_icon_data_new(icon_data, icon_len, NULL);
 739         }
 740
 741         old_icon = g_strdup(purple_account_get_string(account, "buddy_icon", NULL));
 742         if (img && purple_buddy_icons_is_caching())
 743         {
 744                 const char *filename = purple_imgstore_get_filename(img);
 745                 purple_account_set_string(account, "buddy_icon", filename);
 746                 purple_account_set_int(account, "buddy_icon_timestamp", time(NULL));
 747                 ref_filename(filename);
 748         }
 749         else
 750         {
 751                 purple_account_set_string(account, "buddy_icon", NULL);
 752                 purple_account_set_int(account, "buddy_icon_timestamp", 0);
 753         }
 754         unref_filename(old_icon);
 755
 756         old_img = g_hash_table_lookup(pointer_icon_cache, account);
 757
 758         if (img)
 759                 g_hash_table_insert(pointer_icon_cache, account, img);
 760         else
 761                 g_hash_table_remove(pointer_icon_cache, account);
 762
 763         if (purple_account_is_connected(account))
 764         {
 765                 PurpleConnection *gc;
 766                 PurplePluginProtocolInfo *prpl_info;
 767
 768                 gc = purple_account_get_connection(account);
 769                 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc));
 770
 771                 if (prpl_info && prpl_info->set_buddy_icon)
 772                         prpl_info->set_buddy_icon(gc, img);
 773         }
 774
 775         if (old_img)
 776                 purple_imgstore_unref(old_img);
 777         else if (old_icon)
 778         {
 779                 /* The old icon may not have been loaded into memory.  In that
 780                  * case, we'll need to uncache the filename.  The filenames
 781                  * are ref-counted, so this is safe. */
 782                 purple_buddy_icon_data_uncache_file(old_icon);
 783         }
 784         g_free(old_icon);
 785
 786         return img;
 787 }
 788
 789 time_t
 790 purple_buddy_icons_get_account_icon_timestamp(PurpleAccount *account)
 791 {
 792         time_t ret;
 793
 794         g_return_val_if_fail(account != NULL, 0);
 795
 796         ret = purple_account_get_int(account, "buddy_icon_timestamp", 0);
 797
 798         /* This deals with migration cases. */
 799         if (ret == 0 && purple_account_get_string(account, "buddy_icon", NULL) != NULL)
 800         {
 801                 ret = time(NULL);
 802                 purple_account_set_int(account, "buddy_icon_timestamp", ret);
 803         }
 804
 805         return ret;
 806 }
 807
 808 gboolean
 809 purple_buddy_icons_node_has_custom_icon(PurpleBlistNode *node)
 810 {
 811         g_return_val_if_fail(node != NULL, FALSE);
 812
 813         return (purple_blist_node_get_string(node, "custom_buddy_icon") != NULL);
 814 }
 815
 816 PurpleStoredImage *
 817 purple_buddy_icons_node_find_custom_icon(PurpleBlistNode *node)
 818 {
 819         char *path;
 820         size_t len;
 821         guchar *data;
 822         PurpleStoredImage *img;
 823         const char *custom_icon_file, *dirname;
 824
 825         g_return_val_if_fail(node != NULL, NULL);
 826
 827         if ((img = g_hash_table_lookup(pointer_icon_cache, node)))
 828         {
 829                 return purple_imgstore_ref(img);
 830         }
 831
 832         custom_icon_file = purple_blist_node_get_string(node,
 833                                                         "custom_buddy_icon");
 834
 835         if (custom_icon_file == NULL)
 836                 return NULL;
 837
 838         dirname = purple_buddy_icons_get_cache_dir();
 839         path = g_build_filename(dirname, custom_icon_file, NULL);
 840
 841         if (read_icon_file(path, &data, &len))
 842         {
 843                 g_free(path);
 844                 img = purple_buddy_icon_data_new(data, len, custom_icon_file);
 845                 g_hash_table_insert(pointer_icon_cache, node, img);
 846                 return img;
 847         }
 848         g_free(path);
 849
 850         return NULL;
 851 }
 852
 853 PurpleStoredImage *
 854 purple_buddy_icons_node_set_custom_icon(PurpleBlistNode *node,
 855                                         guchar *icon_data, size_t icon_len)
 856 {
 857         char *old_icon;
 858         PurpleStoredImage *old_img;
 859         PurpleStoredImage *img = NULL;
 860
 861         g_return_val_if_fail(node != NULL, NULL);
 862
 863         if (!PURPLE_BLIST_NODE_IS_CONTACT(node) &&
 864             !PURPLE_BLIST_NODE_IS_CHAT(node) &&
 865             !PURPLE_BLIST_NODE_IS_GROUP(node)) {
 866                 return NULL;
 867         }
 868
 869         old_img = g_hash_table_lookup(pointer_icon_cache, node);
 870
 871         if (icon_data != NULL && icon_len > 0) {
 872                 img = purple_buddy_icon_data_new(icon_data, icon_len, NULL);
 873         }
 874
 875         old_icon = g_strdup(purple_blist_node_get_string(node,
 876                                                          "custom_buddy_icon"));
 877         if (img && purple_buddy_icons_is_caching()) {
 878                 const char *filename = purple_imgstore_get_filename(img);
 879                 purple_blist_node_set_string(node, "custom_buddy_icon",
 880                                              filename);
 881                 ref_filename(filename);
 882         } else {
 883                 purple_blist_node_remove_setting(node, "custom_buddy_icon");
 884         }
 885         unref_filename(old_icon);
 886
 887         if (img)
 888                 g_hash_table_insert(pointer_icon_cache, node, img);
 889         else
 890                 g_hash_table_remove(pointer_icon_cache, node);
 891
 892         if (PURPLE_BLIST_NODE_IS_CONTACT(node)) {
 893                 PurpleBlistNode *child;
 894                 for (child = node->child ; child ; child = child->next)
 895                 {
 896                         PurpleBuddy *buddy;
 897                         PurpleConversation *conv;
 898
 899                         if (!PURPLE_BLIST_NODE_IS_BUDDY(child))
 900                                 continue;
 901
 902                         buddy = (PurpleBuddy *)child;
 903
 904                         conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, purple_buddy_get_name(buddy), purple_buddy_get_account(buddy));
 905                         if (conv)
 906                                 purple_conversation_update(conv, PURPLE_CONV_UPDATE_ICON);
 907
 908                         /* Is this call necessary anymore? Can the buddies
 909                          * themselves need updating when the custom buddy
 910                          * icon changes? */
 911                         purple_blist_update_node_icon((PurpleBlistNode*)buddy);
 912                 }
 913         } else if (PURPLE_BLIST_NODE_IS_CHAT(node)) {
 914                 PurpleConversation *conv = NULL;
 915
 916                 conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, purple_chat_get_name((PurpleChat*)node), purple_chat_get_account((PurpleChat*)node));
 917                 if (conv) {
 918                         purple_conversation_update(conv, PURPLE_CONV_UPDATE_ICON);
 919                 }
 920         }
 921
 922         purple_blist_update_node_icon(node);
 923
 924         if (old_img) {
 925                 purple_imgstore_unref(old_img);
 926         } else if (old_icon) {
 927                 /* The old icon may not have been loaded into memory.  In that
 928                  * case, we'll need to uncache the filename.  The filenames
 929                  * are ref-counted, so this is safe. */
 930                 purple_buddy_icon_data_uncache_file(old_icon);
 931         }
 932         g_free(old_icon);
 933
 934         return img;
 935 }
 936
 937 PurpleStoredImage *
 938 purple_buddy_icons_node_set_custom_icon_from_file(PurpleBlistNode *node,
 939                                                   const gchar *filename)
 940 {
 941         size_t len = 0;
 942         guchar *data = NULL;
 943
 944         g_return_val_if_fail(node != NULL, NULL);
 945
 946         if (!PURPLE_BLIST_NODE_IS_CONTACT(node) &&
 947             !PURPLE_BLIST_NODE_IS_CHAT(node) &&
 948             !PURPLE_BLIST_NODE_IS_GROUP(node)) {
 949                 return NULL;
 950         }
 951
 952         if (filename != NULL) {
 953                 if (!read_icon_file(filename, &data, &len)) {
 954                         return NULL;
 955                 }
 956         }
 957
 958         return purple_buddy_icons_node_set_custom_icon(node, data, len);
 959 }
 960
 961 gboolean
 962 purple_buddy_icons_has_custom_icon(PurpleContact *contact)
 963 {
 964         return purple_buddy_icons_node_has_custom_icon((PurpleBlistNode*)contact);
 965 }
 966
 967 PurpleStoredImage *
 968 purple_buddy_icons_find_custom_icon(PurpleContact *contact)
 969 {
 970         return purple_buddy_icons_node_find_custom_icon((PurpleBlistNode*)contact);
 971 }
 972
 973 PurpleStoredImage *
 974 purple_buddy_icons_set_custom_icon(PurpleContact *contact, guchar *icon_data,
 975                                    size_t icon_len)
 976 {
 977         return purple_buddy_icons_node_set_custom_icon((PurpleBlistNode*)contact, icon_data, icon_len);
 978 }
 979
 980 void
 981 _purple_buddy_icon_set_old_icons_dir(const char *dirname)
 982 {
 983         old_icons_dir = g_strdup(dirname);
 984 }
 985
 986 static void
 987 delete_buddy_icon_settings(PurpleBlistNode *node, const char *setting_name)
 988 {
 989         purple_blist_node_remove_setting(node, setting_name);
 990
 991         if (!strcmp(setting_name, "buddy_icon"))
 992         {
 993                 purple_blist_node_remove_setting(node, "avatar_hash");
 994                 purple_blist_node_remove_setting(node, "icon_checksum");
 995         }
 996 }
 997
 998 static void
 999 migrate_buddy_icon(PurpleBlistNode *node, const char *setting_name,
1000                    const char *dirname, const char *filename)
1001 {
1002         char *path;
1003
1004         if (filename[0] != '/')
1005         {
1006                 path = g_build_filename(dirname, filename, NULL);
1007                 if (g_file_test(path, G_FILE_TEST_EXISTS))
1008                 {
1009                         g_free(path);
1010                         return;
1011                 }
1012                 g_free(path);
1013
1014                 path = g_build_filename(old_icons_dir, filename, NULL);
1015         }
1016         else
1017                 path = g_strdup(filename);
1018
1019         if (g_file_test(path, G_FILE_TEST_EXISTS))
1020         {
1021                 guchar *icon_data;
1022                 size_t icon_len;
1023                 FILE *file;
1024                 char *new_filename;
1025
1026                 if (!read_icon_file(path, &icon_data, &icon_len))
1027                 {
1028                         g_free(path);
1029                         delete_buddy_icon_settings(node, setting_name);
1030                         return;
1031                 }
1032
1033                 if (icon_data == NULL || icon_len <= 0)
1034                 {
1035                         /* This really applies to the icon_len check.
1036                          * icon_data should never be NULL if
1037                          * read_icon_file() returns TRUE. */
1038                         purple_debug_error("buddyicon", "Empty buddy icon file: %s\n", path);
1039                         delete_buddy_icon_settings(node, setting_name);
1040                         g_free(path);
1041                         return;
1042                 }
1043
1044                 g_free(path);
1045
1046                 new_filename = purple_util_get_image_filename(icon_data, icon_len);
1047                 if (new_filename == NULL)
1048                 {
1049                         purple_debug_error("buddyicon",
1050                                 "New icon filename is NULL. This should never happen! "
1051                                 "The old filename was: %s\n", path);
1052                         delete_buddy_icon_settings(node, setting_name);
1053                         g_return_if_reached();
1054                 }
1055
1056                 path = g_build_filename(dirname, new_filename, NULL);
1057                 if ((file = g_fopen(path, "wb")) != NULL)
1058                 {
1059                         if (!fwrite(icon_data, icon_len, 1, file))
1060                         {
1061                                 purple_debug_error("buddyicon", "Error writing %s: %s\n",
1062                                                    path, g_strerror(errno));
1063                         }
1064                         else
1065                                 purple_debug_info("buddyicon", "Wrote migrated cache file: %s\n", path);
1066
1067                         fclose(file);
1068                 }
1069                 else
1070                 {
1071                         purple_debug_error("buddyicon", "Unable to create file %s: %s\n",
1072                                            path, g_strerror(errno));
1073                         g_free(new_filename);
1074                         g_free(path);
1075
1076                         delete_buddy_icon_settings(node, setting_name);
1077                         return;
1078                 }
1079                 g_free(path);
1080
1081                 purple_blist_node_set_string(node,
1082                                              setting_name,
1083                                              new_filename);
1084                 ref_filename(new_filename);
1085
1086                 g_free(new_filename);
1087
1088                 if (!strcmp(setting_name, "buddy_icon"))
1089                 {
1090                         const char *hash;
1091
1092                         hash = purple_blist_node_get_string(node, "avatar_hash");
1093                         if (hash != NULL)
1094                         {
1095                                 purple_blist_node_set_string(node, "icon_checksum", hash);
1096                                 purple_blist_node_remove_setting(node, "avatar_hash");
1097                         }
1098                         else
1099                         {
1100                                 PurpleAccount *account = purple_buddy_get_account((PurpleBuddy *)node);
1101                                 const char *prpl_id = purple_account_get_protocol_id(account);
1102
1103                                 if (!strcmp(prpl_id, "prpl-yahoo"))
1104                                 {
1105                                         int checksum = purple_blist_node_get_int(node, "icon_checksum");
1106                                         if (checksum != 0)
1107                                         {
1108                                                 char *checksum_str = g_strdup_printf("%i", checksum);
1109                                                 purple_blist_node_remove_setting(node, "icon_checksum");
1110                                                 purple_blist_node_set_string(node, "icon_checksum", checksum_str);
1111                                                 g_free(checksum_str);
1112                                         }
1113                                 }
1114                         }
1115                 }
1116         }
1117         else
1118         {
1119                 purple_debug_error("buddyicon", "Old icon file doesn't exist: %s\n", path);
1120                 delete_buddy_icon_settings(node, setting_name);
1121                 g_free(path);
1122         }
1123 }
1124
1125 void
1126 _purple_buddy_icons_account_loaded_cb()
1127 {
1128         const char *dirname = purple_buddy_icons_get_cache_dir();
1129         GList *cur;
1130
1131         for (cur = purple_accounts_get_all(); cur != NULL; cur = cur->next)
1132         {
1133                 PurpleAccount *account = cur->data;
1134                 const char *account_icon_file = purple_account_get_string(account, "buddy_icon", NULL);
1135
1136                 if (account_icon_file != NULL)
1137                 {
1138                         char *path = g_build_filename(dirname, account_icon_file, NULL);
1139                         if (!g_file_test(path, G_FILE_TEST_EXISTS))
1140                         {
1141                                 purple_account_set_string(account, "buddy_icon", NULL);
1142                         } else {
1143                                 ref_filename(account_icon_file);
1144                         }
1145                         g_free(path);
1146                 }
1147         }
1148 }
1149
1150 void
1151 _purple_buddy_icons_blist_loaded_cb()
1152 {
1153         PurpleBlistNode *node = purple_blist_get_root();
1154         const char *dirname = purple_buddy_icons_get_cache_dir();
1155
1156         /* Doing this once here saves having to check it inside a loop. */
1157         if (old_icons_dir != NULL)
1158         {
1159                 if (!g_file_test(dirname, G_FILE_TEST_IS_DIR))
1160                 {
1161                         purple_debug_info("buddyicon", "Creating icon cache directory.\n");
1162
1163                         if (g_mkdir(dirname, S_IRUSR | S_IWUSR | S_IXUSR) < 0)
1164                         {
1165                                 purple_debug_error("buddyicon",
1166                                                    "Unable to create directory %s: %s\n",
1167                                                    dirname, g_strerror(errno));
1168                         }
1169                 }
1170         }
1171
1172         while (node != NULL)
1173         {
1174                 if (PURPLE_BLIST_NODE_IS_BUDDY(node))
1175                 {
1176                         const char *filename;
1177
1178                         filename = purple_blist_node_get_string(node, "buddy_icon");
1179                         if (filename != NULL)
1180                         {
1181                                 if (old_icons_dir != NULL)
1182                                 {
1183                                         migrate_buddy_icon(node,
1184                                                            "buddy_icon",
1185                                                            dirname, filename);
1186                                 }
1187                                 else
1188                                 {
1189                                         char *path = g_build_filename(dirname, filename, NULL);
1190                                         if (!g_file_test(path, G_FILE_TEST_EXISTS))
1191                                         {
1192                                                 purple_blist_node_remove_setting(node,
1193                                                                                  "buddy_icon");
1194                                                 purple_blist_node_remove_setting(node,
1195                                                                                  "icon_checksum");
1196                                         }
1197                                         else
1198                                                 ref_filename(filename);
1199                                         g_free(path);
1200                                 }
1201                         }
1202                 }
1203                 else if (PURPLE_BLIST_NODE_IS_CONTACT(node) ||
1204                          PURPLE_BLIST_NODE_IS_CHAT(node) ||
1205                          PURPLE_BLIST_NODE_IS_GROUP(node))
1206                 {
1207                         const char *filename;
1208
1209                         filename = purple_blist_node_get_string(node, "custom_buddy_icon");
1210                         if (filename != NULL)
1211                         {
1212                                 if (old_icons_dir != NULL)
1213                                 {
1214                                         migrate_buddy_icon(node,
1215                                                            "custom_buddy_icon",
1216                                                            dirname, filename);
1217                                 }
1218                                 else
1219                                 {
1220                                         char *path = g_build_filename(dirname, filename, NULL);
1221                                         if (!g_file_test(path, G_FILE_TEST_EXISTS))
1222                                         {
1223                                                 purple_blist_node_remove_setting(node,
1224                                                                                  "custom_buddy_icon");
1225                                         }
1226                                         else
1227                                                 ref_filename(filename);
1228                                         g_free(path);
1229                                 }
1230                         }
1231                 }
1232                 node = purple_blist_node_next(node, TRUE);
1233         }
1234 }
1235
1236 void
1237 purple_buddy_icons_set_caching(gboolean caching)
1238 {
1239         icon_caching = caching;
1240 }
1241
1242 gboolean
1243 purple_buddy_icons_is_caching(void)
1244 {
1245         return icon_caching;
1246 }
1247
1248 void
1249 purple_buddy_icons_set_cache_dir(const char *dir)
1250 {
1251         g_return_if_fail(dir != NULL);
1252
1253         g_free(cache_dir);
1254         cache_dir = g_strdup(dir);
1255 }
1256
1257 const char *
1258 purple_buddy_icons_get_cache_dir(void)
1259 {
1260         return cache_dir;
1261 }
1262
1263 void *
1264 purple_buddy_icons_get_handle()
1265 {
1266         static int handle;
1267
1268         return &handle;
1269 }
1270
1271 void
1272 purple_buddy_icons_init()
1273 {
1274         account_cache = g_hash_table_new_full(
1275                 g_direct_hash, g_direct_equal,
1276                 NULL, (GFreeFunc)g_hash_table_destroy);
1277
1278         icon_data_cache = g_hash_table_new_full(g_str_hash, g_str_equal,
1279                                                 g_free, NULL);
1280         icon_file_cache = g_hash_table_new_full(g_str_hash, g_str_equal,
1281                                                 g_free, NULL);
1282         pointer_icon_cache = g_hash_table_new(g_direct_hash, g_direct_equal);
1283
1284     if (!cache_dir)
1285         cache_dir = g_build_filename(purple_user_dir(), "icons", NULL);
1286
1287         purple_signal_connect(purple_imgstore_get_handle(), "image-deleting",
1288                               purple_buddy_icons_get_handle(),
1289                               G_CALLBACK(image_deleting_cb), NULL);
1290 }
1291
1292 void
1293 purple_buddy_icons_uninit()
1294 {
1295         purple_signals_disconnect_by_handle(purple_buddy_icons_get_handle());
1296
1297         g_hash_table_destroy(account_cache);
1298         g_hash_table_destroy(icon_data_cache);
1299         g_hash_table_destroy(icon_file_cache);
1300         g_hash_table_destroy(pointer_icon_cache);
1301         g_free(old_icons_dir);
1302 }
1303
1304 void purple_buddy_icon_get_scale_size(PurpleBuddyIconSpec *spec, int *width, int *height)
1305 {
1306         int new_width, new_height;
1307
1308         new_width = *width;
1309         new_height = *height;
1310
1311         if (*width < spec->min_width)
1312                 new_width = spec->min_width;
1313         else if (*width > spec->max_width)
1314                 new_width = spec->max_width;
1315
1316         if (*height < spec->min_height)
1317                 new_height = spec->min_height;
1318         else if (*height > spec->max_height)
1319                 new_height = spec->max_height;
1320
1321         /* preserve aspect ratio */
1322         if ((double)*height * (double)new_width >
1323                 (double)*width * (double)new_height) {
1324                         new_width = 0.5 + (double)*width * (double)new_height / (double)*height;
1325         } else {
1326                         new_height = 0.5 + (double)*height * (double)new_width / (double)*width;
1327         }
1328
1329         *width = new_width;
1330         *height = new_height;
1331 }