pidgin/pidgin
Clone
Summary
Browse
Changes
Graph
Make user interfaces setup the default history adapter.
2021-10-18, Gary Kramlich
755e1554051c
Make user interfaces setup the default history adapter.
This helps avoid some issues with the unit tests as well as gives us more
flexibility in the future.
Testing Done:
Ran the unit tests without issue. Ran Pidgin 3 with no existing config directory and verified that `history.db` was created properly.
Reviewed at https://reviews.imfreedom.org/r/1033/
/* purple
*
* 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
* source distribution.
*
* 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
*/
#include
"internal.h"
#include
"buddyicon.h"
#include
"debug.h"
#include
"image.h"
#include
"purpleconversation.h"
#include
"purpleconversationmanager.h"
#include
"purpleprivate.h"
#include
"purpleprotocolserver.h"
#include
"util.h"
/* NOTE: Instances of this struct are allocated without zeroing the memory, so
* NOTE: be sure to update purple_buddy_icon_new() if you add members. */
struct
_PurpleBuddyIcon
{
PurpleAccount
*
account
;
/* The account the user is on. */
PurpleImage
*
img
;
/* The image containing
the icon data. */
char
*
username
;
/* The username the icon belongs to. */
char
*
checksum
;
/* The protocol checksum. */
unsigned
int
ref_count
;
/* The buddy icon reference count. */
};
/*
* This is the big grand daddy hash table that contains references to
* everybody's buddy icons.
*
* Key is a PurpleAccount.
* Value is another hash table, usually referred to as "icon_cache."
* For this inner hash table:
* Key is the username of the buddy whose icon is being stored.
* Value is the PurpleBuddyIcon for this buddy.
*/
static
GHashTable
*
account_cache
=
NULL
;
/*
* This hash table contains a bunch of PurpleImages that are
* shared across all accounts.
*
* Key is the filename for this image as constructed by
* purple_image_generate_filename(). So it is the base16 encoded
* sha-1 hash plus an appropriate file extension. For example:
* "0f4972d17d1e70e751c43c90c948e72efbff9796.gif"
*
* The value is a PurpleImage containing the icon data. These images are
* reference counted, and when the count reaches 0 we remove the image from
* the hash table (but it might still be saved on disk, if the icon is being
* used by offline accounts or some such).
*/
static
GHashTable
*
icon_data_cache
=
NULL
;
/*
* This hash table contains reference counts for how many times each
* icon in the ~/.purple/icons/ directory is being used. It's pretty
* crazy. It maintains the reference count across sessions, too, so
* if you exit Pidgin then this hash table is reconstructed the next
* time Pidgin starts.
*
* Key is the filename for this image as constructed by
* purple_image_generate_filename(). So it is the base16 encoded
* sha-1 hash plus an appropriate file extension. For example:
* "0f4972d17d1e70e751c43c90c948e72efbff9796.gif"
*
* The value is a GINT_TO_POINTER count of the number of times this
* icon is used. So if four of your buddies are using an icon, and
* you have the icon set for two of your accounts, then this number
* will be six. When this reference count reaches 0 the icon will
* be deleted from disk.
*/
static
GHashTable
*
icon_file_cache
=
NULL
;
/*
* This hash table is used for both custom buddy icons on PurpleBlistNodes and
* account icons.
*/
static
GHashTable
*
pointer_icon_cache
=
NULL
;
static
char
*
cache_dir
=
NULL
;
/* "Should icons be cached to disk?" */
static
gboolean
icon_caching
=
TRUE
;
static
void
delete_buddy_icon_settings
(
PurpleBlistNode
*
node
,
const
char
*
setting_name
);
/*
* Begin functions for dealing with the on-disk icon cache
*/
static
void
ref_filename
(
const
char
*
filename
)
{
int
refs
;
g_return_if_fail
(
filename
!=
NULL
);
refs
=
GPOINTER_TO_INT
(
g_hash_table_lookup
(
icon_file_cache
,
filename
));
g_hash_table_insert
(
icon_file_cache
,
g_strdup
(
filename
),
GINT_TO_POINTER
(
refs
+
1
));
}
static
void
unref_filename
(
const
char
*
filename
)
{
int
refs
;
if
(
filename
==
NULL
)
return
;
refs
=
GPOINTER_TO_INT
(
g_hash_table_lookup
(
icon_file_cache
,
filename
));
if
(
refs
==
1
)
{
g_hash_table_remove
(
icon_file_cache
,
filename
);
}
else
{
g_hash_table_insert
(
icon_file_cache
,
g_strdup
(
filename
),
GINT_TO_POINTER
(
refs
-
1
));
}
}
static
const
gchar
*
image_get_filename
(
PurpleImage
*
img
)
{
return
g_object_get_data
(
G_OBJECT
(
img
),
"purple-buddyicon-filename"
);
}
static
void
purple_buddy_icon_data_cache
(
PurpleImage
*
img
)
{
const
gchar
*
dirname
,
*
filename
;
gchar
*
path
;
g_return_if_fail
(
PURPLE_IS_IMAGE
(
img
));
if
(
!
purple_buddy_icons_is_caching
())
return
;
dirname
=
purple_buddy_icons_get_cache_dir
();
filename
=
image_get_filename
(
img
);
g_return_if_fail
(
filename
!=
NULL
);
if
(
!
g_file_test
(
dirname
,
G_FILE_TEST_IS_DIR
))
{
purple_debug_info
(
"buddyicon"
,
"creating icon cache directory"
);
if
(
g_mkdir
(
dirname
,
S_IRUSR
|
S_IWUSR
|
S_IXUSR
)
<
0
)
{
purple_debug_error
(
"buddyicon"
,
"unable to create directory %s: %s"
,
dirname
,
g_strerror
(
errno
));
return
;
}
}
path
=
g_build_filename
(
dirname
,
filename
,
NULL
);
if
(
!
purple_image_save
(
img
,
path
))
purple_debug_error
(
"buddyicon"
,
"failed to save icon %s"
,
path
);
g_free
(
path
);
}
static
void
purple_buddy_icon_data_uncache_file
(
const
char
*
filename
)
{
const
char
*
dirname
;
char
*
path
;
g_return_if_fail
(
filename
!=
NULL
);
/* It's possible that there are other references to this icon
* cache file that are not currently loaded into memory. */
if
(
GPOINTER_TO_INT
(
g_hash_table_lookup
(
icon_file_cache
,
filename
)))
return
;
dirname
=
purple_buddy_icons_get_cache_dir
();
path
=
g_build_filename
(
dirname
,
filename
,
NULL
);
if
(
g_file_test
(
path
,
G_FILE_TEST_EXISTS
))
{
if
(
g_unlink
(
path
))
{
purple_debug_error
(
"buddyicon"
,
"Failed to delete %s: %s
\n
"
,
path
,
g_strerror
(
errno
));
}
else
{
purple_debug_info
(
"buddyicon"
,
"Deleted cache file: %s
\n
"
,
path
);
}
}
g_free
(
path
);
}
/*
* End functions for dealing with the on-disk icon cache
*/
/*
* Begin functions for dealing with the in-memory icon cache
*/
static
gboolean
value_equals
(
gpointer
key
,
gpointer
value
,
gpointer
user_data
)
{
return
(
value
==
user_data
);
}
static
void
image_deleting_cb
(
gpointer
_filename
)
{
PurpleImage
*
img
;
gchar
*
filename
=
_filename
;
img
=
g_hash_table_lookup
(
icon_data_cache
,
filename
);
purple_buddy_icon_data_uncache_file
(
filename
);
g_hash_table_remove
(
icon_data_cache
,
filename
);
/* We could make this O(1) by using another hash table, but
* this is probably good enough. */
g_hash_table_foreach_remove
(
pointer_icon_cache
,
value_equals
,
(
gpointer
)
img
);
g_free
(
filename
);
}
static
PurpleImage
*
purple_buddy_icon_data_new
(
guchar
*
icon_data
,
size_t
icon_len
)
{
PurpleImage
*
newimg
,
*
oldimg
;
const
gchar
*
filename
;
g_return_val_if_fail
(
icon_data
!=
NULL
,
NULL
);
g_return_val_if_fail
(
icon_len
>
0
,
NULL
);
newimg
=
purple_image_new_from_data
(
icon_data
,
icon_len
);
filename
=
purple_image_generate_filename
(
newimg
);
/* TODO: Why is this function called for buddies without icons? If this is
* intended, should the filename be null?
*/
if
(
filename
!=
NULL
)
{
oldimg
=
g_hash_table_lookup
(
icon_data_cache
,
filename
);
if
(
oldimg
)
{
g_warn_if_fail
(
PURPLE_IS_IMAGE
(
oldimg
));
g_object_unref
(
newimg
);
g_object_ref
(
oldimg
);
return
oldimg
;
}
/* This will take ownership of file and free it as needed */
g_hash_table_insert
(
icon_data_cache
,
g_strdup
(
filename
),
newimg
);
}
g_object_set_data_full
(
G_OBJECT
(
newimg
),
"purple-buddyicon-filename"
,
g_strdup
(
filename
),
image_deleting_cb
);
purple_buddy_icon_data_cache
(
newimg
);
return
newimg
;
}
/*
* End functions for dealing with the in-memory icon cache
*/
static
PurpleBuddyIcon
*
purple_buddy_icon_create
(
PurpleAccount
*
account
,
const
char
*
username
)
{
PurpleBuddyIcon
*
icon
;
GHashTable
*
icon_cache
;
/* This does not zero. See purple_buddy_icon_new() for
* information on which function allocates which member. */
icon
=
g_slice_new
(
PurpleBuddyIcon
);
icon
->
account
=
account
;
icon
->
username
=
g_strdup
(
username
);
icon
->
checksum
=
NULL
;
icon
->
ref_count
=
1
;
icon_cache
=
g_hash_table_lookup
(
account_cache
,
account
);
if
(
icon_cache
==
NULL
)
{
icon_cache
=
g_hash_table_new
(
g_str_hash
,
g_str_equal
);
g_hash_table_insert
(
account_cache
,
account
,
icon_cache
);
}
g_hash_table_insert
(
icon_cache
,
(
char
*
)
purple_buddy_icon_get_username
(
icon
),
icon
);
return
icon
;
}
PurpleBuddyIcon
*
purple_buddy_icon_new
(
PurpleAccount
*
account
,
const
char
*
username
,
void
*
icon_data
,
size_t
icon_len
,
const
char
*
checksum
)
{
PurpleBuddyIcon
*
icon
;
g_return_val_if_fail
(
account
!=
NULL
,
NULL
);
g_return_val_if_fail
(
username
!=
NULL
,
NULL
);
g_return_val_if_fail
(
icon_data
!=
NULL
,
NULL
);
g_return_val_if_fail
(
icon_len
>
0
,
NULL
);
/* purple_buddy_icons_find() does allocation, so be
* sure to update it as well when members are added. */
icon
=
purple_buddy_icons_find
(
account
,
username
);
/* purple_buddy_icon_create() sets account & username */
if
(
icon
==
NULL
)
icon
=
purple_buddy_icon_create
(
account
,
username
);
/* purple_buddy_icon_set_data() sets img, but it
* references img first, so we need to initialize it */
icon
->
img
=
NULL
;
purple_buddy_icon_set_data
(
icon
,
icon_data
,
icon_len
,
checksum
);
return
icon
;
}
PurpleBuddyIcon
*
purple_buddy_icon_ref
(
PurpleBuddyIcon
*
icon
)
{
g_return_val_if_fail
(
icon
!=
NULL
,
NULL
);
icon
->
ref_count
++
;
return
icon
;
}
void
purple_buddy_icon_unref
(
PurpleBuddyIcon
*
icon
)
{
if
(
icon
==
NULL
)
return
;
g_return_if_fail
(
icon
->
ref_count
>
0
);
icon
->
ref_count
--
;
if
(
icon
->
ref_count
==
0
)
{
GHashTable
*
icon_cache
=
g_hash_table_lookup
(
account_cache
,
purple_buddy_icon_get_account
(
icon
));
if
(
icon_cache
!=
NULL
)
g_hash_table_remove
(
icon_cache
,
purple_buddy_icon_get_username
(
icon
));
g_free
(
icon
->
username
);
g_free
(
icon
->
checksum
);
g_object_unref
(
icon
->
img
);
g_slice_free
(
PurpleBuddyIcon
,
icon
);
}
}
void
purple_buddy_icon_update
(
PurpleBuddyIcon
*
icon
)
{
PurpleConversation
*
im
;
PurpleConversationManager
*
manager
;
PurpleAccount
*
account
;
const
char
*
username
;
PurpleBuddyIcon
*
icon_to_set
;
GSList
*
buddies
;
g_return_if_fail
(
icon
!=
NULL
);
account
=
purple_buddy_icon_get_account
(
icon
);
username
=
purple_buddy_icon_get_username
(
icon
);
/* If no data exists (icon->img == NULL), then call the functions below
* with NULL to unset the icon. They will then unref the icon and it should
* be destroyed. The only way it wouldn't be destroyed is if someone
* else is holding a reference to it, in which case they can kill
* the icon when they realize it has no data. */
icon_to_set
=
icon
->
img
?
icon
:
NULL
;
/* Ensure that icon remains valid throughout */
purple_buddy_icon_ref
(
icon
);
buddies
=
purple_blist_find_buddies
(
account
,
username
);
while
(
buddies
!=
NULL
)
{
PurpleBuddy
*
buddy
=
(
PurpleBuddy
*
)
buddies
->
data
;
char
*
old_icon
;
purple_buddy_set_icon
(
buddy
,
icon_to_set
);
old_icon
=
g_strdup
(
purple_blist_node_get_string
((
PurpleBlistNode
*
)
buddy
,
"buddy_icon"
));
if
(
icon
->
img
&&
purple_buddy_icons_is_caching
())
{
const
char
*
filename
=
image_get_filename
(
icon
->
img
);
g_warn_if_fail
(
filename
!=
NULL
);
purple_blist_node_set_string
((
PurpleBlistNode
*
)
buddy
,
"buddy_icon"
,
filename
);
if
(
icon
->
checksum
&&
*
icon
->
checksum
)
{
purple_blist_node_set_string
((
PurpleBlistNode
*
)
buddy
,
"icon_checksum"
,
icon
->
checksum
);
}
else
{
purple_blist_node_remove_setting
((
PurpleBlistNode
*
)
buddy
,
"icon_checksum"
);
}
ref_filename
(
filename
);
}
else
if
(
!
icon
->
img
)
{
purple_blist_node_remove_setting
((
PurpleBlistNode
*
)
buddy
,
"buddy_icon"
);
purple_blist_node_remove_setting
((
PurpleBlistNode
*
)
buddy
,
"icon_checksum"
);
}
unref_filename
(
old_icon
);
g_free
(
old_icon
);
buddies
=
g_slist_delete_link
(
buddies
,
buddies
);
}
manager
=
purple_conversation_manager_get_default
();
im
=
purple_conversation_manager_find_im
(
manager
,
account
,
username
);
if
(
PURPLE_IS_IM_CONVERSATION
(
im
))
{
purple_im_conversation_set_icon
(
PURPLE_IM_CONVERSATION
(
im
),
icon_to_set
);
}
/* icon's refcount was incremented above */
purple_buddy_icon_unref
(
icon
);
}
void
purple_buddy_icon_set_data
(
PurpleBuddyIcon
*
icon
,
guchar
*
data
,
size_t
len
,
const
char
*
checksum
)
{
PurpleImage
*
old_img
;
g_return_if_fail
(
icon
!=
NULL
);
old_img
=
icon
->
img
;
icon
->
img
=
NULL
;
if
(
data
!=
NULL
)
{
if
(
len
>
0
)
icon
->
img
=
purple_buddy_icon_data_new
(
data
,
len
);
else
g_free
(
data
);
}
g_free
(
icon
->
checksum
);
icon
->
checksum
=
g_strdup
(
checksum
);
purple_buddy_icon_update
(
icon
);
if
(
old_img
)
g_object_unref
(
old_img
);
}
gboolean
purple_buddy_icon_save_to_filename
(
PurpleBuddyIcon
*
icon
,
const
gchar
*
filename
,
GError
**
error
)
{
gconstpointer
data
;
size_t
len
=
0
;
data
=
purple_buddy_icon_get_data
(
icon
,
&
len
);
return
g_file_set_contents
(
filename
,
data
,
len
,
error
);
}
PurpleAccount
*
purple_buddy_icon_get_account
(
const
PurpleBuddyIcon
*
icon
)
{
g_return_val_if_fail
(
icon
!=
NULL
,
NULL
);
return
icon
->
account
;
}
const
char
*
purple_buddy_icon_get_username
(
const
PurpleBuddyIcon
*
icon
)
{
g_return_val_if_fail
(
icon
!=
NULL
,
NULL
);
return
icon
->
username
;
}
const
char
*
purple_buddy_icon_get_checksum
(
const
PurpleBuddyIcon
*
icon
)
{
g_return_val_if_fail
(
icon
!=
NULL
,
NULL
);
return
icon
->
checksum
;
}
gconstpointer
purple_buddy_icon_get_data
(
const
PurpleBuddyIcon
*
icon
,
size_t
*
len
)
{
g_return_val_if_fail
(
icon
!=
NULL
,
NULL
);
if
(
icon
->
img
)
{
if
(
len
!=
NULL
)
*
len
=
purple_image_get_data_size
(
icon
->
img
);
return
purple_image_get_data
(
icon
->
img
);
}
return
NULL
;
}
GInputStream
*
purple_buddy_icon_get_stream
(
PurpleBuddyIcon
*
icon
)
{
gconstpointer
data
=
NULL
;
size_t
len
=
0
;
g_return_val_if_fail
(
icon
!=
NULL
,
NULL
);
data
=
purple_buddy_icon_get_data
(
icon
,
&
len
);
return
g_memory_input_stream_new_from_data
(
data
,
(
gssize
)
len
,
NULL
);
}
const
char
*
purple_buddy_icon_get_extension
(
const
PurpleBuddyIcon
*
icon
)
{
if
(
icon
->
img
!=
NULL
)
return
purple_image_get_extension
(
icon
->
img
);
return
NULL
;
}
void
purple_buddy_icons_set_for_user
(
PurpleAccount
*
account
,
const
char
*
username
,
void
*
icon_data
,
size_t
icon_len
,
const
char
*
checksum
)
{
GHashTable
*
icon_cache
;
PurpleBuddyIcon
*
icon
=
NULL
;
g_return_if_fail
(
account
!=
NULL
);
g_return_if_fail
(
username
!=
NULL
);
icon_cache
=
g_hash_table_lookup
(
account_cache
,
account
);
if
(
icon_cache
!=
NULL
)
icon
=
g_hash_table_lookup
(
icon_cache
,
username
);
if
(
icon
!=
NULL
)
purple_buddy_icon_set_data
(
icon
,
icon_data
,
icon_len
,
checksum
);
else
if
(
icon_data
&&
icon_len
>
0
)
{
PurpleBuddyIcon
*
icon
=
purple_buddy_icon_new
(
account
,
username
,
icon_data
,
icon_len
,
checksum
);
/* purple_buddy_icon_new() calls
* purple_buddy_icon_set_data(), which calls
* purple_buddy_icon_update(), which has the buddy list
* and conversations take references as appropriate.
* This function doesn't return icon, so we can't
* leave a reference dangling. */
purple_buddy_icon_unref
(
icon
);
}
else
{
/* If the buddy list or a conversation was holding a
* reference, we'd have found the icon in the cache.
* Since we know we're deleting the icon, we only
* need a subset of purple_buddy_icon_update(). */
GSList
*
buddies
=
purple_blist_find_buddies
(
account
,
username
);
while
(
buddies
!=
NULL
)
{
PurpleBuddy
*
buddy
=
(
PurpleBuddy
*
)
buddies
->
data
;
unref_filename
(
purple_blist_node_get_string
((
PurpleBlistNode
*
)
buddy
,
"buddy_icon"
));
purple_blist_node_remove_setting
((
PurpleBlistNode
*
)
buddy
,
"buddy_icon"
);
purple_blist_node_remove_setting
((
PurpleBlistNode
*
)
buddy
,
"icon_checksum"
);
buddies
=
g_slist_delete_link
(
buddies
,
buddies
);
}
}
}
const
gchar
*
purple_buddy_icon_get_full_path
(
PurpleBuddyIcon
*
icon
)
{
const
gchar
*
path
;
g_return_val_if_fail
(
icon
!=
NULL
,
NULL
);
if
(
icon
->
img
==
NULL
)
return
NULL
;
path
=
purple_image_get_path
(
icon
->
img
);
if
(
!
g_file_test
(
path
,
G_FILE_TEST_EXISTS
))
{
return
NULL
;
}
return
path
;
}
const
char
*
purple_buddy_icons_get_checksum_for_user
(
PurpleBuddy
*
buddy
)
{
return
purple_blist_node_get_string
((
PurpleBlistNode
*
)
buddy
,
"icon_checksum"
);
}
static
gboolean
read_icon_file
(
const
char
*
path
,
guchar
**
data
,
size_t
*
len
)
{
GError
*
err
=
NULL
;
if
(
!
g_file_get_contents
(
path
,
(
gchar
**
)
data
,
len
,
&
err
))
{
purple_debug_error
(
"buddyicon"
,
"Error reading %s: %s
\n
"
,
path
,
err
->
message
);
g_error_free
(
err
);
return
FALSE
;
}
return
TRUE
;
}
PurpleBuddyIcon
*
purple_buddy_icons_find
(
PurpleAccount
*
account
,
const
char
*
username
)
{
GHashTable
*
icon_cache
;
PurpleBuddyIcon
*
icon
=
NULL
;
g_return_val_if_fail
(
account
!=
NULL
,
NULL
);
g_return_val_if_fail
(
username
!=
NULL
,
NULL
);
icon_cache
=
g_hash_table_lookup
(
account_cache
,
account
);
if
((
icon_cache
==
NULL
)
||
((
icon
=
g_hash_table_lookup
(
icon_cache
,
username
))
==
NULL
))
{
/* The icon is not currently cached in memory--try reading from disk */
PurpleBuddy
*
b
=
purple_blist_find_buddy
(
account
,
username
);
const
char
*
protocol_icon_file
;
const
char
*
dirname
;
gboolean
caching
;
gchar
*
path
;
guchar
*
data
;
size_t
len
;
if
(
!
b
)
return
NULL
;
protocol_icon_file
=
purple_blist_node_get_string
((
PurpleBlistNode
*
)
b
,
"buddy_icon"
);
if
(
protocol_icon_file
==
NULL
)
return
NULL
;
dirname
=
purple_buddy_icons_get_cache_dir
();
caching
=
purple_buddy_icons_is_caching
();
/* By disabling caching temporarily, we avoid a loop
* and don't have to add special code through several
* functions. */
purple_buddy_icons_set_caching
(
FALSE
);
path
=
g_build_filename
(
dirname
,
protocol_icon_file
,
NULL
);
if
(
read_icon_file
(
path
,
&
data
,
&
len
))
{
const
char
*
checksum
;
icon
=
purple_buddy_icon_create
(
account
,
username
);
icon
->
img
=
NULL
;
checksum
=
purple_blist_node_get_string
((
PurpleBlistNode
*
)
b
,
"icon_checksum"
);
purple_buddy_icon_set_data
(
icon
,
data
,
len
,
checksum
);
}
else
{
delete_buddy_icon_settings
((
PurpleBlistNode
*
)
b
,
"buddy_icon"
);
}
g_free
(
path
);
purple_buddy_icons_set_caching
(
caching
);
}
return
(
icon
?
purple_buddy_icon_ref
(
icon
)
:
NULL
);
}
PurpleImage
*
purple_buddy_icons_find_account_icon
(
PurpleAccount
*
account
)
{
PurpleImage
*
img
;
const
char
*
account_icon_file
;
const
char
*
dirname
;
char
*
path
;
guchar
*
data
;
size_t
len
;
g_return_val_if_fail
(
account
!=
NULL
,
NULL
);
img
=
g_hash_table_lookup
(
pointer_icon_cache
,
account
);
if
(
img
)
{
g_object_ref
(
img
);
return
img
;
}
account_icon_file
=
purple_account_get_string
(
account
,
"buddy_icon"
,
NULL
);
if
(
account_icon_file
==
NULL
)
return
NULL
;
dirname
=
purple_buddy_icons_get_cache_dir
();
path
=
g_build_filename
(
dirname
,
account_icon_file
,
NULL
);
if
(
read_icon_file
(
path
,
&
data
,
&
len
))
{
g_free
(
path
);
img
=
purple_buddy_icons_set_account_icon
(
account
,
data
,
len
);
g_object_ref
(
img
);
return
img
;
}
g_free
(
path
);
return
NULL
;
}
PurpleImage
*
purple_buddy_icons_set_account_icon
(
PurpleAccount
*
account
,
guchar
*
icon_data
,
size_t
icon_len
)
{
PurpleImage
*
old_img
;
PurpleImage
*
img
=
NULL
;
char
*
old_icon
;
if
(
icon_data
!=
NULL
&&
icon_len
>
0
)
{
img
=
purple_buddy_icon_data_new
(
icon_data
,
icon_len
);
}
old_icon
=
g_strdup
(
purple_account_get_string
(
account
,
"buddy_icon"
,
NULL
));
if
(
img
&&
purple_buddy_icons_is_caching
())
{
const
char
*
filename
=
image_get_filename
(
img
);
g_warn_if_fail
(
filename
!=
NULL
);
purple_account_set_string
(
account
,
"buddy_icon"
,
filename
);
purple_account_set_int
(
account
,
"buddy_icon_timestamp"
,
time
(
NULL
));
ref_filename
(
filename
);
}
else
{
purple_account_set_string
(
account
,
"buddy_icon"
,
NULL
);
purple_account_set_int
(
account
,
"buddy_icon_timestamp"
,
0
);
}
unref_filename
(
old_icon
);
old_img
=
g_hash_table_lookup
(
pointer_icon_cache
,
account
);
if
(
img
)
g_hash_table_insert
(
pointer_icon_cache
,
account
,
img
);
else
g_hash_table_remove
(
pointer_icon_cache
,
account
);
if
(
!
purple_account_is_disconnected
(
account
))
{
PurpleConnection
*
gc
;
PurpleProtocol
*
protocol
;
gc
=
purple_account_get_connection
(
account
);
protocol
=
purple_connection_get_protocol
(
gc
);
if
(
PURPLE_IS_PROTOCOL_SERVER
(
protocol
))
{
purple_protocol_server_set_buddy_icon
(
PURPLE_PROTOCOL_SERVER
(
protocol
),
gc
,
img
);
}
}
if
(
old_img
)
g_object_unref
(
old_img
);
else
if
(
old_icon
)
{
/* The old icon may not have been loaded into memory. In that
* case, we'll need to uncache the filename. The filenames
* are ref-counted, so this is safe. */
purple_buddy_icon_data_uncache_file
(
old_icon
);
}
g_free
(
old_icon
);
return
img
;
}
time_t
purple_buddy_icons_get_account_icon_timestamp
(
PurpleAccount
*
account
)
{
time_t
ret
;
g_return_val_if_fail
(
account
!=
NULL
,
0
);
ret
=
purple_account_get_int
(
account
,
"buddy_icon_timestamp"
,
0
);
/* This deals with migration cases. */
if
(
ret
==
0
&&
purple_account_get_string
(
account
,
"buddy_icon"
,
NULL
)
!=
NULL
)
{
ret
=
time
(
NULL
);
purple_account_set_int
(
account
,
"buddy_icon_timestamp"
,
ret
);
}
return
ret
;
}
gboolean
purple_buddy_icons_node_has_custom_icon
(
PurpleBlistNode
*
node
)
{
g_return_val_if_fail
(
node
!=
NULL
,
FALSE
);
return
(
purple_blist_node_get_string
(
node
,
"custom_buddy_icon"
)
!=
NULL
);
}
PurpleImage
*
purple_buddy_icons_node_find_custom_icon
(
PurpleBlistNode
*
node
)
{
char
*
path
;
size_t
len
;
guchar
*
data
;
PurpleImage
*
img
;
const
char
*
custom_icon_file
,
*
dirname
;
g_return_val_if_fail
(
node
!=
NULL
,
NULL
);
img
=
g_hash_table_lookup
(
pointer_icon_cache
,
node
);
if
(
img
)
{
g_object_ref
(
img
);
return
img
;
}
custom_icon_file
=
purple_blist_node_get_string
(
node
,
"custom_buddy_icon"
);
if
(
custom_icon_file
==
NULL
)
return
NULL
;
dirname
=
purple_buddy_icons_get_cache_dir
();
path
=
g_build_filename
(
dirname
,
custom_icon_file
,
NULL
);
if
(
read_icon_file
(
path
,
&
data
,
&
len
))
{
g_free
(
path
);
img
=
purple_buddy_icons_node_set_custom_icon
(
node
,
data
,
len
);
g_object_ref
(
img
);
return
img
;
}
g_free
(
path
);
return
NULL
;
}
PurpleImage
*
purple_buddy_icons_node_set_custom_icon
(
PurpleBlistNode
*
node
,
guchar
*
icon_data
,
size_t
icon_len
)
{
char
*
old_icon
;
PurpleConversationManager
*
manager
=
NULL
;
PurpleImage
*
old_img
;
PurpleImage
*
img
=
NULL
;
g_return_val_if_fail
(
node
!=
NULL
,
NULL
);
if
(
!
PURPLE_IS_CONTACT
(
node
)
&&
!
PURPLE_IS_CHAT
(
node
)
&&
!
PURPLE_IS_GROUP
(
node
))
{
return
NULL
;
}
old_img
=
g_hash_table_lookup
(
pointer_icon_cache
,
node
);
if
(
icon_data
!=
NULL
&&
icon_len
>
0
)
{
img
=
purple_buddy_icon_data_new
(
icon_data
,
icon_len
);
}
old_icon
=
g_strdup
(
purple_blist_node_get_string
(
node
,
"custom_buddy_icon"
));
if
(
img
&&
purple_buddy_icons_is_caching
())
{
const
char
*
filename
=
image_get_filename
(
img
);
g_warn_if_fail
(
filename
);
purple_blist_node_set_string
(
node
,
"custom_buddy_icon"
,
filename
);
ref_filename
(
filename
);
}
else
{
purple_blist_node_remove_setting
(
node
,
"custom_buddy_icon"
);
}
unref_filename
(
old_icon
);
if
(
img
)
g_hash_table_insert
(
pointer_icon_cache
,
node
,
img
);
else
g_hash_table_remove
(
pointer_icon_cache
,
node
);
manager
=
purple_conversation_manager_get_default
();
if
(
PURPLE_IS_CONTACT
(
node
))
{
PurpleBlistNode
*
child
;
for
(
child
=
purple_blist_node_get_first_child
(
node
);
child
;
child
=
purple_blist_node_get_sibling_next
(
child
))
{
PurpleBuddy
*
buddy
;
PurpleConversation
*
im
;
if
(
!
PURPLE_IS_BUDDY
(
child
))
{
continue
;
}
buddy
=
PURPLE_BUDDY
(
child
);
im
=
purple_conversation_manager_find_im
(
manager
,
purple_buddy_get_account
(
buddy
),
purple_buddy_get_name
(
buddy
));
if
(
PURPLE_IS_IM_CONVERSATION
(
im
))
{
purple_conversation_update
(
im
,
PURPLE_CONVERSATION_UPDATE_ICON
);
}
/* Is this call necessary anymore? Can the buddies
* themselves need updating when the custom buddy
* icon changes? */
purple_blist_update_node
(
purple_blist_get_default
(),
child
);
}
}
else
if
(
PURPLE_IS_CHAT
(
node
))
{
PurpleAccount
*
account
=
purple_chat_get_account
(
PURPLE_CHAT
(
node
));
PurpleConversation
*
chat
=
NULL
;
const
gchar
*
name
=
purple_chat_get_name
(
PURPLE_CHAT
(
node
));
chat
=
purple_conversation_manager_find_chat
(
manager
,
account
,
name
);
if
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
))
{
purple_conversation_update
(
chat
,
PURPLE_CONVERSATION_UPDATE_ICON
);
}
}
purple_blist_update_node
(
purple_blist_get_default
(),
node
);
if
(
old_img
)
{
g_object_unref
(
old_img
);
}
else
if
(
old_icon
)
{
/* The old icon may not have been loaded into memory. In that
* case, we'll need to uncache the filename. The filenames
* are ref-counted, so this is safe. */
purple_buddy_icon_data_uncache_file
(
old_icon
);
}
g_free
(
old_icon
);
return
img
;
}
PurpleImage
*
purple_buddy_icons_node_set_custom_icon_from_file
(
PurpleBlistNode
*
node
,
const
gchar
*
filename
)
{
size_t
len
=
0
;
guchar
*
data
=
NULL
;
g_return_val_if_fail
(
node
!=
NULL
,
NULL
);
if
(
!
PURPLE_IS_CONTACT
(
node
)
&&
!
PURPLE_IS_CHAT
(
node
)
&&
!
PURPLE_IS_GROUP
(
node
))
{
return
NULL
;
}
if
(
filename
!=
NULL
)
{
if
(
!
read_icon_file
(
filename
,
&
data
,
&
len
))
{
return
NULL
;
}
}
return
purple_buddy_icons_node_set_custom_icon
(
node
,
data
,
len
);
}
static
void
delete_buddy_icon_settings
(
PurpleBlistNode
*
node
,
const
char
*
setting_name
)
{
purple_blist_node_remove_setting
(
node
,
setting_name
);
if
(
purple_strequal
(
setting_name
,
"buddy_icon"
))
{
purple_blist_node_remove_setting
(
node
,
"avatar_hash"
);
purple_blist_node_remove_setting
(
node
,
"icon_checksum"
);
}
}
void
_purple_buddy_icons_account_loaded_cb
()
{
const
char
*
dirname
=
purple_buddy_icons_get_cache_dir
();
GList
*
cur
;
for
(
cur
=
purple_accounts_get_all
();
cur
!=
NULL
;
cur
=
cur
->
next
)
{
PurpleAccount
*
account
=
cur
->
data
;
const
char
*
account_icon_file
=
purple_account_get_string
(
account
,
"buddy_icon"
,
NULL
);
if
(
account_icon_file
!=
NULL
)
{
char
*
path
=
g_build_filename
(
dirname
,
account_icon_file
,
NULL
);
if
(
!
g_file_test
(
path
,
G_FILE_TEST_EXISTS
))
{
purple_account_set_string
(
account
,
"buddy_icon"
,
NULL
);
}
else
{
ref_filename
(
account_icon_file
);
}
g_free
(
path
);
}
}
}
void
_purple_buddy_icons_blist_loaded_cb
()
{
PurpleBlistNode
*
node
=
purple_blist_get_default_root
();
const
char
*
dirname
=
purple_buddy_icons_get_cache_dir
();
while
(
node
!=
NULL
)
{
if
(
PURPLE_IS_BUDDY
(
node
))
{
const
char
*
filename
;
filename
=
purple_blist_node_get_string
(
node
,
"buddy_icon"
);
if
(
filename
!=
NULL
)
{
char
*
path
=
g_build_filename
(
dirname
,
filename
,
NULL
);
if
(
!
g_file_test
(
path
,
G_FILE_TEST_EXISTS
))
{
purple_blist_node_remove_setting
(
node
,
"buddy_icon"
);
purple_blist_node_remove_setting
(
node
,
"icon_checksum"
);
}
else
ref_filename
(
filename
);
g_free
(
path
);
}
}
else
if
(
PURPLE_IS_CONTACT
(
node
)
||
PURPLE_IS_CHAT
(
node
)
||
PURPLE_IS_GROUP
(
node
))
{
const
char
*
filename
;
filename
=
purple_blist_node_get_string
(
node
,
"custom_buddy_icon"
);
if
(
filename
!=
NULL
)
{
char
*
path
=
g_build_filename
(
dirname
,
filename
,
NULL
);
if
(
!
g_file_test
(
path
,
G_FILE_TEST_EXISTS
))
{
purple_blist_node_remove_setting
(
node
,
"custom_buddy_icon"
);
}
else
ref_filename
(
filename
);
g_free
(
path
);
}
}
node
=
purple_blist_node_next
(
node
,
TRUE
);
}
}
void
purple_buddy_icons_set_caching
(
gboolean
caching
)
{
icon_caching
=
caching
;
}
gboolean
purple_buddy_icons_is_caching
(
void
)
{
return
icon_caching
;
}
void
purple_buddy_icons_set_cache_dir
(
const
char
*
dir
)
{
g_return_if_fail
(
dir
!=
NULL
);
g_free
(
cache_dir
);
cache_dir
=
g_strdup
(
dir
);
}
const
char
*
purple_buddy_icons_get_cache_dir
(
void
)
{
return
cache_dir
;
}
void
*
purple_buddy_icons_get_handle
()
{
static
int
handle
;
return
&
handle
;
}
void
purple_buddy_icons_init
()
{
account_cache
=
g_hash_table_new_full
(
g_direct_hash
,
g_direct_equal
,
NULL
,
(
GFreeFunc
)
g_hash_table_destroy
);
icon_data_cache
=
g_hash_table_new_full
(
g_str_hash
,
g_str_equal
,
g_free
,
NULL
);
icon_file_cache
=
g_hash_table_new_full
(
g_str_hash
,
g_str_equal
,
g_free
,
NULL
);
pointer_icon_cache
=
g_hash_table_new
(
g_direct_hash
,
g_direct_equal
);
if
(
!
cache_dir
)
cache_dir
=
g_build_filename
(
purple_cache_dir
(),
"icons"
,
NULL
);
}
void
purple_buddy_icons_uninit
()
{
purple_signals_disconnect_by_handle
(
purple_buddy_icons_get_handle
());
g_hash_table_destroy
(
account_cache
);
g_hash_table_destroy
(
icon_data_cache
);
g_hash_table_destroy
(
icon_file_cache
);
g_hash_table_destroy
(
pointer_icon_cache
);
g_free
(
cache_dir
);
cache_dir
=
NULL
;
}
GType
purple_buddy_icon_get_type
(
void
)
{
static
GType
type
=
0
;
if
(
type
==
0
)
{
type
=
g_boxed_type_register_static
(
"PurpleBuddyIcon"
,
(
GBoxedCopyFunc
)
purple_buddy_icon_ref
,
(
GBoxedFreeFunc
)
purple_buddy_icon_unref
);
}
return
type
;
}
PurpleBuddyIconSpec
*
purple_buddy_icon_spec_new
(
char
*
format
,
int
min_width
,
int
min_height
,
int
max_width
,
int
max_height
,
size_t
max_filesize
,
PurpleBuddyIconScaleFlags
scale_rules
)
{
PurpleBuddyIconSpec
*
icon_spec
;
icon_spec
=
g_new0
(
PurpleBuddyIconSpec
,
1
);
icon_spec
->
format
=
format
;
icon_spec
->
min_width
=
min_width
;
icon_spec
->
min_height
=
min_height
;
icon_spec
->
max_width
=
max_width
;
icon_spec
->
max_height
=
max_height
;
icon_spec
->
max_filesize
=
max_filesize
;
icon_spec
->
scale_rules
=
scale_rules
;
return
icon_spec
;
}
void
purple_buddy_icon_spec_free
(
PurpleBuddyIconSpec
*
spec
)
{
if
(
spec
==
NULL
)
{
return
;
}
g_free
(
spec
);
}
static
PurpleBuddyIconSpec
*
purple_buddy_icon_spec_copy
(
PurpleBuddyIconSpec
*
icon_spec
)
{
PurpleBuddyIconSpec
*
icon_spec_copy
;
g_return_val_if_fail
(
icon_spec
!=
NULL
,
NULL
);
icon_spec_copy
=
g_new0
(
PurpleBuddyIconSpec
,
1
);
*
icon_spec_copy
=
*
icon_spec
;
return
icon_spec_copy
;
}
void
purple_buddy_icon_spec_get_scaled_size
(
PurpleBuddyIconSpec
*
spec
,
int
*
width
,
int
*
height
)
{
int
new_width
,
new_height
;
new_width
=
*
width
;
new_height
=
*
height
;
if
(
*
width
<
spec
->
min_width
)
new_width
=
spec
->
min_width
;
else
if
(
*
width
>
spec
->
max_width
)
new_width
=
spec
->
max_width
;
if
(
*
height
<
spec
->
min_height
)
new_height
=
spec
->
min_height
;
else
if
(
*
height
>
spec
->
max_height
)
new_height
=
spec
->
max_height
;
/* preserve aspect ratio */
if
((
double
)
*
height
*
(
double
)
new_width
>
(
double
)
*
width
*
(
double
)
new_height
)
{
new_width
=
0.5
+
(
double
)
*
width
*
(
double
)
new_height
/
(
double
)
*
height
;
}
else
{
new_height
=
0.5
+
(
double
)
*
height
*
(
double
)
new_width
/
(
double
)
*
width
;
}
*
width
=
new_width
;
*
height
=
new_height
;
}
GType
purple_buddy_icon_spec_get_type
(
void
)
{
static
GType
type
=
0
;
if
(
type
==
0
)
{
type
=
g_boxed_type_register_static
(
"PurpleBuddyIconSpec"
,
(
GBoxedCopyFunc
)
purple_buddy_icon_spec_copy
,
(
GBoxedFreeFunc
)
purple_buddy_icon_spec_free
);
}
return
type
;
}