static VALUE remove_buddy(VALUE self, VALUE buddy) { PurpleAccount *account = NULL; PurpleConnection *gc = NULL; Data_Get_Struct(self, PurpleAccount, account); gc = purple_account_get_connection( account ); PurpleBuddy* pb = purple_find_buddy(account, RSTRING_PTR(buddy)); if (NULL == pb) { rb_raise(rb_eRuntimeError, "Failed to remove buddy for %s : %s does not exist", purple_account_get_username(account), RSTRING_PTR(buddy)); } char* group = _("Buddies"); PurpleGroup* grp = purple_find_group(group); if (!grp) { grp = purple_group_new(group); purple_blist_add_group(grp, NULL); } purple_blist_remove_buddy(pb); purple_account_remove_buddy(account, pb, grp); serv_rem_permit( gc, RSTRING_PTR( buddy ) ); return Qtrue; }
void BuddyListContact::ContactContextMenu::removeResponseHandler( CppConsUI::MessageDialog& /*activator*/, CppConsUI::AbstractDialog::ResponseType response) { if (response != CppConsUI::AbstractDialog::RESPONSE_OK) return; // based on gtkdialogs.c:pidgin_dialogs_remove_contact_cb() PurpleContact *contact = parent_contact->getPurpleContact(); PurpleBlistNode *cnode = PURPLE_BLIST_NODE(contact); PurpleGroup *group = purple_contact_get_group(contact); for (PurpleBlistNode *bnode = purple_blist_node_get_first_child(cnode); bnode; bnode = purple_blist_node_get_sibling_next(bnode)) { PurpleBuddy *buddy = PURPLE_BUDDY(bnode); PurpleAccount *account = purple_buddy_get_account(buddy); if (purple_account_is_connected(account)) purple_account_remove_buddy(account, buddy, group); } /* Close the context menu before the contact is deleted because its deletion * can lead to destruction of this object. */ close(); purple_blist_remove_contact(contact); }
bool PurpleIMContactList::removeContactCbk(void * dataIn) { // Mutex::ScopedLock lock(PurpleIMContactList::_mutex); Mutex::ScopedLock lock(PurpleIMContactList::_mutexContact); //VOXOX - JRT - 2009.07.14 PurpleIMContactListCallbackData* cbData = (PurpleIMContactListCallbackData*)dataIn; PurpleAccount *gAccount = getPurpleAccount( cbData->getInstance() ); PurpleGroup *gGroup = NULL; PurpleBuddy *gBuddy = NULL; if ( !cbData->getGroupName().empty() ) { gGroup = purple_find_group( cbData->getGroupName().c_str() ); gBuddy = purple_find_buddy_in_group(gAccount, cbData->getContactId().c_str(), gGroup ); } else { gBuddy = purple_find_buddy(gAccount, cbData->getContactId().c_str() ); } if (gBuddy) { purple_account_remove_buddy(gAccount, gBuddy, gGroup); purple_blist_remove_buddy(gBuddy); } timeoutRemove( cbData ); delete cbData; return TRUE; }
static void purple_remove_buddy( struct im_connection *ic, char *who, char *group ) { PurpleBuddy *pb; pb = purple_find_buddy( (PurpleAccount*) ic->proto_data, who ); if( pb != NULL ) { PurpleGroup *group; group = purple_buddy_get_group( pb ); purple_account_remove_buddy( (PurpleAccount*) ic->proto_data, pb, group ); purple_blist_remove_buddy( pb ); } purple_gg_buddylist_export( ((PurpleAccount*)ic->proto_data)->gc ); }
void BuddyListBuddy::BuddyContextMenu::removeResponseHandler( CppConsUI::MessageDialog& /*activator*/, CppConsUI::AbstractDialog::ResponseType response) { if (response != CppConsUI::AbstractDialog::RESPONSE_OK) return; PurpleBuddy *buddy = parent_buddy->getPurpleBuddy(); purple_account_remove_buddy(purple_buddy_get_account(buddy), buddy, purple_buddy_get_group(buddy)); /* Close the context menu before the buddy is deleted because its deletion * can lead to destruction of this object. */ close(); purple_blist_remove_buddy(buddy); }
void BuddyListGroup::GroupContextMenu::removeResponseHandler( CppConsUI::MessageDialog& /*activator*/, CppConsUI::AbstractDialog::ResponseType response) { if (response != CppConsUI::AbstractDialog::RESPONSE_OK) return; // based on gtkdialogs.c:pidgin_dialogs_remove_group_cb() PurpleGroup *group = parent_group->getPurpleGroup(); PurpleBlistNode *cnode = purple_blist_node_get_first_child( PURPLE_BLIST_NODE(group)); while (cnode) { if (PURPLE_BLIST_NODE_IS_CONTACT(cnode)) { PurpleBlistNode *bnode = purple_blist_node_get_first_child(cnode); cnode = purple_blist_node_get_sibling_next(cnode); while (bnode) if (PURPLE_BLIST_NODE_IS_BUDDY(bnode)) { PurpleBuddy *buddy = PURPLE_BUDDY(bnode); PurpleAccount *account = purple_buddy_get_account(buddy); bnode = purple_blist_node_get_sibling_next(bnode); if (purple_account_is_connected(account)) { purple_account_remove_buddy(account, buddy, group); purple_blist_remove_buddy(buddy); } } else bnode = purple_blist_node_get_sibling_next(bnode); } else if (PURPLE_BLIST_NODE_IS_CHAT(cnode)) { PurpleChat *chat = PURPLE_CHAT(cnode); cnode = purple_blist_node_get_sibling_next(cnode); purple_blist_remove_chat(chat); } else cnode = purple_blist_node_get_sibling_next(cnode); } /* Close the context menu before the group is deleted because its deletion * can lead to destruction of this object. */ close(); purple_blist_remove_group(group); }
static VALUE remove_buddy(VALUE self, VALUE buddy) { PurpleAccount *account; Data_Get_Struct(self, PurpleAccount, account); PurpleBuddy* pb = purple_find_buddy(account, StringValueCStr(buddy)); if (NULL == pb) { rb_raise(rb_eRuntimeError, "Failed to remove buddy for %s : %s does not exist", purple_account_get_username(account), StringValueCStr(buddy)); } char* group = _("Buddies"); PurpleGroup* grp = purple_find_group(group); if (!grp) { grp = purple_group_new(group); purple_blist_add_group(grp, NULL); } purple_blist_remove_buddy(pb); purple_account_remove_buddy(account, pb, grp); return Qtrue; }
xmlnode * _h_elim_remove_buddy ( const char *name , const char *id , SEXP_VALUE *args , gpointer data ) { ASSERT_ALISTP( args, id, name ); fprintf( stderr, "(elim-remove-buddy)\n" ); elim_ping(); const char *aname = ALIST_VAL_STR( args, "account-name" ); const char *proto = ALIST_VAL_STR( args, "im-protocol" ); gpointer auid = ALIST_VAL_PTR( args, "account-uid" ); PurpleAccount *acct = NULL; gpointer b_uid = ALIST_VAL_PTR( args, "bnode-uid" ); const char *b_arg = NULL; const char *bname = NULL; const char *gname = NULL; PurpleGroup *group = NULL; PurpleBuddy *buddy = NULL; gboolean gone = FALSE; if( b_uid ) { PurpleBlistNodeType type = PURPLE_BLIST_OTHER_NODE; PurpleBlistNode *node = find_blist_node_by_uid( b_uid , TRUE ); if( !node ) { sexp_val_free( args ); return response_error( EINVAL, id, name, "rogue buddy pointer" ); } type = purple_blist_node_get_type( node ); // =========================================================== // groups, contacts and chats can safely be removed here: // buddies should instead be noted for removal in the next // block of code as they require client<->server interaction: switch( type ) { case PURPLE_BLIST_GROUP_NODE : purple_blist_remove_group ( (PurpleGroup *)node ); gone = TRUE; break; case PURPLE_BLIST_CONTACT_NODE: purple_blist_remove_contact( (PurpleContact *)node ); gone = TRUE; break; case PURPLE_BLIST_CHAT_NODE : FIND_ACCOUNT( args, id, name, acct, auid, aname, proto ); BNODE_ACCOUNT_CHECK(chat,(PurpleChat *)node, acct, args, id, name); purple_blist_remove_chat ( (PurpleChat *)node ); gone = TRUE; break; case PURPLE_BLIST_BUDDY_NODE : buddy = (PurpleBuddy *)node; FIND_ACCOUNT( args, id, name, acct, auid, aname, proto ); BNODE_ACCOUNT_CHECK( buddy, buddy, acct, args, id, name ); b_arg = purple_buddy_get_name( buddy ); bname = purple_normalize( acct, b_arg ); break; default: sexp_val_free( args ); return response_error( EINVAL, id, name, "Unknown buddy list node type" ); } if( gone ) { xmlnode *rval = xnode_new( "alist" ); if( acct ) { AL_STR( rval, "account-name", aname ); AL_STR( rval, "im-protocol" , proto ); AL_PTR( rval, "account-uid" , acct ); } AL_PTR ( rval, "bnode-uid" , buddy ); AL_ENUM( rval, "bnode-type", type , ":blist-node-type" ); sexp_val_free( args ); return response_value( 0, id, name, rval ); } } else { b_arg = ALIST_VAL_STRING( args, "bnode-name" ); FIND_ACCOUNT( args, id, name, acct, auid, aname, proto ); if( b_arg ) { bname = purple_normalize( acct, b_arg ); gname = ALIST_VAL_STRING( args, "group" ); group = ( gname && *gname ) ? purple_find_group( gname ) : NULL; buddy = ( group ? purple_find_buddy_in_group( acct, bname, group ) : purple_find_buddy ( acct, bname ) ); } } if( !b_arg || !*b_arg ) { sexp_val_free( args ); return response_error( EINVAL, id, name, "buddy not specified" ); } // buddy must be in our local list or libpurple won't remove it from the // server list ( determined empirically, confirmed by inspecting code ): if( !buddy ) { buddy = purple_buddy_new( acct, bname, bname ); purple_blist_add_buddy ( buddy, NULL, NULL, NULL ); } if( buddy ) { // the order of the remove operations is important: it has to be // this way round, as noted above: account buddy removal won't // happen if the buddy is not in the blist when we try: if( !group ) group = purple_buddy_get_group( buddy ); // is this correct? what if we have more than one copy of said buddy? // potentially confusing. dunno what the right thing to do is here. purple_account_remove_buddy( acct, buddy, group ); purple_blist_remove_buddy( buddy ); } else { sexp_val_free( args ); return response_error( ENXIO, id, name, "no such buddy" ); } xmlnode *rval = xnode_new( "alist" ); AL_STR ( rval, "account-name", purple_account_get_username ( acct ) ); AL_STR ( rval, "im-protocol" , purple_account_get_protocol_id( acct ) ); AL_PTR ( rval, "account-uid" , acct ); AL_PTR ( rval, "bnode-uid" , buddy ); AL_ENUM( rval, "bnode-type", PURPLE_BLIST_BUDDY_NODE, ":blist-node-type" ); sexp_val_free( args ); return response_value( 0, id, name, rval ); }
void SpectrumRosterManager::handleSubscription(const Subscription &subscription) { std::string remote_user = purpleUsername(subscription.to().username()); if (remote_user.empty()) { Log(m_user->jid(), "handleSubscription: Remote user is EMPTY!"); return; } if (m_user->isConnected()) { PurpleBuddy *buddy = NULL; // Try to get PurpleBuddy from SpectrumBuddy at first, because SpectrumBuddy // uses normalized username (buddy->name could be "User", but remote_user is normalized // so it's "user" for example). AbstractSpectrumBuddy *s_buddy = getRosterItem(remote_user); if (s_buddy) buddy = s_buddy->getBuddy(); else buddy = purple_find_buddy(m_user->account(), remote_user.c_str()); if (subscription.subtype() == Subscription::Subscribed) { // Accept authorize request. if (hasAuthRequest(remote_user)) { Log(m_user->jid(), "subscribed presence for authRequest arrived => accepting the request"); m_authRequests[remote_user]->authorize_cb(m_authRequests[remote_user]->user_data); removeAuthRequest(remote_user); } if (!isInRoster(remote_user, "both")) { if (buddy) { Log(m_user->jid(), "adding this user to local roster and sending presence"); if (s_buddy == NULL) { // There is PurpleBuddy, but not SpectrumBuddy (that should not happen, but this // code doesn't break anything). addRosterItem(buddy); Transport::instance()->sql()->addBuddy(m_user->storageId(), remote_user, "both"); storeBuddy(buddy); } else { // Update subscription. s_buddy->setSubscription("both"); Transport::instance()->sql()->updateBuddySubscription(m_user->storageId(), remote_user, "both"); storeBuddy(buddy); } } else { Log(m_user->jid(), "user is not in legacy network contact lists => nothing to be subscribed"); } } // XMPP user is able to get the first status presence just after "subscribed" presence. if (s_buddy) { sendPresence(s_buddy); } return; } else if (subscription.subtype() == Subscription::Subscribe) { // User is in roster, so that's probably response for RIE. if (s_buddy) { Log(m_user->jid(), "subscribe presence; user is already in roster => sending subscribed"); s_buddy->setSubscription("to"); Tag *reply = new Tag("presence"); reply->addAttribute( "to", subscription.from().bare() ); reply->addAttribute( "from", subscription.to().bare() ); reply->addAttribute( "type", "subscribe" ); Transport::instance()->send( reply ); reply = new Tag("presence"); reply->addAttribute( "to", subscription.from().bare() ); reply->addAttribute( "from", subscription.to().bare() ); reply->addAttribute( "type", "subscribed" ); Transport::instance()->send( reply ); // Sometimes there is "subscribed" request for new user received before "subscribe", // so s_buddy could be already there, but purple_account_add_buddy has not been called. if (buddy) { Log(m_user->jid(), "Trying to purple_account_add_buddy just to be sure."); purple_account_add_buddy(m_user->account(), buddy); } } // User is not in roster, so that's probably new subscribe request. else { Log(m_user->jid(), "subscribe presence; user is not in roster => adding to legacy network"); // Disable handling new-buddy event, because we're going to create new buddy by Spectrum, not // by libpurple (so we don't want to add it to RIE queue and send back to XMPP user). m_loadingFromDB = true; PurpleBuddy *buddy = purple_buddy_new(m_user->account(), remote_user.c_str(), remote_user.c_str()); #ifndef TESTS SpectrumBuddy *s_buddy = new SpectrumBuddy(-1, buddy); buddy->node.ui_data = (void *) s_buddy; s_buddy->setSubscription("to"); if (usesJidEscaping(subscription.to().username())) s_buddy->setFlags(s_buddy->getFlags() | SPECTRUM_BUDDY_JID_ESCAPING); addRosterItem(s_buddy); #endif // Add newly created buddy to legacy network roster. purple_blist_add_buddy(buddy, NULL, NULL ,NULL); purple_account_add_buddy(m_user->account(), buddy); m_loadingFromDB = false; } return; } else if (subscription.subtype() == Subscription::Unsubscribe || subscription.subtype() == Subscription::Unsubscribed) { if (subscription.subtype() == Subscription::Unsubscribed) { // Reject authorize request. if (hasAuthRequest(remote_user)) { Log(m_user->jid(), "unsubscribed presence for authRequest arrived => rejecting the request"); m_authRequests[remote_user]->deny_cb(m_authRequests[remote_user]->user_data); removeAuthRequest(remote_user); return; } } // Buddy is in legacy network roster, so we can remove it. if (buddy) { Log(m_user->jid(), "unsubscribed presence => removing this contact from legacy network"); // Remove buddy from database, if he's already there. if (s_buddy) { long id = s_buddy->getId(); Transport::instance()->sql()->removeBuddy(m_user->storageId(), remote_user, id); } // Remove buddy from legacy network roster. purple_account_remove_buddy(m_user->account(), buddy, purple_buddy_get_group(buddy)); purple_blist_remove_buddy(buddy); } else { // this buddy is not in legacy network roster, so there is nothing to remove... } removeFromLocalRoster(remote_user); // inform user about removing this buddy Tag *tag = new Tag("presence"); tag->addAttribute("to", subscription.from().bare()); tag->addAttribute("from", subscription.to().username() + "@" + Transport::instance()->jid() + "/bot"); if(subscription.subtype() == Subscription::Unsubscribe) { tag->addAttribute( "type", "unsubscribe" ); } else { tag->addAttribute( "type", "unsubscribed" ); } Transport::instance()->send( tag ); return; } } else { Log(subscription.from().full(), "Subscribe presence received, but is not connected to legacy network yet."); } }
void IMInvoker::send(void *userdata, const std::string event) { // we are in the thread that manages all of libpurple EventContext* ctx = (EventContext*)userdata; if (!ctx) return; if (!ctx->instance || !ctx->instance->_account) { ctx->instance->returnErrorExecution("No account available"); delete(ctx); return; } if (iequals(ctx->sendReq.name, "im.send")) { std::string receiver; Event::getParam(ctx->sendReq.params, "receiver", receiver); Data data; Event::getParam(ctx->sendReq.params, "data", data); #if LIBPURPLE_VERSION_MAJOR >= 3 PurpleIMConversation* conv = purple_im_conversation_new(ctx->instance->_account, receiver.c_str()); if (ctx->sendReq.content.length() > 0) purple_conversation_send(PURPLE_CONVERSATION(conv), ctx->sendReq.content.c_str()); #else PurpleConversation* conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, ctx->instance->_account, receiver.c_str()); if (ctx->sendReq.content.length() > 0) purple_conv_im_send(purple_conversation_get_im_data(conv), ctx->sendReq.content.c_str()); #endif #if 0 if (data.binary) { PurpleConnection *gc = purple_account_get_connection(ctx->instance->_account); PurplePlugin *prpl; PurplePluginProtocolInfo *prpl_info; if (gc) { prpl = purple_connection_get_prpl(gc); prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); // if (prpl_info && prpl_info->new_xfer) { // PurpleXfer* xfer = (prpl_info->new_xfer)(purple_account_get_connection(ctx->instance->_account), receiver.c_str()); // purple_xfer_set_local_filename(xfer, "/Users/sradomski/Documents/W3C Standards.pdf"); // purple_xfer_set_filename(xfer, "asdfadsf.pdf"); // purple_xfer_request(xfer); // purple_xfer_request_accepted(xfer, "/Users/sradomski/Documents/W3C Standards.pdf"); // } //Set the filename // purple_xfer_set_local_filename(xfer, [[fileTransfer localFilename] UTF8String]); // purple_xfer_set_filename(xfer, [[[fileTransfer localFilename] lastPathComponent] UTF8String]); // xfer->ui_data // purple_xfer_request(xfer); serv_send_file(gc, "sradomski@localhost", "/Users/sradomski/Documents/W3C Standards.pdf"); // if (prpl_info->send_file && (prpl_info->can_receive_file && prpl_info->can_receive_file(gc, receiver.c_str()))) { // prpl_info->send_file(gc, receiver.c_str(), "/Users/sradomski/Documents/W3C Standards.pdf"); // } // prpl_info->send_raw(gc, data.binary->data, data.binary->size); } } #endif } else if (iequals(ctx->sendReq.name, "im.buddy.add")) { std::string buddyName; Event::getParam(ctx->sendReq.params, "name", buddyName); std::string reqMsg; Event::getParam(ctx->sendReq.params, "msg", reqMsg); PurpleBuddy* buddy = purple_buddy_new(ctx->instance->_account, buddyName.c_str(), NULL); purple_blist_add_buddy(buddy, NULL, NULL, NULL); #if LIBPURPLE_VERSION_MAJOR >= 3 purple_account_add_buddy(ctx->instance->_account, buddy, reqMsg.c_str()); #else purple_account_add_buddy(ctx->instance->_account, buddy); #endif } else if (iequals(ctx->sendReq.name, "im.buddy.remove")) { std::string buddyName; Event::getParam(ctx->sendReq.params, "name", buddyName); #if LIBPURPLE_VERSION_MAJOR >= 3 PurpleBuddy* buddy = purple_blist_find_buddy(ctx->instance->_account, buddyName.c_str()); if (PURPLE_IS_BUDDY(buddy)) { purple_account_remove_buddy(ctx->instance->_account, buddy, purple_buddy_get_group(buddy)); purple_blist_remove_buddy(buddy); } #else PurpleBuddy* buddy = purple_find_buddy(ctx->instance->_account, buddyName.c_str()); purple_account_remove_buddy(ctx->instance->_account, buddy, purple_buddy_get_group(buddy)); purple_blist_remove_buddy(buddy); #endif } delete(ctx); }