void BuddyListChat::onActivate(Button& /*activator*/)
{
PurpleAccount *account = purple_chat_get_account(chat);
PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(
purple_find_prpl(purple_account_get_protocol_id(account)));
GHashTable *components = purple_chat_get_components(chat);
char *chat_name = NULL;
if (prpl_info && prpl_info->get_chat_name)
chat_name = prpl_info->get_chat_name(components);
const char *name;
if (chat_name)
name = chat_name;
else
name = purple_chat_get_name(chat);
PurpleConversation *conv = purple_find_conversation_with_account(
PURPLE_CONV_TYPE_CHAT, name, account);
if (conv)
purple_conversation_present(conv);
serv_join_chat(purple_account_get_connection(account), components);
g_free(chat_name);
}
PurpleStoredImage *
purple_buddy_icons_set_account_icon(PurpleAccount *account,
guchar *icon_data, size_t icon_len)
{
PurpleStoredImage *old_img;
PurpleStoredImage *img = NULL;
char *old_icon;
if (icon_data != NULL && icon_len > 0)
{
img = purple_buddy_icon_data_new(icon_data, icon_len, NULL);
}
old_icon = g_strdup(purple_account_get_string(account, "buddy_icon", NULL));
if (img && purple_buddy_icons_is_caching())
{
const char *filename = purple_imgstore_get_filename(img);
purple_account_set_string(account, "buddy_icon", filename);
purple_account_set_int(account, "buddy_icon_timestamp", time(NULL));
ref_filename(filename);
}
else
{
purple_account_set_string(account, "buddy_icon", NULL);
purple_account_set_int(account, "buddy_icon_timestamp", 0);
}
unref_filename(old_icon);
old_img = g_hash_table_lookup(pointer_icon_cache, account);
if (img)
g_hash_table_insert(pointer_icon_cache, account, img);
else
g_hash_table_remove(pointer_icon_cache, account);
if (purple_account_is_connected(account))
{
PurpleConnection *gc;
PurplePluginProtocolInfo *prpl_info;
gc = purple_account_get_connection(account);
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc));
if (prpl_info && prpl_info->set_buddy_icon)
prpl_info->set_buddy_icon(gc, img);
}
if (old_img)
purple_imgstore_unref(old_img);
else if (old_icon)
{
/* The old icon may not have been loaded into memory. In that
* case, we'll need to uncache the filename. The filenames
* are ref-counted, so this is safe. */
purple_buddy_icon_data_uncache_file(old_icon);
}
g_free(old_icon);
return img;
}
static void buddy_status_changed(PurpleBuddy *buddy, PurpleStatus *old_status, PurpleStatus *status) {
PurplePlugin *prpl;
PurplePluginProtocolInfo *prpl_info = NULL;
char *sip_from = find_sip_user(buddy->name);
int d = hashtable_get_counter(buddy->name);
PurpleStatusPrimitive primitive;
enum purple_publish_basic basic;
enum purple_publish_activity activity;
char *statustext = NULL, *tmp = NULL, *new;
const char *end;
LM_DBG("buddy <%s> has changed status\n", buddy->name);
if ((sip_from) && (d>0)) {
primitive = purple_status_type_get_primitive(purple_status_get_type(status));
primitive_parse(primitive, &basic, &activity);
// char *note = purple_status_get_attr_string(status, "message");
prpl = purple_find_prpl(purple_account_get_protocol_id(buddy->account));
if (prpl != NULL)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
if (prpl_info && prpl_info->status_text && buddy->account->gc) {
tmp = prpl_info->status_text(buddy);
if(tmp && !g_utf8_validate(tmp, -1, &end)) {
new = g_strndup(tmp, g_utf8_pointer_to_offset(tmp, end));
g_free(tmp);
tmp = new;
}
static void message_send_cb(GtkWidget *widget, gpointer p)
{
GtkTextIter start, end;
PurplePluginProtocolInfo *prpl_info = NULL;
PurpleConnection *gc;
GtkTextBuffer *buffer;
char *text;
gc = console->gc;
if (gc)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(console->entry));
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
text = gtk_imhtml_get_text(GTK_IMHTML(console->entry), &start, &end);
if (prpl_info && prpl_info->send_raw != NULL)
prpl_info->send_raw(gc, text, strlen(text));
g_free(text);
gtk_imhtml_clear(GTK_IMHTML(console->entry));
}
/* stolen from autoaccept.c and gtkblist.c files. */
void
buddy_context_menu_add_item (PurpleBlistNode * node, GList ** menu,
PurplePlugin * plugin) {
PurplePluginProtocolInfo *prpl_info;
if (PURPLE_BLIST_NODE_IS_BUDDY (node)) {
prpl_info =
PURPLE_PLUGIN_PROTOCOL_INFO (((PurpleBuddy *) node)->account->
gc->prpl);
if (prpl_info && prpl_info->send_file) {
if (!prpl_info->can_receive_file ||
prpl_info->can_receive_file (((PurpleBuddy *) node)->
account->gc,
((PurpleBuddy *) node)->name)) {
PurpleMenuAction *action;
if (!PURPLE_BLIST_NODE_IS_BUDDY (node)
&& !PURPLE_BLIST_NODE_IS_CONTACT (node)
&& !(purple_blist_node_get_flags (node) &
PURPLE_BLIST_NODE_FLAG_NO_SAVE))
return;
action =
purple_menu_action_new (SCREENSHOT_SEND_MENUITEM_LABEL,
PURPLE_CALLBACK
(on_blist_context_menu_send_capture),
plugin, NULL);
(*menu) = g_list_prepend (*menu, action); /* add */
}
}
}
}
void
auto_reply (PurpleAccount* account, const char *recipient, const char *message)
{
PurpleConnection *gc;
PurplePluginProtocolInfo *prpl_info;
purple_debug_info("pidgin-pp", "Auto-reply: '%s'\n", message);
// Don't send another message within MSG_LIST_TIMEOUT
if (is_in_msg_list(recipient)) return;
gc = NULL;
prpl_info = NULL;
gc = purple_account_get_connection(account);
if (gc != NULL && gc->prpl != NULL)
{
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
}
if (prpl_info && prpl_info->send_im)
{
purple_debug_info("pidgin-pp", "Sending to: %s\n", recipient);
prpl_info->send_im(gc, recipient, message,
PURPLE_MESSAGE_AUTO_RESP);
add_to_msg_list(recipient);
}
return;
}
void AccountWindow::SplitOption::updateSplits()
{
SplitWidgets *split_widgets = &account_entry->split_widgets;
SplitWidgets::iterator split_widget = split_widgets->begin();
SplitOption *widget = *split_widget;
const char *val = widget->getValue();
split_widget++;
GString *username = g_string_new(val);
PurplePluginProtocolInfo *prplinfo = PURPLE_PLUGIN_PROTOCOL_INFO(
purple_find_prpl(purple_account_get_protocol_id(account)));
for (GList *iter = prplinfo->user_splits;
iter && split_widget != split_widgets->end();
iter = iter->next, split_widget++) {
PurpleAccountUserSplit *user_split
= reinterpret_cast<PurpleAccountUserSplit*>(iter->data);
widget = *split_widget;
val = widget->getValue();
if (!val || !*val)
val = purple_account_user_split_get_default_value(user_split);
g_string_append_printf(username, "%c%s",
purple_account_user_split_get_separator(user_split), val);
}
purple_account_set_username(account, username->str);
g_string_free(username, TRUE);
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
PurplePlugin *prpl = NULL;
PurpleAccountOption *option;
void *gc_handle = NULL;
#if !PURPLE_VERSION_CHECK(2,4,0)
gchar *notice_help = NULL;
#endif
prpl = purple_find_prpl("prpl-irc");
/* if we didn't find the prpl, bail */
if (!prpl)
return FALSE;
#if !PURPLE_VERSION_CHECK(2,4,0)
/* specify our help string and register our command */
notice_help = _("notice target message: Send a notice to the specified target.");
notice_cmd_id = purple_cmd_register("notice", "ws", PURPLE_CMD_P_PLUGIN,
PURPLE_CMD_FLAG_IM | PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PRPL_ONLY,
"prpl-irc", notice_cmd_cb, notice_help, NULL);
#endif
/* we need this handle for the signed-on signal */
gc_handle = purple_connections_get_handle();
/* list signals in alphabetical order for consistency */
purple_signal_connect(prpl, "irc-sending-text", plugin,
G_CALLBACK(irc_sending_text), NULL);
purple_signal_connect(prpl, "irc-receiving-text", plugin,
G_CALLBACK(irc_receiving_text), NULL);
purple_signal_connect(gc_handle, "signed-on", plugin,
G_CALLBACK(signed_on_cb), NULL);
irc_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
/* Alphabetize the option label strings */
option = purple_account_option_string_new(_("Auto-Join Channels"), "autojoin", "");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
option = purple_account_option_string_new(_("CTCP Version reply"), "ctcp-message", "Purple IRC");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
option = purple_account_option_string_new(_("Default Quit Message"), "quit-message", "Leaving.");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
option = purple_account_option_string_new(_("Default Part Message"), "part-message", "Leaving.");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
option = purple_account_option_string_new(_("Set User Modes On Connect"), "setumodes", "i");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
option = purple_account_option_string_new(_("Unset User Modes On Connect"), "unsetumodes", "");
irc_info->protocol_options = g_list_append(irc_info->protocol_options, option);
return TRUE;
}
void ConfigFile::loadPurpleAccountSettings(Configuration &configuration) {
if (!m_loaded)
return;
if (!g_key_file_has_group(keyfile, "purple"))
return;
PurplePlugin *plugin = purple_find_prpl(Transport::instance()->protocol()->protocol().c_str());
PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
for (GList *l = prpl_info->protocol_options; l != NULL; l = l->next) {
PurpleAccountOption *option = (PurpleAccountOption *) l->data;
PurpleAccountSettingValue v;
v.type = purple_account_option_get_type(option);
std::string key(purple_account_option_get_setting(option));
switch (v.type) {
case PURPLE_PREF_BOOLEAN:
if (g_key_file_has_key(keyfile, "purple", key.c_str(), NULL)) {
loadBoolean(v.b, "purple", key);
configuration.purple_account_settings[key] = v;
}
// else
// v.b = purple_account_option_get_default_bool(option);
break;
case PURPLE_PREF_INT:
if (g_key_file_has_key(keyfile, "purple", key.c_str(), NULL)) {
loadInteger(v.i, "purple", key);
configuration.purple_account_settings[key] = v;
}
// else
// v.i = purple_account_option_get_default_int(option);
break;
case PURPLE_PREF_STRING:
if (g_key_file_has_key(keyfile, "purple", key.c_str(), NULL)) {
std::string str;
loadString(str, "purple", key);
v.str = g_strdup(str.c_str());
configuration.purple_account_settings[key] = v;
}
// else {
// const char *str = purple_account_option_get_default_string(option);
// v.str = str ? g_strdup(str) : NULL;
// }
break;
case PURPLE_PREF_STRING_LIST:
if (g_key_file_has_key(keyfile, "purple", key.c_str(), NULL)) {
loadStringList(v.strlist, "purple", key);
configuration.purple_account_settings[key] = v;
}
break;
default:
continue;
}
}
}
gboolean
purple_plugin_register(PurplePlugin *plugin)
{
g_return_val_if_fail(plugin != NULL, FALSE);
/* If this plugin has been registered already then exit */
if (g_list_find(plugins, plugin))
return TRUE;
/* Ensure the plugin has the requisite information */
if (plugin->info->type == PURPLE_PLUGIN_LOADER)
{
PurplePluginLoaderInfo *loader_info;
loader_info = PURPLE_PLUGIN_LOADER_INFO(plugin);
if (loader_info == NULL)
{
purple_debug_error("plugins", "%s is not loadable, loader plugin missing loader_info\n",
plugin->path);
return FALSE;
}
}
else if (plugin->info->type == PURPLE_PLUGIN_PROTOCOL)
{
PurplePluginProtocolInfo *prpl_info;
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
if (prpl_info == NULL)
{
purple_debug_error("plugins", "%s is not loadable, protocol plugin missing prpl_info\n",
plugin->path);
return FALSE;
}
}
#ifdef PURPLE_PLUGINS
/* This plugin should be probed and maybe loaded--add it to the queue */
load_queue = g_list_append(load_queue, plugin);
#else
if (plugin->info != NULL)
{
if (plugin->info->type == PURPLE_PLUGIN_PROTOCOL)
protocol_plugins = g_list_insert_sorted(protocol_plugins, plugin,
(GCompareFunc)compare_prpl);
if (plugin->info->load != NULL)
if (!plugin->info->load(plugin))
return FALSE;
}
#endif
plugins = g_list_append(plugins, plugin);
return TRUE;
}
int QuetzalAccount::sendRawData(const QByteArray &data)
{
if (!m_account->gc)
return -1;
PurplePluginProtocolInfo *prpl = PURPLE_PLUGIN_PROTOCOL_INFO(m_account->gc->prpl);
if (PURPLE_PROTOCOL_PLUGIN_HAS_FUNC(prpl, send_raw))
return prpl->send_raw(m_account->gc, data.constData(), data.length());
return -1;
}
void QuetzalChat::doLeave()
{
PurpleConnection *gc = m_conv->account->gc;
if (!gc)
return;
PurplePluginProtocolInfo *info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (!info->chat_leave)
return;
info->chat_leave(gc, PURPLE_CONV_CHAT(m_conv)->id);
}
void QuetzalChat::setTopic(const QString &topic)
{
PurpleConnection *gc = m_conv->account->gc;
if (!gc)
return;
PurplePluginProtocolInfo *info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (!info->set_chat_topic)
return;
info->set_chat_topic(gc, PURPLE_CONV_CHAT(m_conv)->id, topic.toUtf8().constData());
}
static void
init_plugin(PurplePlugin *plugin)
{
PurpleAccountOption *option;
oscar_init(PURPLE_PLUGIN_PROTOCOL_INFO(plugin));
option = purple_account_option_string_new(_("Encoding"), "encoding", OSCAR_DEFAULT_CUSTOM_ENCODING);
prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
}
void
_purple_connection_new_unregister(PurpleAccount *account, const char *password, PurpleAccountUnregistrationCb cb, void *user_data)
{
/* Lots of copy/pasted code to avoid API changes. You might want to integrate that into the previous function when posssible. */
PurpleConnection *gc;
PurplePlugin *prpl;
PurplePluginProtocolInfo *prpl_info;
g_return_if_fail(account != NULL);
prpl = purple_find_prpl(purple_account_get_protocol_id(account));
if (prpl != NULL)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
else {
gchar *message;
message = g_strdup_printf(_("Missing protocol plugin for %s"),
purple_account_get_username(account));
purple_notify_error(NULL, _("Unregistration Error"), message, NULL);
g_free(message);
return;
}
if (!purple_account_is_disconnected(account)) {
prpl_info->unregister_user(account, cb, user_data);
return;
}
if (((password == NULL) || (*password == '\0')) &&
!(prpl_info->options & OPT_PROTO_NO_PASSWORD) &&
!(prpl_info->options & OPT_PROTO_PASSWORD_OPTIONAL))
{
purple_debug_error("connection", "Cannot connect to account %s without "
"a password.\n", purple_account_get_username(account));
return;
}
gc = g_new0(PurpleConnection, 1);
PURPLE_DBUS_REGISTER_POINTER(gc, PurpleConnection);
gc->prpl = prpl;
if ((password != NULL) && (*password != '\0'))
gc->password = g_strdup(password);
purple_connection_set_account(gc, account);
purple_connection_set_state(gc, PURPLE_CONNECTING);
connections = g_list_append(connections, gc);
purple_account_set_connection(account, gc);
purple_signal_emit(purple_connections_get_handle(), "signing-on", gc);
purple_debug_info("connection", "Unregistering. gc = %p\n", gc);
prpl_info->unregister_user(account, cb, user_data);
}
void QuetzalChat::doJoin()
{
PurpleConnection *gc = m_conv->account->gc;
if (!gc)
return;
PurplePluginProtocolInfo *info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (!info->join_chat || !info->chat_info_defaults)
return;
GHashTable *comps = info->chat_info_defaults(gc, m_id.toUtf8().constData());
info->join_chat(gc, comps);
g_hash_table_destroy(comps);
}
bool PurpleIMChat::sendMessageCbk(void * dataIn)
{
Mutex::ScopedLock lock(PurpleIMChat::_mutex);
PurpleIMChatCallbackData* cbData = (PurpleIMChatCallbackData*) dataIn;
IMChatSession* chatSession = cbData->getIMChatSession();
// const char * message = (const char *)((misc_t *)data)->data_ptr2;
// char *cleanMess = (char *) message;
// bool cleaned = false;
std::string cleanMsg = cbData->getMessage();
mConvInfo_t *mConv = FindChatStructById(chatSession->getId());
PurpleConversation *gConv = mConv->purple_conv_session; //VOXOX - JRT - 2009.07.09
// special case for ICQ
PurpleAccount *gAccount = purple_conversation_get_account(gConv);
PurplePlugin *prpl = purple_find_prpl(purple_account_get_protocol_id(gAccount));
if (prpl)
{
PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
if (prpl_info->list_icon != NULL)
{
if (!strcmp("icq", prpl_info->list_icon(gAccount, NULL)))
{
// cleanMess = (char *) purple_markup_strip_html(message);
cleanMsg= purple_markup_strip_html( cbData->getMessage().c_str() );
// cleaned = true;
}
}
}
if (purple_conversation_get_type(gConv) == PURPLE_CONV_TYPE_IM)
{
purple_conv_im_send_with_flags(PURPLE_CONV_IM(gConv), cleanMsg.c_str(), PURPLE_MESSAGE_SEND);
}
else if (purple_conversation_get_type(gConv) == PURPLE_CONV_TYPE_CHAT)
{
purple_conv_chat_send_with_flags(PURPLE_CONV_CHAT(gConv), cleanMsg.c_str(), PURPLE_MESSAGE_SEND);
}
// if (cleaned)
// {
// g_free(cleanMess);
// }
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
PurpleRoomlist *purple_roomlist_get_list(PurpleConnection *gc)
{
PurplePluginProtocolInfo *prpl_info = NULL;
g_return_val_if_fail(gc != NULL, NULL);
if (gc->prpl != NULL)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (prpl_info && prpl_info->roomlist_get_list)
return prpl_info->roomlist_get_list(gc);
return NULL;
}
void
purple_prpl_send_attention(PurpleConnection *gc, const char *who, guint type_code)
{
PurpleAttentionType *attn;
PurpleMessageFlags flags;
PurplePlugin *prpl;
PurpleConversation *conv;
gboolean (*send_attention)(PurpleConnection *, const char *, guint);
PurpleBuddy *buddy;
const char *alias;
gchar *description;
time_t mtime;
g_return_if_fail(gc != NULL);
g_return_if_fail(who != NULL);
prpl = purple_find_prpl(purple_account_get_protocol_id(gc->account));
send_attention = PURPLE_PLUGIN_PROTOCOL_INFO(prpl)->send_attention;
g_return_if_fail(send_attention != NULL);
mtime = time(NULL);
attn = purple_get_attention_type_from_code(gc->account, type_code);
if ((buddy = purple_find_buddy(purple_connection_get_account(gc), who)) != NULL)
alias = purple_buddy_get_contact_alias(buddy);
else
alias = who;
if (attn && purple_attention_type_get_outgoing_desc(attn)) {
description = g_strdup_printf(purple_attention_type_get_outgoing_desc(attn), alias);
} else {
description = g_strdup_printf(_("Requesting %s's attention..."), alias);
}
flags = PURPLE_MESSAGE_SEND | PURPLE_MESSAGE_NOTIFY | PURPLE_MESSAGE_SYSTEM;
purple_debug_info("server", "serv_send_attention: sending '%s' to %s\n",
description, who);
if (!send_attention(gc, who, type_code))
return;
conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, gc->account, who);
purple_conv_im_write(PURPLE_CONV_IM(conv), NULL, description, flags, mtime);
purple_prpl_attention(conv, who, type_code, PURPLE_MESSAGE_SEND, time(NULL));
g_free(description);
}
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));
}
/*static void
toggle_nickchange_pref(const char *name, PurplePrefType type, gconstpointer val, gpointer data)
{
}*/
static void nickchange_chat_rename_user
(PurpleConversation *conv, const char *old_user, const char *new_user, const char *new_alias)
{
if (!should_hide_notice(conv, old_user, userstable)) {
PurpleConvChat *chat = PURPLE_CONV_CHAT(conv);
char tmp[2048];
if (purple_strequal(chat->nick, purple_normalize(conv->account, old_user))) {
// Its me!
char *escaped = g_markup_escape_text(new_user, -1);
g_snprintf(tmp, sizeof(tmp),
_("You are now known as %s"), escaped);
g_free(escaped);
} else {
const char *old_alias = old_user;
const char *new_alias = new_user;
char *escaped;
char *escaped2;
PurpleConnection *gc = purple_conversation_get_gc(conv);
PurplePluginProtocolInfo *prpl_info;
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc));
if (prpl_info && !(prpl_info->options & OPT_PROTO_UNIQUE_CHATNAME)) {
PurpleBuddy *buddy;
if ((buddy = purple_find_buddy(gc->account, old_user)) != NULL)
old_alias = purple_buddy_get_contact_alias(buddy);
if ((buddy = purple_find_buddy(gc->account, new_user)) != NULL)
new_alias = purple_buddy_get_contact_alias(buddy);
}
escaped = g_markup_escape_text(old_alias, -1);
escaped2 = g_markup_escape_text(new_alias, -1);
g_snprintf(tmp, sizeof(tmp),
_("%s is now known as %s"), escaped, escaped2);
g_free(escaped);
g_free(escaped2);
}
purple_conversation_write(conv, NULL, tmp,
PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LINKIFY,
time(NULL));
}
if (orig_chat_rename_user)
return orig_chat_rename_user(conv, old_user, new_user, new_alias);
}
bool Transport::canSendFile(PurpleAccount *account, const std::string &uname) {
PurplePlugin *prpl = NULL;
PurplePluginProtocolInfo *prpl_info = NULL;
PurpleConnection *gc = purple_account_get_connection(account);
if (gc)
prpl = purple_connection_get_prpl(gc);
if (prpl)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
if (prpl_info && prpl_info->send_file) {
if (prpl_info->can_receive_file && prpl_info->can_receive_file(gc, uname.c_str())) {
return true;
}
}
return false;
}
void purple_roomlist_cancel_get_list(PurpleRoomlist *list)
{
PurplePluginProtocolInfo *prpl_info = NULL;
PurpleConnection *gc;
g_return_if_fail(list != NULL);
gc = purple_account_get_connection(list->account);
g_return_if_fail(gc != NULL);
if (gc != NULL && gc->prpl != NULL)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (prpl_info && prpl_info->roomlist_cancel)
prpl_info->roomlist_cancel(list);
}
static void irc_connected(struct irc_conn *irc, const char *nick)
{
PurpleConnection *gc;
PurpleStatus *status;
PurpleBlistNode *gnode, *cnode, *bnode;
if ((gc = purple_account_get_connection(irc->account)) == NULL
|| PURPLE_CONNECTION_IS_CONNECTED(gc))
return;
purple_connection_set_display_name(gc, nick);
purple_connection_set_state(gc, PURPLE_CONNECTED);
/* If we're away then set our away message */
status = purple_account_get_active_status(irc->account);
if (!purple_status_get_type(status) != PURPLE_STATUS_AVAILABLE) {
PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
prpl_info->set_status(irc->account, status);
}
/* this used to be in the core, but it's not now */
for (gnode = purple_get_blist()->root; gnode; gnode = gnode->next) {
if(!PURPLE_BLIST_NODE_IS_GROUP(gnode))
continue;
for(cnode = gnode->child; cnode; cnode = cnode->next) {
if(!PURPLE_BLIST_NODE_IS_CONTACT(cnode))
continue;
for(bnode = cnode->child; bnode; bnode = bnode->next) {
PurpleBuddy *b;
if(!PURPLE_BLIST_NODE_IS_BUDDY(bnode))
continue;
b = (PurpleBuddy *)bnode;
if(b->account == gc->account) {
struct irc_buddy *ib = g_new0(struct irc_buddy, 1);
ib->name = g_strdup(b->name);
g_hash_table_insert(irc->buddies, ib->name, ib);
}
}
}
}
irc_blist_timeout(irc);
if (!irc->timer)
irc->timer = purple_timeout_add_seconds(45, (GSourceFunc)irc_blist_timeout, (gpointer)irc);
}
static void
do_prpl_change_account_status(PurpleAccount *account,
PurpleStatus *old_status, PurpleStatus *new_status)
{
PurplePlugin *prpl;
PurplePluginProtocolInfo *prpl_info;
if (purple_status_is_online(new_status) &&
purple_account_is_disconnected(account) &&
purple_network_is_available())
{
purple_account_connect(account);
return;
}
if (!purple_status_is_online(new_status))
{
if (!purple_account_is_disconnected(account))
purple_account_disconnect(account);
/* Clear out the unsaved password if we're already disconnected and we switch to offline status */
else if (!purple_account_get_remember_password(account))
purple_account_set_password(account, NULL);
return;
}
if (purple_account_is_connecting(account))
/*
* We don't need to call the set_status PRPL function because
* the PRPL will take care of setting its status during the
* connection process.
*/
return;
prpl = purple_find_prpl(purple_account_get_protocol_id(account));
if (prpl == NULL)
return;
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
if (!purple_account_is_disconnected(account) && prpl_info->set_status != NULL)
{
prpl_info->set_status(account, new_status);
}
}
PurpleRoomlist *purple_roomlist_get_list(PurpleConnection *gc)
{
PurplePlugin *prpl = NULL;
PurplePluginProtocolInfo *prpl_info = NULL;
g_return_val_if_fail(gc != NULL, NULL);
g_return_val_if_fail(PURPLE_CONNECTION_IS_CONNECTED(gc), NULL);
prpl = purple_connection_get_prpl(gc);
if(prpl != NULL)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
if(prpl_info && prpl_info->roomlist_get_list)
return prpl_info->roomlist_get_list(gc);
return NULL;
}
static gboolean
send_keepalive(gpointer data)
{
PurpleConnection *gc = data;
PurplePluginProtocolInfo *prpl_info;
/* Only send keep-alives if we haven't heard from the
* server in a while.
*/
if ((time(NULL) - gc->last_received) < KEEPALIVE_INTERVAL)
return TRUE;
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (prpl_info->keepalive)
prpl_info->keepalive(gc);
return TRUE;
}
void purple_roomlist_expand_category(PurpleRoomlist *list, PurpleRoomlistRoom *category)
{
PurplePluginProtocolInfo *prpl_info = NULL;
PurpleConnection *gc;
g_return_if_fail(list != NULL);
g_return_if_fail(category != NULL);
g_return_if_fail(category->type & PURPLE_ROOMLIST_ROOMTYPE_CATEGORY);
gc = purple_account_get_connection(list->account);
g_return_if_fail(gc != NULL);
if (gc->prpl != NULL)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (prpl_info && prpl_info->roomlist_expand_category)
prpl_info->roomlist_expand_category(list, category);
}
gboolean
purple_media_send_dtmf(PurpleMedia *media, const gchar *session_id,
gchar dtmf, guint8 volume, guint16 duration)
{
#ifdef USE_VV
PurpleAccount *account = NULL;
PurpleConnection *gc = NULL;
PurplePlugin *prpl = NULL;
PurplePluginProtocolInfo *prpl_info = NULL;
PurpleMediaBackendIface *backend_iface = NULL;
if (media)
{
account = purple_media_get_account(media);
backend_iface = PURPLE_MEDIA_BACKEND_GET_INTERFACE(media->priv->backend);
}
if (account)
gc = purple_account_get_connection(account);
if (gc)
prpl = purple_connection_get_prpl(gc);
if (prpl)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
if (dtmf == 'a')
dtmf = 'A';
else if (dtmf == 'b')
dtmf = 'B';
else if (dtmf == 'c')
dtmf = 'C';
else if (dtmf == 'd')
dtmf = 'D';
g_return_val_if_fail(strchr("0123456789ABCD#*", dtmf), FALSE);
if (backend_iface && backend_iface->send_dtmf
&& backend_iface->send_dtmf(media->priv->backend,
session_id, dtmf, volume, duration))
{
return TRUE;
}
#endif
return FALSE;
}
void BuddyListNode::ContextMenu::appendProtocolMenu(PurpleConnection *gc)
{
PurplePluginProtocolInfo *prpl_info
= PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc));
if (!prpl_info || !prpl_info->blist_node_menu)
return;
GList *ll = prpl_info->blist_node_menu(parent_node->getPurpleBlistNode());
for (GList *l = ll; l; l = l->next) {
PurpleMenuAction *act = reinterpret_cast<PurpleMenuAction*>(l->data);
appendMenuAction(*this, act);
}
if (ll) {
// append a separator because there has been some items
appendSeparator();
}
g_list_free(ll);
}
