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); }