void qq_request_get_buddies_level(PurpleConnection *gc, guint32 update_class)
{
qq_data *qd = (qq_data *) gc->proto_data;
PurpleBuddy *buddy;
qq_buddy_data *bd;
guint8 *buf;
GSList *buddies, *it;
gint bytes;
/* server only reply levels for online buddies */
buf = g_newa(guint8, MAX_PACKET_SIZE);
bytes = 0;
bytes += qq_put8(buf + bytes, 0x00);
buddies = purple_find_buddies(purple_connection_get_account(gc), NULL);
for (it = buddies; it; it = it->next) {
buddy = it->data;
if (buddy == NULL) continue;
if (buddy->proto_data == NULL) continue;
bd = (qq_buddy_data *)buddy->proto_data;
if (bd->uid == 0) continue; /* keep me as end of packet*/
if (bd->uid == qd->uid) continue;
bytes += qq_put32(buf + bytes, bd->uid);
}
bytes += qq_put32(buf + bytes, qd->uid);
qq_send_cmd_mess(gc, QQ_CMD_GET_LEVEL, buf, bytes, update_class, 0);
}
void purple_prpl_got_user_status_deactive(PurpleAccount *account, const char *name,
const char *status_id)
{
GSList *list, *l;
PurpleBuddy *buddy;
PurplePresence *presence;
PurpleStatus *status;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
g_return_if_fail(status_id != NULL);
g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
if((list = purple_find_buddies(account, name)) == NULL)
return;
for(l = list; l != NULL; l = l->next) {
buddy = l->data;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_status(presence, status_id);
if(NULL == status)
continue;
if (purple_status_is_active(status)) {
purple_status_set_active(status, FALSE);
purple_blist_update_buddy_status(buddy, status);
}
}
g_slist_free(list);
}
void
purple_prpl_got_user_login_time(PurpleAccount *account, const char *name,
time_t login_time)
{
GSList *list;
PurplePresence *presence;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
if ((list = purple_find_buddies(account, name)) == NULL)
return;
if (login_time == 0)
login_time = time(NULL);
while (list) {
PurpleBuddy *buddy = list->data;
presence = purple_buddy_get_presence(buddy);
list = g_slist_delete_link(list, list);
if (purple_presence_get_login_time(presence) != login_time)
{
purple_presence_set_login_time(presence, login_time);
purple_signal_emit(purple_blist_get_handle(), "buddy-got-login-time", buddy);
}
}
}
void GetAllBuddyInfo(struct fetion_account_data *sip)
{
gchar body[10240];
GSList *buddy_list;
memset(body, 0, sizeof(body));
g_strlcat(body, "<args><contacts attributes=\"provisioning;impresa;mobile-no;nickname;name;gender;portrait-crc;ivr-enabled\" extended-attributes=\"score-level\">", 10240);
buddy_list = purple_find_buddies(sip->account, NULL);
for (; buddy_list; buddy_list = g_slist_next(buddy_list)) {
if ((strncmp (((PurpleBuddy *) buddy_list->data)->name, "sip", 3) == 0) &&
(strcmp (((PurpleBuddy *) buddy_list->data)->name, sip->uri) != 0))
{
g_strlcat(body, "<contact uri=\"", 10240);
g_strlcat(body, ((PurpleBuddy *) buddy_list-> data)->name, 10240);
g_strlcat(body, "\" />", 10240);
} else
continue;
}
g_strlcat(body, "</contacts></args>", 10240);
send_sip_request(sip->gc, "S", "", "", "N: GetContactsInfo\r\n", body,
NULL, NULL);
}
static void
show_private_list(PurplePluginAction *action, guint16 list_type, const gchar *title, const gchar *list_description, const gchar *menu_action_name)
{
PurpleConnection *gc = (PurpleConnection *) action->context;
OscarData *od = purple_connection_get_protocol_data(gc);
PurpleAccount *account = purple_connection_get_account(gc);
GSList *buddies, *filtered_buddies, *cur;
gchar *text, *secondary;
buddies = purple_find_buddies(account, NULL);
filtered_buddies = NULL;
for (cur = buddies; cur != NULL; cur = cur->next) {
PurpleBuddy *buddy;
const gchar *bname;
buddy = cur->data;
bname = purple_buddy_get_name(buddy);
if (aim_ssi_itemlist_finditem(od->ssi.local, NULL, bname, list_type)) {
filtered_buddies = g_slist_prepend(filtered_buddies, buddy);
}
}
g_slist_free(buddies);
filtered_buddies = g_slist_reverse(filtered_buddies);
text = oscar_format_buddies(filtered_buddies, _("you have no buddies on this list"));
g_slist_free(filtered_buddies);
secondary = g_strdup_printf(_("You can add a buddy to this list "
"by right-clicking on them and "
"selecting \"%s\""), menu_action_name);
purple_notify_formatted(gc, title, list_description, secondary, text, NULL, NULL);
g_free(secondary);
g_free(text);
}
PurpleBuddy* spin_find_buddy_by_id(PurpleAccount* account,const gchar* id)
{
GSList* account_buddies = purple_find_buddies(account,NULL);
PurpleBuddy* ret = spin_find_buddy_in_list(account_buddies,id);
g_slist_free(account_buddies);
return ret;
}
void
purple_prpl_got_media_caps(PurpleAccount *account, const char *name)
{
#ifdef USE_VV
GSList *list;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
if ((list = purple_find_buddies(account, name)) == NULL)
return;
while (list) {
PurpleBuddy *buddy = list->data;
PurpleMediaCaps oldcaps = purple_buddy_get_media_caps(buddy);
PurpleMediaCaps newcaps = 0;
const gchar *bname = purple_buddy_get_name(buddy);
list = g_slist_delete_link(list, list);
newcaps = purple_prpl_get_media_caps(account, bname);
purple_buddy_set_media_caps(buddy, newcaps);
if (oldcaps == newcaps)
continue;
purple_signal_emit(purple_blist_get_handle(),
"buddy-caps-changed", buddy,
newcaps, oldcaps);
}
#endif
}
void jabber_roster_group_change(PurpleConnection *gc, const char *name,
const char *old_group, const char *new_group)
{
GSList *buddies, *groups = NULL;
PurpleBuddy *b;
PurpleGroup *g;
const char *gname;
if(!old_group || !new_group || !strcmp(old_group, new_group))
return;
buddies = purple_find_buddies(gc->account, name);
while(buddies) {
b = buddies->data;
g = purple_buddy_get_group(b);
gname = purple_group_get_name(g);
if(!strcmp(gname, old_group))
groups = g_slist_append(groups, (char*)new_group); /* ick */
else
groups = g_slist_append(groups, (char*)gname);
buddies = g_slist_remove(buddies, b);
}
purple_debug_info("jabber", "jabber_roster_group_change(): Moving %s from %s to %s\n",
name, old_group, new_group);
jabber_roster_update(gc->proto_data, name, groups);
}
/*load userlist from the Blist file cache*/
void
msn_userlist_load(MsnSession *session)
{
PurpleAccount *account = session->account;
PurpleConnection *gc = purple_account_get_connection(account);
GSList *l;
MsnUser * user;
g_return_if_fail(gc != NULL);
for (l = purple_find_buddies(account, NULL); l != NULL;
l = g_slist_delete_link(l, l)) {
PurpleBuddy *buddy = l->data;
user = msn_userlist_find_add_user(session->userlist,
purple_buddy_get_name(buddy), NULL);
purple_buddy_set_protocol_data(buddy, user);
msn_user_set_op(user, MSN_LIST_FL_OP);
}
for (l = session->account->permit; l != NULL; l = l->next)
{
user = msn_userlist_find_add_user(session->userlist,
(char *)l->data,NULL);
msn_user_set_op(user, MSN_LIST_AL_OP);
}
for (l = session->account->deny; l != NULL; l = l->next)
{
user = msn_userlist_find_add_user(session->userlist,
(char *)l->data,NULL);
msn_user_set_op(user, MSN_LIST_BL_OP);
}
}
void jabber_roster_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy,
PurpleGroup *group) {
GSList *buddies = purple_find_buddies(gc->account, buddy->name);
buddies = g_slist_remove(buddies, buddy);
if(buddies != NULL) {
PurpleBuddy *tmpbuddy;
PurpleGroup *tmpgroup;
GSList *groups = NULL;
while(buddies) {
tmpbuddy = buddies->data;
tmpgroup = purple_buddy_get_group(tmpbuddy);
groups = g_slist_append(groups, tmpgroup->name);
buddies = g_slist_remove(buddies, tmpbuddy);
}
jabber_roster_update(gc->proto_data, buddy->name, groups);
g_slist_free(groups);
} else {
JabberIq *iq = jabber_iq_new_query(gc->proto_data, JABBER_IQ_SET,
"jabber:iq:roster");
xmlnode *query = xmlnode_get_child(iq->node, "query");
xmlnode *item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "jid", buddy->name);
xmlnode_set_attrib(item, "subscription", "remove");
jabber_iq_send(iq);
}
}
void fchat_load_buddy_list(FChatConnection *fchat_conn) {
GSList *buddies = purple_find_buddies(fchat_conn->gc->account, NULL);
for(GSList *l = buddies; l; l = l->next) {
PurpleBuddy *buddy = (PurpleBuddy *)l->data;
FChatBuddy *fchat_buddy = fchat_buddy_new(buddy->name, buddy->alias);
g_hash_table_insert(fchat_conn->buddies, g_strdup(buddy->name), fchat_buddy);
}
g_slist_free(buddies);
}
static void remove_purple_buddies(JabberStream *js, const char *jid)
{
GSList *buddies, *l;
buddies = purple_find_buddies(js->gc->account, jid);
for(l = buddies; l; l = l->next)
purple_blist_remove_buddy(l->data);
g_slist_free(buddies);
}
static void
msn_session_sync_users(MsnSession *session)
{
PurpleConnection *gc = purple_account_get_connection(session->account);
GList *to_remove = NULL;
GSList *buddies;
g_return_if_fail(gc != NULL);
/* The core used to use msn_add_buddy to add all buddies before
* being logged in. This no longer happens, so we manually iterate
* over the whole buddy list to identify sync issues.
*/
for (buddies = purple_find_buddies(session->account, NULL); buddies;
buddies = g_slist_delete_link(buddies, buddies)) {
PurpleBuddy *buddy = buddies->data;
const gchar *buddy_name = purple_buddy_get_name(buddy);
const gchar *group_name = purple_group_get_name(purple_buddy_get_group(buddy));
MsnUser *remote_user;
gboolean found = FALSE;
remote_user = msn_userlist_find_user(session->userlist, buddy_name);
if (remote_user && remote_user->list_op & MSN_LIST_FL_OP) {
GList *l;
for (l = remote_user->group_ids; l; l = l->next) {
const char *name = msn_userlist_find_group_name(remote_user->userlist, l->data);
if (name && !g_ascii_strcasecmp(group_name, name)) {
found = TRUE;
break;
}
}
/* We don't care if they're in a different group, as long as they're on the
* list somewhere. If we check for the group, we cause pain, agony and
* suffering for people who decide to re-arrange their buddy list elsewhere.
*/
if (!found) {
if ((remote_user == NULL) || !(remote_user->list_op & MSN_LIST_FL_OP)) {
/* The user is not on the server list */
msn_error_sync_issue(session, buddy_name, group_name);
} else {
/* The user is not in that group on the server list */
to_remove = g_list_prepend(to_remove, buddy);
}
}
}
}
if (to_remove != NULL) {
g_list_foreach(to_remove, (GFunc)purple_blist_remove_buddy, NULL);
g_list_free(to_remove);
}
}
static void jabber_roster_update(JabberStream *js, const char *name,
GSList *grps)
{
PurpleBuddy *b;
PurpleGroup *g;
GSList *groups = NULL, *l;
JabberIq *iq;
xmlnode *query, *item, *group;
if (js->currently_parsing_roster_push)
return;
if(!(b = purple_find_buddy(js->gc->account, name)))
return;
if(grps) {
groups = grps;
} else {
GSList *buddies = purple_find_buddies(js->gc->account, name);
if(!buddies)
return;
while(buddies) {
b = buddies->data;
g = purple_buddy_get_group(b);
groups = g_slist_append(groups, g->name);
buddies = g_slist_remove(buddies, b);
}
}
iq = jabber_iq_new_query(js, JABBER_IQ_SET, "jabber:iq:roster");
query = xmlnode_get_child(iq->node, "query");
item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "jid", name);
xmlnode_set_attrib(item, "name", b->alias ? b->alias : "");
for(l = groups; l; l = l->next) {
group = xmlnode_new_child(item, "group");
xmlnode_insert_data(group, l->data, -1);
}
if(!grps)
g_slist_free(groups);
if (js->server_caps & JABBER_CAP_GOOGLE_ROSTER) {
jabber_google_roster_outgoing(js, query, item);
xmlnode_set_attrib(query, "xmlns:gr", "google:roster");
xmlnode_set_attrib(query, "gr:ext", "2");
}
jabber_iq_send(iq);
}
void
fetion_subscribe_exp(struct fetion_account_data *sip,
struct fetion_buddy *buddy)
{
GSList *buddy_list;
gchar body[10240], *hdr;
memset(body, 0, sizeof(body));
g_strlcat(body, "<args><subscription><contacts>", 10240);
hdr = g_strdup_printf("N: presence\r\n");
if (buddy == NULL) {
buddy_list = purple_find_buddies(sip->account, NULL);
for (; buddy_list; buddy_list = g_slist_next(buddy_list)) {
if ((strncmp
(((PurpleBuddy *) buddy_list->data)->name, "sip",
3) == 0)
&&
(strcmp
(((PurpleBuddy *) buddy_list->data)->name,
sip->uri)
!= 0)) {
g_strlcat(body, "<contact uri=\"", 10240);
purple_debug_info("fetion:sub", "name=[%s]\n",
((PurpleBuddy *)
buddy_list->data)->name);
g_strlcat(body,
((PurpleBuddy *) buddy_list->
data)->name, 10240);
g_strlcat(body, "\" />", 10240);
} else
continue;
}
} else {
g_strlcat(body, "<contact uri=\"", 10240);
g_strlcat(body, buddy->name, 10240);
g_strlcat(body, "\" />", 10240);
}
g_strlcat(body, "</contacts>", 10240);
g_strlcat(body,
"<presence><basic attributes=\"all\" /><personal attributes=\"all\" /><extended types=\"sms;location;listening;ring-back-tone\" /></presence></subscription><subscription><contacts><contact uri=\"",
10240);
g_strlcat(body, sip->uri, 10240);
g_strlcat(body,
"\" /></contacts><presence><extended types=\"sms;location;listening;ring-back-tone\" /></presence></subscription></args>",
10240);
purple_debug_info("fetion:sub", "name=[%s]\n", body);
send_sip_request(sip->gc, "SUB", "", "", hdr, body, NULL,
process_subscribe_response);
}
void
purple_prpl_got_user_status(PurpleAccount *account, const char *name,
const char *status_id, ...)
{
GSList *list, *l;
PurpleBuddy *buddy;
PurplePresence *presence;
PurpleStatus *status;
PurpleStatus *old_status;
va_list args;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
g_return_if_fail(status_id != NULL);
g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
if((list = purple_find_buddies(account, name)) == NULL)
return;
for(l = list; l != NULL; l = l->next) {
buddy = l->data;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_status(presence, status_id);
if(NULL == status)
/*
* TODO: This should never happen, right? We should call
* g_warning() or something.
*/
continue;
old_status = purple_presence_get_active_status(presence);
va_start(args, status_id);
purple_status_set_active_with_attrs(status, TRUE, args);
va_end(args);
purple_blist_update_buddy_status(buddy, old_status);
}
g_slist_free(list);
/* The buddy is no longer online, they are therefore by definition not
* still typing to us. */
if (!purple_status_is_online(status)) {
serv_got_typing_stopped(purple_account_get_connection(account), name);
purple_prpl_got_media_caps(account, name);
}
}
static VALUE account_get_buddies_list( VALUE self ) {
PurpleAccount *account = PURPLE_ACCOUNT(self);
PurpleBuddy *buddy = NULL;
GList *iter = NULL;
VALUE buddies = rb_ary_new();
for( iter = (GList *) purple_find_buddies( account, NULL ); iter; iter = iter->next ) {
buddy = iter->data;
if( buddy != NULL && buddy->name != NULL ) {
rb_ary_push( buddies, RB_BLIST_BUDDY( buddy ) );
}
}
return buddies;
}
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_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);
}
}
}
static void waprpl_insert_contacts(PurpleConnection *gc) {
whatsapp_connection * wconn = purple_connection_get_protocol_data(gc);
GSList *buddies = purple_find_buddies(purple_connection_get_account(gc), NULL);
GSList * l;
for (l = buddies; l; l = l->next) {
PurpleBuddy * b = l->data;
const char * name = purple_buddy_get_name(b);
waAPI_addcontact(wconn->waAPI,name);
}
waprpl_check_output(gc);
g_slist_free(buddies);
}
void
purple_prpl_got_user_status(PurpleAccount *account, const char *name,
const char *status_id, ...)
{
GSList *list, *l;
PurpleBuddy *buddy;
PurplePresence *presence;
PurpleStatus *status;
PurpleStatus *old_status;
va_list args;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
g_return_if_fail(status_id != NULL);
g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
if((list = purple_find_buddies(account, name)) == NULL)
return;
for(l = list; l != NULL; l = l->next) {
buddy = l->data;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_status(presence, status_id);
if(NULL == status)
continue;
old_status = purple_presence_get_active_status(presence);
va_start(args, status_id);
purple_status_set_active_with_attrs(status, TRUE, args);
va_end(args);
purple_blist_update_buddy_status(buddy, old_status);
}
g_slist_free(list);
/* we get to re-use the last status we found */
if (!purple_status_is_online(status))
serv_got_typing_stopped(purple_account_get_connection(account), name);
}
void
purple_prpl_got_user_idle(PurpleAccount *account, const char *name,
gboolean idle, time_t idle_time)
{
PurplePresence *presence;
GSList *list;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
if ((list = purple_find_buddies(account, name)) == NULL)
return;
while (list) {
presence = purple_buddy_get_presence(list->data);
list = g_slist_delete_link(list, list);
purple_presence_set_idle(presence, idle, idle_time);
}
}
/* stupid libpurple's local contact list, we don't need you! */
static void
sync_users (MsnSession *session)
{
PurpleAccount *account;
GSList *buddies;
GList *to_remove = NULL;
account = msn_session_get_user_data(session);
for (buddies = purple_find_buddies(account, NULL); buddies;
buddies = g_slist_delete_link(buddies, buddies))
{
PurpleBuddy *buddy = buddies->data;
const gchar *buddy_name = purple_buddy_get_name(buddy);
const gchar *group_name = purple_group_get_name(purple_buddy_get_group(buddy));
struct pn_contact *contact;
gboolean found = FALSE;
contact = pn_contactlist_find_contact(session->contactlist, buddy_name);
if (contact && contact->list_op & MSN_LIST_FL_OP) {
struct pn_group *group;
group = pn_contactlist_find_group_with_name(session->contactlist,
group_name);
found = pn_contact_is_in_group(contact, group);
}
if (!found) {
pn_warning("synchronization issue; buddy %s not found in group %s: removing",
purple_buddy_get_name(buddy), group_name);
to_remove = g_list_prepend(to_remove, buddy);
}
}
if (to_remove) {
g_list_foreach(to_remove, (GFunc) purple_blist_remove_buddy, NULL);
g_list_free(to_remove);
}
}
void AccountCollector::collectNow(PurpleAccount *account, bool remove) {
if (account->ui_data == NULL) {
Log("AccountCollector","freeing account " << purple_account_get_username(account));
if (remove)
g_hash_table_remove(m_accounts, purple_account_get_username(account));
purple_account_set_enabled(account, purple_core_get_ui(), FALSE);
purple_notify_close_with_handle(account);
purple_request_close_with_handle(account);
purple_accounts_remove(account);
GSList *buddies = purple_find_buddies(account, NULL);
while(buddies) {
PurpleBuddy *b = (PurpleBuddy *) buddies->data;
purple_blist_remove_buddy(b);
buddies = g_slist_delete_link(buddies, buddies);
}
/* Remove any open conversation for this account */
for (GList *it = purple_get_conversations(); it; ) {
PurpleConversation *conv = (PurpleConversation *) it->data;
it = it->next;
if (purple_conversation_get_account(conv) == account)
purple_conversation_destroy(conv);
}
/* Remove this account's pounces */
// purple_pounce_destroy_all_by_account(account);
/* This will cause the deletion of an old buddy icon. */
purple_buddy_icons_set_account_icon(account, NULL, 0);
purple_account_destroy(account);
// VALGRIND_DO_LEAK_CHECK;
}
}
// purple event callbacks
void IMInvoker::signedOnCB(PurpleConnection *gc, gpointer null) {
PurpleAccount *account = purple_connection_get_account(gc);
GET_INSTANCE_IN_CALLBACK(account);
if (!inst)
return;
#if 0
GSList *buddies = purple_find_buddies(purple_connection_get_account(gc), NULL);
GSList *cur;
for (cur = buddies; cur; cur = cur->next) {
buddyAddedCB((PurpleBuddy *)cur->data);
}
g_slist_free(buddies);
#endif
// set my status to active
PurpleSavedStatus* status = purple_savedstatus_new(NULL, PURPLE_STATUS_AVAILABLE);
purple_savedstatus_activate(status);
Event retEv("im.signed.on");
inst->returnEvent(retEv);
}
void jabber_roster_group_change(PurpleConnection *gc, const char *name,
const char *old_group, const char *new_group)
{
GSList *buddies, *groups = NULL;
PurpleBuddy *b;
PurpleGroup *g;
if(!old_group || !new_group || !strcmp(old_group, new_group))
return;
buddies = purple_find_buddies(gc->account, name);
while(buddies) {
b = buddies->data;
g = purple_buddy_get_group(b);
if(!strcmp(g->name, old_group))
groups = g_slist_append(groups, (char*)new_group); /* ick */
else
groups = g_slist_append(groups, g->name);
buddies = g_slist_remove(buddies, b);
}
jabber_roster_update(gc->proto_data, name, groups);
g_slist_free(groups);
}
/*
* \brief Concatenates buddy strings to textual list
*
* This function assembles all the buddies of one account in one big string to
* later write them into a file at once.
*
* \param account The account whose buddies will be concatenated.
*
* \returns Whole buddy list of an account as string. The returned string has to
* be freed by the caller later on.
*/
static char *assemble_accounts_buddy_list_string(PurpleAccount *account)
{
char *string = NULL;
char *current_buddy_string = NULL;
char *tmp = NULL;
GSList *current = purple_find_buddies(account, NULL);
for (; current != NULL; current = g_slist_next(current)) {
current_buddy_string = get_buddy_string(current->data);
if (string != NULL) {
tmp = g_strconcat(string, current_buddy_string, NULL);
g_free(string);
} else {
tmp = g_strdup(current_buddy_string);
}
g_free(current_buddy_string);
string = tmp;
}
return (string) ? string : g_strdup("");
}
/* This makes sure that only all the buddies are in the permit list. */
static void
add_buddies_in_permit(PurpleAccount *account, gboolean local)
{
GSList *list;
/* Remove anyone in the permit list who is not in the buddylist */
for (list = account->permit; list != NULL; ) {
char *person = list->data;
list = list->next;
if (!purple_find_buddy(account, person))
purple_privacy_permit_remove(account, person, local);
}
/* Now make sure everyone in the buddylist is in the permit list */
list = purple_find_buddies(account, NULL);
while (list != NULL)
{
PurpleBuddy *buddy = list->data;
if (!g_slist_find_custom(account->permit, buddy->name, (GCompareFunc)g_utf8_collate))
purple_privacy_permit_add(account, buddy->name, local);
list = g_slist_delete_link(list, list);
}
}
void jabber_roster_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy,
PurpleGroup *group) {
const char *name = purple_buddy_get_name(buddy);
GSList *buddies = purple_find_buddies(purple_connection_get_account(gc), name);
buddies = g_slist_remove(buddies, buddy);
if(buddies != NULL) {
PurpleBuddy *tmpbuddy;
PurpleGroup *tmpgroup;
GSList *groups = NULL;
while(buddies) {
tmpbuddy = buddies->data;
tmpgroup = purple_buddy_get_group(tmpbuddy);
groups = g_slist_append(groups, (char *)purple_group_get_name(tmpgroup));
buddies = g_slist_remove(buddies, tmpbuddy);
}
purple_debug_info("jabber", "jabber_roster_remove_buddy(): Removing %s from %s\n",
purple_buddy_get_name(buddy), purple_group_get_name(group));
jabber_roster_update(gc->proto_data, name, groups);
} else {
JabberIq *iq = jabber_iq_new_query(gc->proto_data, JABBER_IQ_SET,
"jabber:iq:roster");
xmlnode *query = xmlnode_get_child(iq->node, "query");
xmlnode *item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "jid", name);
xmlnode_set_attrib(item, "subscription", "remove");
purple_debug_info("jabber", "jabber_roster_remove_buddy(): Removing %s\n",
purple_buddy_get_name(buddy));
jabber_iq_send(iq);
}
}
GList *fb_get_buddies_friend_list (FacebookAccount *fba,
const gchar *uid, JsonArray *friend_list_ids)
{
GSList *buddies;
GSList *cur;
GHashTable *cur_groups;
int i;
GList *final_buddies, *cur_buddy;
PurpleGroup *fb_group;
PurpleBuddy *buddy;
final_buddies = NULL;
buddies = purple_find_buddies(fba->account, uid);
// If we're already in the buddy list, stop. Ignore FB info because
// it will be incorrect.
if (atoll(uid) == fba->uid && buddies != NULL) {
purple_debug_info("facebook",
"already have buddies for self, not adding\n");
for (cur = buddies; cur != NULL; cur = cur->next)
{
final_buddies = g_list_append(
final_buddies, cur->data);
}
g_slist_free(buddies);
return final_buddies;
}
//Do we want to ignore groups?
if (!purple_account_get_bool(fba->account, "facebook_use_groups", TRUE))
{
if (buddies != NULL) {
//Copy the slist into the list
for (cur = buddies; cur != NULL; cur = cur->next)
{
final_buddies = g_list_append(
final_buddies, cur->data);
}
g_slist_free(buddies);
return final_buddies;
} else {
buddy = purple_buddy_new(fba->account, uid, NULL);
fb_group = purple_find_group(DEFAULT_GROUP_NAME);
if (fb_group == NULL)
{
fb_group = purple_group_new(DEFAULT_GROUP_NAME);
purple_blist_add_group(fb_group, NULL);
}
purple_blist_add_buddy(buddy, NULL, fb_group, NULL);
final_buddies = g_list_append(final_buddies, buddy);
return final_buddies;
}
}
// Determine what buddies exist and what groups they are in.
cur_groups = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, NULL);
for (cur = buddies; cur != NULL; cur = cur->next)
{
const gchar *group_name;
group_name = purple_group_get_name(purple_buddy_get_group(
(PurpleBuddy *)cur->data));
group_name = purple_normalize_nocase(NULL, group_name);
g_hash_table_insert(cur_groups, g_strdup(group_name), cur->data);
}
g_slist_free(buddies);
// Create/insert necessary buddies
if (friend_list_ids) {
for (i = 0; i < json_array_get_length(friend_list_ids); i++)
{
const gchar *friend_list_id;
friend_list_id = json_node_get_string(
json_array_get_element(friend_list_ids, i));
buddy = add_buddy(fba, friend_list_id, uid, cur_groups);
final_buddies = g_list_append(final_buddies, buddy);
}
} else {
// No friend list data, so we use the default group.
final_buddies = g_list_append(final_buddies,
add_buddy(fba, "-1", uid, cur_groups));
}
// Figure out which groups/buddies are not represented.
for (cur_buddy = final_buddies; cur_buddy != NULL;
cur_buddy = cur_buddy->next)
{
const gchar *group_name = purple_group_get_name(purple_buddy_get_group(
(PurpleBuddy *)cur_buddy->data));
g_hash_table_remove(cur_groups, purple_normalize_nocase(NULL, group_name));
}
// Delete remaining buddies to maintain sync state with server.
g_hash_table_foreach(cur_groups, destroy_buddy, fba);
// Cleanup!
g_hash_table_destroy(cur_groups);
return final_buddies;
}
static void historize(PurpleConversation *c)
{
PurpleAccount *account = purple_conversation_get_account(c);
const char *name = purple_conversation_get_name(c);
PurpleConversationType convtype;
GList *logs = NULL;
const char *alias = name;
PurpleLogReadFlags flags;
char *history;
char *header;
PurpleMessageFlags mflag;
convtype = purple_conversation_get_type(c);
if (convtype == PURPLE_CONV_TYPE_IM) {
GSList *buddies;
GSList *cur;
FinchConv *fc = FINCH_CONV(c);
if (fc->list && fc->list->next) /* We were already in the middle of a conversation. */
return;
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_ims"))
return;
/* Find buddies for this conversation. */
buddies = purple_find_buddies(account, name);
/* If we found at least one buddy, save the first buddy's alias. */
if (buddies != NULL)
alias = purple_buddy_get_contact_alias((PurpleBuddy *)buddies->data);
for (cur = buddies; cur != NULL; cur = cur->next) {
PurpleBlistNode *node = cur->data;
if ((node != NULL) &&
((purple_blist_node_get_sibling_prev(node) != NULL) ||
(purple_blist_node_get_sibling_next(node) != NULL))) {
PurpleBlistNode *node2;
alias = purple_buddy_get_contact_alias((PurpleBuddy *)node);
/* We've found a buddy that matches this conversation. It's part of a
* PurpleContact with more than one PurpleBuddy. Loop through the PurpleBuddies
* in the contact and get all the logs. */
for (node2 = purple_blist_node_get_first_child(purple_blist_node_get_parent(node));
node2 != NULL ; node2 = purple_blist_node_get_sibling_next(node2)) {
logs = g_list_concat(
purple_log_get_logs(PURPLE_LOG_IM,
purple_buddy_get_name((PurpleBuddy *)node2),
purple_buddy_get_account((PurpleBuddy *)node2)),
logs);
}
break;
}
}
g_slist_free(buddies);
if (logs == NULL)
logs = purple_log_get_logs(PURPLE_LOG_IM, name, account);
else
logs = g_list_sort(logs, purple_log_compare);
} else if (convtype == PURPLE_CONV_TYPE_CHAT) {
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_chats"))
return;
logs = purple_log_get_logs(PURPLE_LOG_CHAT, name, account);
}
if (logs == NULL)
return;
mflag = PURPLE_MESSAGE_NO_LOG | PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_DELAYED;
history = purple_log_read((PurpleLog*)logs->data, &flags);
header = g_strdup_printf(_("<b>Conversation with %s on %s:</b><br>"), alias,
purple_date_format_full(localtime(&((PurpleLog *)logs->data)->time)));
purple_conversation_write(c, "", header, mflag, time(NULL));
g_free(header);
if (flags & PURPLE_LOG_READ_NO_NEWLINE)
purple_str_strip_char(history, '\n');
purple_conversation_write(c, "", history, mflag, time(NULL));
g_free(history);
purple_conversation_write(c, "", "<hr>", mflag, time(NULL));
g_list_foreach(logs, (GFunc)purple_log_free, NULL);
g_list_free(logs);
}
