bool PurpleIMContactList::addContactCbk(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 ((gGroup = purple_find_group(cbData->getGroupName().c_str())) == NULL) { gGroup = purple_group_new(cbData->getGroupName().c_str()); purple_blist_add_group(gGroup, NULL); } gBuddy = purple_buddy_new(gAccount, cbData->getContactId().c_str(), cbData->getContactId().c_str() ); purple_blist_add_buddy(gBuddy, NULL, gGroup, NULL); purple_account_add_buddy(gAccount, gBuddy); timeoutRemove( cbData ); delete cbData; return TRUE; }
void gevo_add_buddy(PurpleAccount *account, const char *group_name, const char *buddy_name, const char *alias) { PurpleConversation *conv = NULL; PurpleBuddy *buddy; PurpleGroup *group; conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, buddy_name, account); group = purple_find_group(group_name); if (group == NULL) { group = purple_group_new(group_name); purple_blist_add_group(group, NULL); } buddy = purple_find_buddy_in_group(account, buddy_name, group); if (buddy == NULL) { buddy = purple_buddy_new(account, buddy_name, alias); purple_blist_add_buddy(buddy, NULL, group, NULL); } purple_account_add_buddy(account, buddy); if (conv != NULL) { purple_buddy_icon_update(purple_conv_im_get_icon(PURPLE_CONV_IM(conv))); purple_conversation_update(conv, PURPLE_CONV_UPDATE_ADD); } }
void lh_util_add_buddy(const gchar *group, PurpleGroup *purple_group, const gchar *buddy, const gchar *alias, PurpleAccount *account, const gchar *buddynotes, gint signed_on, gint signed_off, gint lastseen, gint last_seen, const gchar *gf_theme, const gchar *icon_file, gchar *lastsaid) { PurpleBuddy *purple_buddy = NULL; PurpleBlistNode *node = NULL; purple_buddy = purple_buddy_new(account, buddy, alias); node = (PurpleBlistNode *)purple_buddy; purple_blist_add_buddy(purple_buddy, NULL, purple_group, NULL); #if PURPLE_VERSION_CHECK(3,0,0) purple_account_add_buddy(account, purple_buddy, NULL); #else purple_account_add_buddy(account, purple_buddy); #endif if(buddynotes) purple_blist_node_set_string(node, "notes", buddynotes); if(signed_on) purple_blist_node_set_int(node, "signedon", signed_on); if(signed_off) purple_blist_node_set_int(node, "signedoff", signed_off); if(lastseen) purple_blist_node_set_int(node, "lastseen", lastseen); if(last_seen) purple_blist_node_set_int(node, "last_seen", last_seen); if(gf_theme) purple_blist_node_set_string(node, "guifications-theme", gf_theme); if(icon_file) purple_blist_node_set_string(node, "buddy_icon", icon_file); if(lastsaid) purple_blist_node_set_string(node, "lastsaid", lastsaid); purple_debug_info("listhandler: import", "group: %s\tbuddy: %s\talias: %s\thas been added to the list\n", group, buddy, alias ? alias : "NULL"); return; }
void BuddyList::add_buddy_ok_cb(PurpleRequestFields *fields) { PurpleAccount *account = purple_request_fields_get_account(fields, "account"); const char *name = purple_request_fields_get_string(fields, "name"); const char *alias = purple_request_fields_get_string(fields, "alias"); int selected = purple_request_fields_get_choice(fields, "group"); GList *list = purple_request_field_choice_get_labels( purple_request_fields_get_field(fields, "group")); const char *group = reinterpret_cast<const char*>(g_list_nth_data(list, selected)); bool err = false; if (!account) { LOG->Message(_("No account specified.")); err = true; } else if (!purple_account_is_connected(account)) { LOG->Message(_("Selected account is not connected.")); err = true; } if (!name || !name[0]) { LOG->Message(_("No buddy name specified.")); err = true; } if (!group || !group[0]) { LOG->Message(_("No group name specified.")); err = true; } if (err) { purple_blist_request_add_buddy(account, name, group, alias); return; } PurpleGroup *g = purple_find_group(group); if (!g) { g = purple_group_new(group); purple_blist_add_group(g, NULL); } PurpleBuddy *b = purple_find_buddy_in_group(account, name, g); if (b) { LOG->Message(_("Specified buddy is already in the list.")); return; } if (alias && !alias[0]) alias = NULL; b = purple_buddy_new(account, name, alias); purple_blist_add_buddy(b, NULL, g, NULL); purple_account_add_buddy(account, b); }
static void purple_add_buddy( struct im_connection *ic, char *who, char *group ) { PurpleBuddy *pb; PurpleGroup *pg = NULL; if( group && !( pg = purple_find_group( group ) ) ) { pg = purple_group_new( group ); purple_blist_add_group( pg, NULL ); } pb = purple_buddy_new( (PurpleAccount*) ic->proto_data, who, NULL ); purple_blist_add_buddy( pb, NULL, pg, NULL ); purple_account_add_buddy( (PurpleAccount*) ic->proto_data, pb ); purple_gg_buddylist_export( ((PurpleAccount*)ic->proto_data)->gc ); }
static VALUE add_buddy(VALUE self, VALUE buddy) { PurpleAccount *account; Data_Get_Struct(self, PurpleAccount, account); PurpleBuddy* pb = purple_buddy_new(account, StringValueCStr(buddy), NULL); char* group = _("Buddies"); PurpleGroup* grp = purple_find_group(group); if (!grp) { grp = purple_group_new(group); purple_blist_add_group(grp, NULL); } purple_blist_add_buddy(pb, NULL, grp, NULL); purple_account_add_buddy(account, pb); return Qtrue; }
static VALUE add_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_buddy_new(account, RSTRING_PTR(buddy), NULL); char* group = _("Buddies"); PurpleGroup* grp = purple_find_group(group); if (!grp) { grp = purple_group_new(group); purple_blist_add_group(grp, NULL); } purple_blist_add_buddy(pb, NULL, grp, NULL); purple_account_add_buddy(account, pb); serv_add_permit( gc, RSTRING_PTR(buddy) ); return Qtrue; }
xmlnode * _h_elim_add_buddy ( const char *name , const char *id , SEXP_VALUE *args , gpointer data ) { ASSERT_ALISTP( args, id, name ); elim_ping(); int loopc = 0; 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 = auid ? find_acct_by_uid( auid ) : purple_accounts_find( aname, proto ); if( !acct ) { sexp_val_free( args ); return response_error( ENXIO, id, name, "unknown account" ); } const char *b_arg = ALIST_VAL_STRING( args, "bnode-name" ); const char *bname = purple_normalize( acct, b_arg ); const char *gname = ALIST_VAL_STRING( args, "group" ); if( !gname || !*gname ) gname = "Buddies"; PurpleGroup *group = purple_group_new( gname ); PurpleBuddy *buddy = purple_buddy_new( acct, bname, b_arg ); PurpleBuddy *clone = NULL; //fprintf( stderr, "add-buddy( b: %p, g: %p )\n", buddy, group ); // remove other references to this buddy purple_blist_add_buddy ( buddy, NULL, group, NULL ); purple_account_add_buddy( acct , buddy ); while( ( clone = (PurpleBuddy*)find_blist_node_clone( buddy ) ) ) { if( loopc++ > 99 ) { fprintf( stderr, "ARGH! clone reaping looped: %d\n", loopc ); break; } if( clone == buddy ) { fprintf( stderr, "ARGH! %p not a clone of %p\n", buddy, clone ); break; } fprintf( stderr, "(removing clone %p %ld (of buddy: %p)\n", clone, (long)clone, buddy ); fprintf( stderr, " name : %s\n", purple_buddy_get_name(clone) ); fprintf( stderr, " group: %s)\n", purple_group_get_name( purple_buddy_get_group(clone) ) ); purple_blist_remove_buddy( clone ); } xmlnode *rval = xnode_new( "alist" ); AL_PTR( rval, "account-uid" , acct ); AL_PTR( rval, "bnode-uid" , buddy ); AL_PTR( rval, "group-uid" , group ); AL_STR( rval, "bnode-name" , purple_buddy_get_name ( buddy ) ); AL_STR( rval, "bnode-alias" , purple_buddy_get_alias ( buddy ) ); AL_STR( rval, "account-name", purple_account_get_username ( acct ) ); AL_STR( rval, "im-protocol" , purple_account_get_protocol_id( acct ) ); AL_STR( rval, "group-name" , purple_group_get_name ( group ) ); 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); }
static void pipe_handle_subscribe(struct purple_subscribe *subscribe) { PurpleAccount *account = NULL; extern_account_t *accounts = NULL; extern_user_t *users = NULL; int naccounts = 0, nusers = 0; int i, j; PurpleBuddy *buddy = NULL; int d = 0; const char *note; enum purple_publish_basic basic; enum purple_publish_activity activity; LM_DBG("calling find_accounts(\"%s\", &naccounts)\n", subscribe->from); accounts = find_accounts(subscribe->from, &naccounts); LM_DBG("found %d extra account(s) for <%s>", naccounts, subscribe->from); LM_DBG("calling find_users(\"%s\", &nusers)\n", subscribe->to); users = find_users(subscribe->to, &nusers); LM_DBG("found %d extra user(s) for <%s>", nusers, subscribe->to); for (i = 0; i < naccounts; i++) { LM_DBG("calling client_find_account(\"%s\")\n", accounts[i].username); account = client_find_account(&accounts[i]); //if ((account) && (purple_account_is_connected(account) || purple_account_is_connecting(account))) { if (account) { for (j = 0; j < nusers; j++) { if (!strcmp(accounts[i].protocol, users[j].protocol)) { LM_DBG("found matching protocol: %s\n", accounts[i].protocol); LM_DBG("subscribe expires : %d\n", subscribe->expires); if (subscribe->expires == 0) d = hashtable_dec_counter(users[j].username); else d = hashtable_inc_counter(users[j].username); LM_DBG("<%s> is now referenced %d times\n", users[j].username, d); if (d == 0) { LM_DBG("<%s> is no more referenced, removing presence...\n", users[j].username); if (purple_send_sip_publish(subscribe->to, users[j].username, PURPLE_BASIC_CLOSED, 0, NULL) < 0) LM_ERR("error sending presence for %s", subscribe->to); else LM_DBG("presence message sent successfully\n"); } else { buddy = purple_find_buddy(account, users[j].username); if (buddy == NULL) { LM_DBG("<%s> not found in <%s> buddy list, adding\n", users[j].username, accounts[i].username); buddy = purple_buddy_new(account, users[j].username, users[j].username); //purple_blist_add_buddy(buddy, NULL, NULL, NULL); purple_account_add_buddy(account, buddy); } else { LM_DBG("<%s> found in <%s> buddy list, sending publish\n", users[j].username, accounts[i].username); PurplePresence *presence = purple_buddy_get_presence(buddy); PurpleStatus *status = purple_presence_get_active_status(presence); PurpleStatusType *type = purple_status_get_type(status); PurpleStatusPrimitive primitive = purple_status_type_get_primitive(type); note = purple_status_get_attr_string(status, "message"); primitive_parse(primitive, &basic, &activity); if (purple_send_sip_publish(subscribe->to, users[j].username, basic, activity, note) < 0) LM_ERR("error sending presence for %s", subscribe->to); else LM_DBG("presence message sent successfully\n"); } } break; } } } } if (accounts) extern_account_free(accounts, naccounts); if (users) extern_user_free(users, nusers); }