/* * helpers */ static PurpleConnection *get_nullprpl_gc(const char *username) { PurpleAccount *acct = purple_accounts_find(username, NULLPRPL_ID); if (acct && purple_account_is_connected(acct)) return purple_account_get_connection(acct); else return NULL; }
static void purplemot_chat_invite(PurpleConnection *gc, int id, const char *message, const char *who) { const char *username = gc->account->username; PurpleConversation *conv = purple_find_chat(gc, id); const char *room = conv->name; PurpleAccount *to_acct = purple_accounts_find(who, PURPLEMOT_ID); purple_debug_info("purplemot", "%s is inviting %s to join chat room %s\n", username, who, room); if (to_acct) { PurpleConversation *to_conv = purple_find_chat(to_acct->gc, id); if (to_conv) { char *tmp = g_strdup_printf("%s is already in chat room %s.", who, room); purple_debug_info("purplemot", "%s is already in chat room %s; " "ignoring invitation from %s\n", who, room, username); purple_notify_info(gc, _("Chat invitation"), _("Chat invitation"), tmp); g_free(tmp); } else { GHashTable *components; components = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_free); g_hash_table_replace(components, "room", g_strdup(room)); g_hash_table_replace(components, "invited_by", g_strdup(username)); serv_got_chat_invite(to_acct->gc, room, username, message, components); } } }
static void dologin_named(const char *name) { PurpleAccount *account; char **names; int i; if (name != NULL) { /* list of names given */ names = g_strsplit(name, ",", 64); for (i = 0; names[i] != NULL; i++) { account = purple_accounts_find(names[i], NULL); if (account != NULL) { /* found a user */ purple_account_set_enabled(account, PIDGIN_UI, TRUE); } } g_strfreev(names); } else { /* no name given, use the first account */ GList *accounts; accounts = purple_accounts_get_all(); if (accounts != NULL) { account = (PurpleAccount *)accounts->data; purple_account_set_enabled(account, PIDGIN_UI, TRUE); } } }
static void message_source_activated(MessagingMenuApp *app, const gchar *id, gpointer user_data) { gchar **sections = g_strsplit(id, ":", 0); PurpleConversation *conv = NULL; PurpleAccount *account; PidginConvWindow *purplewin = NULL; char *type = sections[0]; char *cname = sections[1]; char *aname = sections[2]; char *protocol = sections[3]; account = purple_accounts_find(aname, protocol); if (g_strcmp0(type, "im") == 0) conv = PURPLE_CONVERSATION(purple_conversations_find_im_with_account(cname, account)); else if (g_strcmp0(type, "chat") == 0) conv = PURPLE_CONVERSATION(purple_conversations_find_chat_with_account(cname, account)); else conv = purple_conversations_find_with_account(cname, account); if (conv) { unalert(conv); purplewin = PIDGIN_CONVERSATION(conv)->win; pidgin_conv_window_switch_gtkconv(purplewin, PIDGIN_CONVERSATION(conv)); gdk_window_focus(gtk_widget_get_window(purplewin->window), time(NULL)); } g_strfreev (sections); }
static void nullprpl_chat_invite(PurpleConnection *gc, int id, const char *message, const char *who) { const char *username = purple_account_get_username(purple_connection_get_account(gc)); PurpleChatConversation *chat = purple_conversations_find_chat(gc, id); const char *room = purple_conversation_get_name(PURPLE_CONVERSATION(chat)); PurpleAccount *to_acct = purple_accounts_find(who, NULLPRPL_ID); purple_debug_info("nullprpl", "%s is inviting %s to join chat room %s\n", username, who, room); if (to_acct) { PurpleChatConversation *to_conv = purple_conversations_find_chat(purple_account_get_connection(to_acct), id); if (to_conv) { char *tmp = g_strdup_printf("%s is already in chat room %s.", who, room); purple_debug_info("nullprpl", "%s is already in chat room %s; " "ignoring invitation from %s\n", who, room, username); purple_notify_info(gc, _("Chat invitation"), _("Chat invitation"), tmp, purple_request_cpar_from_conversation(PURPLE_CONVERSATION(to_conv))); g_free(tmp); } else { GHashTable *components; components = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_free); g_hash_table_replace(components, "room", g_strdup(room)); g_hash_table_replace(components, "invited_by", g_strdup(username)); purple_serv_got_chat_invite(purple_account_get_connection(to_acct), room, username, message, components); } } }
static void nullprpl_get_info(PurpleConnection *gc, const char *username) { const char *body; PurpleNotifyUserInfo *info = purple_notify_user_info_new(); PurpleAccount *acct; purple_debug_info("nullprpl", "Fetching %s's user info for %s\n", username, purple_account_get_username(purple_connection_get_account(gc))); acct = purple_accounts_find(username, NULLPRPL_ID); if (!get_nullprpl_gc(username)) { char *msg = g_strdup_printf(_("%s is not logged in."), username); purple_notify_error(gc, _("User Info"), _("User info not available. "), msg, purple_request_cpar_from_account(acct)); g_free(msg); } if (acct) body = purple_account_get_user_info(acct); else body = _("No user info."); /* TODO: Check whether it's correct to call add_pair_html, or if we should be using add_pair_plaintext */ purple_notify_user_info_add_pair_html(info, "Info", body); /* show a buddy's user info in a nice dialog box */ purple_notify_userinfo(gc, /* connection the buddy info came through */ username, /* buddy's username */ info, /* body */ NULL, /* callback called when dialog closed */ NULL); /* userdata for callback */ }
static void purplemot_get_info(PurpleConnection *gc, const char *username) { const char *body; PurpleNotifyUserInfo *info = purple_notify_user_info_new(); PurpleAccount *acct; purple_debug_info("purplemot", "Fetching %s's user info for %s\n", username, gc->account->username); if (!get_purplemot_gc(username)) { char *msg = g_strdup_printf(_("%s is not logged in."), username); purple_notify_error(gc, _("User Info"), _("User info not available. "), msg); g_free(msg); } acct = purple_accounts_find(username, PURPLEMOT_ID); if (acct) body = purple_account_get_user_info(acct); else body = _("No user info."); purple_notify_user_info_add_pair(info, "Info", body); /* show a buddy's user info in a nice dialog box */ purple_notify_userinfo(gc, /* connection the buddy info came through */ username, /* buddy's username */ info, /* body */ NULL, /* callback called when dialog closed */ NULL); /* userdata for callback */ }
PurpleAccount *flist_deserialize_account(const gchar *lookup) { const gchar *name; name = g_hash_table_lookup(string_to_account, lookup); if(!name) return NULL; return purple_accounts_find(name, FLIST_PLUGIN_ID); }
static PurpleConnection * get_purplemot_gc(const char *username) { PurpleAccount *acct = purple_accounts_find(username, PURPLEMOT_ID); if (acct && purple_account_is_connected(acct)) return acct->gc; else return NULL; }
/* a timer based callback function that sends the next message in the queue */ static gboolean send_message_timer_cb( message_to_conv *msg_to_conv ) { PurpleAccount *account; PurpleConversation *conv; gchar *msg; g_return_val_if_fail(msg_to_conv != NULL, FALSE); g_return_val_if_fail(msg_to_conv->messages != NULL, FALSE); g_return_val_if_fail(msg_to_conv->sender_username != NULL, FALSE); g_return_val_if_fail(msg_to_conv->sender_protocol_id != NULL, FALSE); msg = g_queue_pop_head(msg_to_conv->messages); if( msg == NULL ) { /* clean up and terminate timer callback */ g_queue_free(msg_to_conv->messages); g_free(msg_to_conv->sender_username); g_free(msg_to_conv->sender_protocol_id); if( msg_to_conv->type == PURPLE_CONV_TYPE_IM && msg_to_conv->receiver != NULL ) g_free(msg_to_conv->receiver); g_free(msg_to_conv); return FALSE; } else { /* find account info (it may have changed) and try and create a new conversation window (it may have been closed) or find the existing chat, and finally send the message */ account = purple_accounts_find(msg_to_conv->sender_username, msg_to_conv->sender_protocol_id); g_return_val_if_fail(account != NULL, FALSE); if( msg_to_conv->type == PURPLE_CONV_TYPE_IM && msg_to_conv->receiver != NULL ) conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, msg_to_conv->receiver); else if( msg_to_conv->type == PURPLE_CONV_TYPE_CHAT ) conv = purple_find_chat(account->gc, msg_to_conv->id); else conv = NULL; g_return_val_if_fail(conv != NULL, FALSE); splitter_common_send(conv, msg, PURPLE_MESSAGE_SEND); g_free(msg); return TRUE; } }
static int purplemot_send_im(PurpleConnection *gc, const char *who, const char *message, PurpleMessageFlags flags) { const char *from_username = gc->account->username; PurpleMessageFlags receive_flags = ((flags & ~PURPLE_MESSAGE_SEND) | PURPLE_MESSAGE_RECV); PurpleAccount *to_acct = purple_accounts_find(who, PURPLEMOT_ID); PurpleConnection *to; purple_debug_info("purplemot", "sending message from %s to %s: %s\n", from_username, who, message); /* is the sender blocked by the recipient's privacy settings? */ if (to_acct && !purple_privacy_check(to_acct, gc->account->username)) { char *msg = g_strdup_printf( _("Your message was blocked by %s's privacy settings."), who); purple_debug_info("purplemot", "discarding; %s is blocked by %s's privacy settings\n", from_username, who); purple_conv_present_error(who, gc->account, msg); g_free(msg); return 0; } /* is the recipient online? */ to = get_purplemot_gc(who); if (to) { /* yes, send */ serv_got_im(to, from_username, message, receive_flags, time(NULL)); } else { /* nope, store as an offline message */ GOfflineMessage *offline_message; GList *messages; purple_debug_info("purplemot", "%s is offline, sending as offline message\n", who); offline_message = g_new0(GOfflineMessage, 1); offline_message->from = g_strdup(from_username); offline_message->message = g_strdup(message); offline_message->mtime = time(NULL); offline_message->flags = receive_flags; messages = g_hash_table_lookup(goffline_messages, who); messages = g_list_append(messages, offline_message); g_hash_table_insert(goffline_messages, g_strdup(who), messages); } return 1; }
void TestPidginIm::testSendIQ(PurplePluginAction* action) { const char* fromName = "test@localhost/QAS"; const char* toName = "xuewen@localhost/winxp"; const char* protocol = "prpl-jabber"; PurpleAccount * account = purple_accounts_find(fromName, protocol); if (!account) { purple_debug_info("TestQAS Test file", "find accout faile"); return; } PurpleConnection * conn = purple_account_get_connection(account); PurplePluginProtocolInfo * prpl = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(conn)); prpl->send_raw(conn, msg, strlen(msg)); prpl->send_raw(conn, iq, strlen(iq)); }
xmlnode * _h_elim_send_file ( const char *name , const char *id , SEXP_VALUE *args , gpointer data ) { ASSERT_ALISTP( args, id, name ); 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 = 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" ); } PurpleConnection *conn = purple_account_get_connection( acct ); if( !conn ) { sexp_val_free( args ); return response_error( ENXIO, id, name, "account not online" ); } // file can be NULL, but that's Ok, it just triggers a req to the user: const char *b_arg = ALIST_VAL_STRING( args, "recipient" ); const char *file = ALIST_VAL_STRING( args, "filename" ); serv_send_file( conn, b_arg, file ); // bname is a static buf allocated in purple_normalize: don't free it! // also, this means that bname is volatile, so use it immediately after // acquiring it, if you make any calls into libpurple they might invalidate // its state: const char *bname = purple_normalize( acct, b_arg ); xmlnode *rval = xnode_new( "alist" ); AL_PTR( rval, "account-uid" , acct ); AL_STR( rval, "recipient" , bname ); sexp_val_free( args ); return response_value( 0, id, name, rval ); }
xmlnode * _h_elim_set_icon ( const char *name , const char *id , SEXP_VALUE *args , gpointer data ) { ASSERT_ALISTP( args, id, name ); 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" ); const char *file = ALIST_VAL_STR ( args, "icon-file" ); GString *img = ALIST_VAL_DATA( args, "icon-data" ); gchar *bytes = NULL; gsize len = 0; gpointer set = NULL; 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" ); } if( !img && file && *file ) { g_file_get_contents( file, &bytes, &len, NULL ); } else if( img ) { bytes = g_memdup( img->str, img->len ); len = img->len; } // the imgstore owns `bytes' after this, don't free it: set = purple_buddy_icons_set_account_icon( acct, (guchar *)bytes, len ); xmlnode *rval = xnode_new( "alist" ); AL_PTR ( rval, "account-uid" , acct ); AL_STR ( rval, "account-name", purple_account_get_username ( acct ) ); AL_STR ( rval, "im-protocol" , purple_account_get_protocol_id( acct ) ); AL_BOOL( rval, "has-icon" , set ? TRUE : FALSE ); sexp_val_free( args ); return response_value( 0, id, name, rval ); }
static void dropdown_changed_cb(GtkComboBox *widget, gpointer nul) { PurpleAccount *account; if (!console) return; account = purple_accounts_find(gtk_combo_box_get_active_text(GTK_COMBO_BOX(console->dropdown)), "prpl-jabber"); if (!account || !account->gc) return; console->gc = account->gc; gtk_imhtml_clear(GTK_IMHTML(console->imhtml)); }
static int account_find(LuaState *L)/*{{{*/ { luaL_checktype(L, 1, LUA_TTABLE); const char *name = luaL_checkstring(L, 2); const char *protocol = luaL_checkstring(L, 3); PurpleAccount *account = purple_accounts_find(name, protocol); if (account) { lua_pushlightuserdata(L, account); lua_gettable(L, LUA_REGISTRYINDEX); } else { lua_pushboolean(L, FALSE); } return 1; }/*}}}*/
PurpleAccount *client_find_account(extern_account_t *account) { PurpleAccount *r; char* plugin; char username[255]; memset(username, 0, 255); if (strcmp(account->protocol, "gtalk") == 0) { sprintf(username, "%s%s", account->username, "/sip"); plugin = "prpl-jabber"; } else { sprintf(username, "%s", account->username); plugin = account->protocol; } LM_DBG("searching purple account for %s with plugin %s \n", username, plugin); r = purple_accounts_find(username, plugin); if (r) { LM_DBG("account %s found\n", username); return r; } LM_DBG("account %s not found, creating.\n", username); r = purple_account_new(username, plugin); purple_account_set_password(r, account->password); purple_account_set_remember_password(r, TRUE); if (proxy != NULL) purple_account_set_proxy_info(r, proxy); if (strcmp(account->protocol, "gtalk") == 0) purple_account_set_string(r, "connect_server", "talk.google.com"); purple_accounts_add(r); return r; }
/* Send an OTR Query Message to attempt to start a connection */ void otrg_ui_connect_connection(ConnContext *context) { /* Send an OTR Query to the other side. */ PurpleAccount *account; char *msg; /* Don't do this if we're already ENCRYPTED */ if (context == NULL || context->msgstate == OTRL_MSGSTATE_ENCRYPTED) return; account = purple_accounts_find(context->accountname, context->protocol); if (!account) { PurplePlugin *p = purple_find_prpl(context->protocol); msg = g_strdup_printf(_("Account %s (%s) could not be found"), context->accountname, (p && p->info->name) ? p->info->name : _("Unknown")); otrg_dialog_notify_error(context->accountname, context->protocol, context->username, _("Account not found"), msg, NULL); g_free(msg); return; } otrg_plugin_send_default_query(context, account); }
static PurpleAccount *find_acct(const char *prpl, const char *acct_id) { PurpleAccount *acct = NULL; /* If we have a specific acct, use it */ if (acct_id) { acct = purple_accounts_find(acct_id, prpl); if (acct && !purple_account_is_connected(acct)) acct = NULL; } else { /* Otherwise find an active account for the protocol */ GList *l = purple_accounts_get_all(); while (l) { if (!strcmp(prpl, purple_account_get_protocol_id(l->data)) && purple_account_is_connected(l->data)) { acct = l->data; break; } l = l->next; } } return acct; }
static void end_element_handler(GMarkupParseContext *context, const gchar *element_name, gpointer user_data, GError **error) { PounceParserData *data = user_data; gchar *buffer = NULL; if (data->buffer != NULL) { buffer = g_string_free(data->buffer, FALSE); data->buffer = NULL; } if (purple_strequal(element_name, "account")) { g_free(data->account_name); data->account_name = g_strdup(buffer); } else if (purple_strequal(element_name, "pouncee")) { g_free(data->pouncee); data->pouncee = g_strdup(buffer); } else if (purple_strequal(element_name, "option")) { if (purple_strequal(data->option_type, "on-away")) data->options |= PURPLE_POUNCE_OPTION_AWAY; g_free(data->option_type); data->option_type = NULL; } else if (purple_strequal(element_name, "event")) { if (purple_strequal(data->event_type, "sign-on")) data->events |= PURPLE_POUNCE_SIGNON; else if (purple_strequal(data->event_type, "sign-off")) data->events |= PURPLE_POUNCE_SIGNOFF; else if (purple_strequal(data->event_type, "away")) data->events |= PURPLE_POUNCE_AWAY; else if (purple_strequal(data->event_type, "return-from-away")) data->events |= PURPLE_POUNCE_AWAY_RETURN; else if (purple_strequal(data->event_type, "idle")) data->events |= PURPLE_POUNCE_IDLE; else if (purple_strequal(data->event_type, "return-from-idle")) data->events |= PURPLE_POUNCE_IDLE_RETURN; else if (purple_strequal(data->event_type, "start-typing")) data->events |= PURPLE_POUNCE_TYPING; else if (purple_strequal(data->event_type, "typed")) data->events |= PURPLE_POUNCE_TYPED; else if (purple_strequal(data->event_type, "stop-typing")) data->events |= PURPLE_POUNCE_TYPING_STOPPED; else if (purple_strequal(data->event_type, "message-received")) data->events |= PURPLE_POUNCE_MESSAGE_RECEIVED; g_free(data->event_type); data->event_type = NULL; } else if (purple_strequal(element_name, "action")) { if (data->pounce != NULL) { purple_pounce_action_register(data->pounce, data->action_name); purple_pounce_action_set_enabled(data->pounce, data->action_name, TRUE); } g_free(data->action_name); data->action_name = NULL; } else if (purple_strequal(element_name, "param")) { if (data->pounce != NULL) { purple_pounce_action_set_attribute(data->pounce, data->action_name, data->param_name, buffer); } g_free(data->param_name); data->param_name = NULL; } else if (purple_strequal(element_name, "events")) { PurpleAccount *account; account = purple_accounts_find(data->account_name, data->protocol_id); g_free(data->account_name); g_free(data->protocol_id); data->account_name = NULL; data->protocol_id = NULL; if (account == NULL) { purple_debug(PURPLE_DEBUG_ERROR, "pounce", "Account for pounce not found!\n"); /* * This pounce has effectively been removed, so make * sure that we save the changes to pounces.xml */ schedule_pounces_save(); } else { purple_debug(PURPLE_DEBUG_INFO, "pounce", "Creating pounce: %s, %s\n", data->ui_name, data->pouncee); data->pounce = purple_pounce_new(data->ui_name, account, data->pouncee, data->events, data->options); } g_free(data->pouncee); data->pouncee = NULL; } else if (purple_strequal(element_name, "save")) { if (data->pounce != NULL) purple_pounce_set_save(data->pounce, TRUE); } else if (purple_strequal(element_name, "pounce")) { data->pounce = NULL; data->events = 0; data->options = 0; g_free(data->ui_name); g_free(data->pouncee); g_free(data->protocol_id); g_free(data->event_type); g_free(data->option_type); g_free(data->action_name); g_free(data->param_name); g_free(data->account_name); data->ui_name = NULL; data->pounce = NULL; data->protocol_id = NULL; data->event_type = NULL; data->option_type = NULL; data->action_name = NULL; data->param_name = NULL; data->account_name = NULL; } g_free(buffer); }
static PurpleAccount* get_account_from_ruby_object(VALUE acc){ PurpleAccount* account = NULL; Data_Get_Struct( acc, PurpleAccount, account ); return purple_accounts_find(account->username,account->protocol_id); }
/*------------------------------------------------------------------------ * Handle an URI clicked on the UI * * @param link the link name which has been clicked */ static void* mxit_link_click( const char* link64 ) { PurpleAccount* account; PurpleConnection* gc; gchar** parts = NULL; gchar* link = NULL; gsize len; gboolean is_command = FALSE; purple_debug_info( MXIT_PLUGIN_ID, "mxit_link_click (%s)\n", link64 ); if ( g_ascii_strncasecmp( link64, MXIT_LINK_PREFIX, strlen( MXIT_LINK_PREFIX ) ) != 0 ) { /* this is not for us */ goto skip; } /* decode the base64 payload */ link = (gchar*) purple_base64_decode( link64 + strlen( MXIT_LINK_PREFIX ), &len ); purple_debug_info( MXIT_PLUGIN_ID, "Clicked Link: '%s'\n", link ); parts = g_strsplit( link, "|", 6 ); /* check if this is a valid mxit link */ if ( ( !parts ) || ( !parts[0] ) || ( !parts[1] ) || ( !parts[2] ) || ( !parts[3] ) || ( !parts[4] ) || ( !parts[5] ) ) { /* this is not for us */ goto skip; } else if ( g_ascii_strcasecmp( parts[0], MXIT_LINK_KEY ) != 0 ) { /* this is not for us */ goto skip; } /* find the account */ account = purple_accounts_find( parts[1], parts[2] ); if ( !account ) goto skip; gc = purple_account_get_connection( account ); if ( !gc ) goto skip; /* determine if it's a command-response to send */ is_command = ( atoi( parts[4] ) == 1 ); /* send click message back to MXit */ mxit_send_message( purple_connection_get_protocol_data( gc ), parts[3], parts[5], FALSE, is_command ); g_free( link ); link = NULL; g_strfreev( parts ); parts = NULL; return (void*) link64; skip: /* this is not an internal mxit link */ if ( link ) g_free( link ); link = NULL; if ( parts ) g_strfreev( parts ); parts = NULL; if ( mxit_pidgin_uri_cb ) return mxit_pidgin_uri_cb( link64 ); else return (void*) link64; }
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 ); }
xmlnode * _h_elim_add_chat( const char *name , const char *id , SEXP_VALUE *args , gpointer data ) { ASSERT_ALISTP( args, id, name ); elim_ping(); const char *aname = ALIST_VAL_STR ( args, "account-name" ); const char *proto = ALIST_VAL_STR ( args, "im-protocol" ); const char *alias = ALIST_VAL_STR ( args, "chat-alias" ); gpointer auid = ALIST_VAL_PTR ( args, "account-uid" ); GHashTable *opts = ALIST_VAL_ALIST( args, "chat-options" ); GHashTable *options = __ghash_str_sexp__str_str( opts ); 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" ); } // cook up a chat node. if it's already on our buddy list, uncook it // and use the old one instead (name should be unique per account // so the operation is reasonable - we cannot supply a name as this // parameter can be delegated to the plugin to generate automatically): // this will trigger a new_node call, and possibly a remove call PurpleChat *chat = purple_chat_new( acct, alias, options ); const char *chn = purple_chat_get_name( chat ); PurpleChat *ch_2 = purple_blist_find_chat( acct, chn ); if( ch_2 ) { fprintf( stderr, "(elim-debug chat already exists)\n" ); purple_blist_remove_chat( chat ); chat = ch_2; chn = purple_chat_get_name( chat ); purple_blist_alias_chat( chat, alias ); } fprintf( stderr, "(elim-debug adding chat to blist)\n" ); purple_blist_add_chat( chat, NULL, NULL ); // if we have a conversation already, prod the client to show it fprintf( stderr, "(elim-debug looking for conversation)\n" ); PurpleConversation *conv = purple_find_conversation_with_account( PURPLE_CONV_TYPE_CHAT, chn, acct ); if( conv ) purple_conversation_present( conv ); 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_STR( rval, "chat-name" , chn ); if( conv ) { PurpleConversationType pct = purple_conversation_get_type ( conv ); PurpleConnectionFlags pcf = purple_conversation_get_features( conv ); AL_PTR ( rval, "conv-uid" , conv ); AL_STR ( rval, "conv-name" , purple_conversation_get_name (conv) ); AL_STR ( rval, "conv-title" , purple_conversation_get_title(conv) ); AL_ENUM( rval, "conv-type" , pct, ":conversation-type" ); AL_ENUM( rval, "conv-features", pcf, ":connection-flags" ); } sexp_val_free( args ); return response_value( 0, id, name, rval ); }
xmlnode * _h_elim_message ( const char *name , const char *id , SEXP_VALUE *args , gpointer data ) { fprintf(stderr, "(elim-debug entered _h_elim_message)"); ASSERT_ALISTP( args, id, name ); 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 = 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" ); } PurpleConversationType pt = PURPLE_CONV_TYPE_UNKNOWN; gpointer cuid = ALIST_VAL_PTR( args, "conv-uid" ); const char *cname = ALIST_VAL_STR( args, "conv-name" ); PurpleConversation *pc = find_conv_by_acct_uid( acct, cuid ); if ( pc ) pt = purple_conversation_get_type( pc ); else { pt = PURPLE_CONV_TYPE_ANY; pc = purple_find_conversation_with_account( pt, cname, acct ); if( !pc ) { pt = PURPLE_CONV_TYPE_IM; pc = purple_conversation_new( pt, acct, cname ); } else { pt = purple_conversation_get_type( pc ); } } if( !pc ) { sexp_val_free( args ); return response_error( ENXIO, id, name, "new conversation failed" ); } PurpleConvIm *pci = NULL; PurpleConvChat *pcc = NULL; const char *msg = ALIST_VAL_STRING( args, "text" ); char *esc = g_markup_escape_text( msg, -1 ); int len = strlen( esc ); switch( pt ) { case PURPLE_CONV_TYPE_IM: pci = purple_conversation_get_im_data( pc ); purple_conv_im_send( pci, esc ); break; case PURPLE_CONV_TYPE_CHAT: pcc = purple_conversation_get_chat_data( pc ); purple_conv_chat_send( pcc, esc ); break; default: g_free ( esc ); sexp_val_free( args ); return response_error( EINVAL, id, name, "unknown conversation type" ); } xmlnode *rval = xnode_new( "alist" ); AL_INT( rval, "bytes" , len ); AL_PTR( rval, "conv-uid" , pc ); AL_STR( rval, "conv-name", purple_conversation_get_name(pc) ); g_free ( esc ); sexp_val_free( args ); fprintf(stderr, "(elim-debug leaving _h_elim_message)"); return response_value( 0, id, name, rval ); }
//----------------------------------------------------------------------------- //static PurpleAccount* PurpleIMChat::getPurpleAccount( const IMAccount& imAccount ) { return purple_accounts_find( imAccount.getLogin().c_str(), PurpleIMPrcl::GetPrclId( imAccount.getProtocol() ) ); }
xmlnode * _h_elim_command ( const char *name , const char *id , SEXP_VALUE *args , gpointer data ) { fprintf(stderr, "(elim-debug entered _h_elim_command)"); ASSERT_ALISTP( args, id, name ); 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 = 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" ); } PurpleConversationType pt = PURPLE_CONV_TYPE_UNKNOWN; gpointer cuid = ALIST_VAL_PTR( args, "conv-uid" ); const char *cname = ALIST_VAL_STR( args, "conv-name" ); PurpleConversation *pc = find_conv_by_acct_uid( acct, cuid ); if ( pc ) pt = purple_conversation_get_type( pc ); else { pt = PURPLE_CONV_TYPE_ANY; pc = purple_find_conversation_with_account( pt, cname, acct ); if( !pc ) { sexp_val_free( args ); return response_error( ENOENT, id, name, "conversation not found" ); } else { pt = purple_conversation_get_type( pc ); } } PurpleCmdStatus c_s = PURPLE_CMD_STATUS_FAILED; const char *cmd = ALIST_VAL_STRING( args, "command" ); char *esc = g_markup_escape_text( cmd, -1 ); char *err = NULL; const char *error = NULL; c_s = purple_cmd_do_command( pc, cmd, esc, &err ); if( c_s != PURPLE_CMD_STATUS_OK && (!err || !*err) ) switch( c_s ) { case PURPLE_CMD_STATUS_FAILED : error = "Command failed"; break; case PURPLE_CMD_STATUS_NOT_FOUND : error = "Command not found"; break; case PURPLE_CMD_STATUS_WRONG_ARGS: error = "Bad command arguments"; break; case PURPLE_CMD_STATUS_WRONG_PRPL: error = "Command not valid for this IM protocol"; break; case PURPLE_CMD_STATUS_WRONG_TYPE: error = "Command not valid in this conversation"; break; default: error = "Unknown command error"; } xmlnode *rval = xnode_new( "alist" ); AL_PTR ( rval, "conv-uid" , pc ); AL_STR ( rval, "conv-name" , purple_conversation_get_name(pc) ); AL_ENUM( rval, "command-status", c_s , ":cmd-status" ); AL_STR ( rval, "command-error" , err ? err : error ); AL_STR ( rval, "command-line" , cmd ); g_free ( err ); g_free ( esc ); sexp_val_free( args ); fprintf(stderr, "(elim-debug leaving _h_elim_command)"); return response_value( 0, id, name, rval ); }
PurpleAccount* PurpleIMContactList::getPurpleAccount( PurpleIMContactList* imContactList ) { return purple_accounts_find( imContactList->getIMAccount().getLogin().c_str(), PurpleIMPrcl::GetPrclId(imContactList->getIMAccount().getProtocol())); }
bool GlooxRegisterHandler::unregisterUser(const std::string &barejid) { UserRow res = Transport::instance()->sql()->getUserByJid(barejid); // This user is already registered if (res.id == -1) return false; Log("GlooxRegisterHandler", "removing user " << barejid << " from database and disconnecting from legacy network"); PurpleAccount *account = NULL; AbstractUser *user = Transport::instance()->userManager()->getUserByJID(barejid); if (user && user->hasFeature(GLOOX_FEATURE_ROSTERX) && false) { std::cout << "* sending rosterX\n"; Tag *tag = new Tag("message"); tag->addAttribute( "to", barejid ); std::string _from; _from.append(Transport::instance()->jid()); tag->addAttribute( "from", _from ); tag->addChild(new Tag("body","removing users")); Tag *x = new Tag("x"); x->addAttribute("xmlns","http://jabber.org/protocol/rosterx"); std::list <std::string> roster; roster = Transport::instance()->sql()->getBuddies(res.id); Tag *item; for(std::list<std::string>::iterator u = roster.begin(); u != roster.end() ; u++){ std::string name = *u; item = new Tag("item"); item->addAttribute("action", "delete"); item->addAttribute("jid", name + "@" + Transport::instance()->jid()); x->addChild(item); } tag->addChild(x); Transport::instance()->send(tag); } else { std::list <std::string> roster; // roster contains already escaped jids roster = Transport::instance()->sql()->getBuddies(res.id); Tag *tag; for(std::list<std::string>::iterator u = roster.begin(); u != roster.end() ; u++){ std::string name = *u; tag = new Tag("presence"); tag->addAttribute( "to", barejid ); tag->addAttribute( "type", "unsubscribe" ); tag->addAttribute( "from", name + "@" + Transport::instance()->jid()); Transport::instance()->send( tag ); tag = new Tag("presence"); tag->addAttribute( "to", barejid ); tag->addAttribute( "type", "unsubscribed" ); tag->addAttribute( "from", name + "@" + Transport::instance()->jid()); Transport::instance()->send( tag ); } } // Remove user from database if (res.id != -1) { Transport::instance()->sql()->removeUser(res.id); } // Disconnect the user if (user != NULL) { account = user->account(); Transport::instance()->userManager()->removeUser(user); } if (!account) { account = purple_accounts_find(res.uin.c_str(), Transport::instance()->protocol()->protocol().c_str()); } #ifndef TESTS // Remove account from memory if (account) Transport::instance()->collector()->collectNow(account, true); #endif Tag *reply = new Tag( "presence" ); reply->addAttribute( "type", "unsubscribe" ); reply->addAttribute( "from", Transport::instance()->jid() ); reply->addAttribute( "to", barejid ); Transport::instance()->send( reply ); reply = new Tag("presence"); reply->addAttribute( "type", "unsubscribed" ); reply->addAttribute( "from", Transport::instance()->jid() ); reply->addAttribute( "to", barejid ); Transport::instance()->send( reply ); return true; }