static void
write_status(PurpleBuddy *buddy, const char *message)
{
PurpleAccount *account = NULL;
PurpleConversation *conv;
const char *who;
char buf[256];
char *escaped;
const gchar *buddy_name = NULL;
account = purple_buddy_get_account(buddy);
buddy_name = purple_buddy_get_name(buddy);
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM,
buddy_name, account);
if (conv == NULL)
return;
g_return_if_fail(conv->type == PURPLE_CONV_TYPE_IM);
/* Prevent duplicate notifications for buddies in multiple groups */
if (buddy != purple_find_buddy(buddy->account, buddy->name))
return;
who = purple_buddy_get_alias(buddy);
escaped = g_markup_escape_text(who, -1);
g_snprintf(buf, sizeof(buf), message, escaped);
g_free(escaped);
purple_conv_im_write(conv->u.im, NULL, buf, PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_ACTIVE_ONLY | PURPLE_MESSAGE_NO_LINKIFY, time(NULL));
}
static int tgprpl_send_im (PurpleConnection * gc, const char *who, const char *message, PurpleMessageFlags flags) {
debug ("tgprpl_send_im()\n");
telegram_conn *conn = purple_connection_get_protocol_data(gc);
PurpleAccount *pa = conn->pa;
// this is part of a workaround to support clients without
// the request API (request.h), see telegram-base.c:request_code()
if (conn->in_fallback_chat) {
request_code_entered (conn->TLS, message);
conn->in_fallback_chat = 0;
return 1;
}
PurpleBuddy *b = purple_find_buddy (pa, who);
if (!b) {
warning ("Buddy %s not found, cannot send IM\n", who);
return -1;
}
tgl_peer_t *peer = tgl_peer_get(conn->TLS, TGL_MK_USER(atoi (who)));
if (!peer) {
warning ("Protocol data tgl_peer_t for %s not found, cannot send IM\n", who);
return -1;
}
gchar *raw = purple_unescape_html(message);
tgl_do_send_message (conn->TLS, peer->id, raw, (int)strlen (raw), 0, 0);
g_free(raw);
return 1;
}
/* received-im-msg */
static void
received_im_msg(PurpleAccount *account, char *sender, char *message, PurpleConversation *conv, PurpleMessageFlags flags) {
PurpleBuddy *buddy;
CapStatistics *stats;
/* guint words = word_count(message); */
if (flags & PURPLE_MESSAGE_AUTO_RESP)
return;
buddy = purple_find_buddy(account, sender);
if (buddy == NULL)
return;
stats = get_stats_for(buddy);
/* insert_word_count(sender, buddy_name, words); */
/* If we are waiting for a response from a prior message
* then cancel the timeout callback. */
if(stats->timeout_source_id != 0) {
purple_debug_info("cap", "Cancelling timeout callback\n");
purple_timeout_remove(stats->timeout_source_id);
stats->timeout_source_id = 0;
}
insert_cap_success(stats);
/* Reset the last_message value */
stats->last_message = -1;
/* Reset the last status id value */
stats->last_message_status_id = NULL;
}
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;
}
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;
}
gboolean
purple_privacy_check(PurpleAccount *account, const char *who)
{
GSList *list;
switch (account->perm_deny) {
case PURPLE_PRIVACY_ALLOW_ALL:
return TRUE;
case PURPLE_PRIVACY_DENY_ALL:
return FALSE;
case PURPLE_PRIVACY_ALLOW_USERS:
who = purple_normalize(account, who);
for (list=account->permit; list!=NULL; list=list->next) {
if (!purple_utf8_strcasecmp(who, (char *)list->data))
return TRUE;
}
return FALSE;
case PURPLE_PRIVACY_DENY_USERS:
who = purple_normalize(account, who);
for (list=account->deny; list!=NULL; list=list->next) {
if (!purple_utf8_strcasecmp(who, (char *)list->data ))
return FALSE;
}
return TRUE;
case PURPLE_PRIVACY_ALLOW_BUDDYLIST:
return (purple_find_buddy(account, who) != NULL);
default:
g_return_val_if_reached(TRUE);
}
}
static gboolean should_hide_notice(PurpleConversation *conv, const char *name,
GHashTable *users)
{
PurpleConvChat *chat;
int threshold;
struct joinpart_key key;
time_t *last_said;
g_return_val_if_fail(conv != NULL, FALSE);
g_return_val_if_fail(purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT, FALSE);
/* If the room is small, don't bother. */
chat = PURPLE_CONV_CHAT(conv);
threshold = purple_prefs_get_int(THRESHOLD_PREF);
if (g_list_length(purple_conv_chat_get_users(chat)) < threshold)
return FALSE;
if (!purple_prefs_get_bool(HIDE_BUDDIES_PREF) &&
purple_find_buddy(purple_conversation_get_account(conv), name))
return FALSE;
/* Only show the notice if the user has spoken recently. */
key.conv = conv;
key.user = (gchar *)name;
last_said = g_hash_table_lookup(users, &key);
if (last_said != NULL)
{
int delay = purple_prefs_get_int(DELAY_PREF);
if (delay > 0 && (*last_said + (delay * 60)) >= time(NULL))
return FALSE;
}
return TRUE;
}
/*
* Subtypes 0x000b (SNAC_SUBTYPE_BUDDY_ONCOMING) and 0x000c (SNAC_SUBTYPE_BUDDY_OFFGOING) - Change in buddy status
*
* Oncoming Buddy notifications contain a subset of the
* user information structure. It's close enough to run
* through aim_info_extract() however.
*
* Although the offgoing notification contains no information,
* it is still in a format parsable by aim_info_extract().
*
*/
static int
buddychange(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
int ret = 0;
aim_userinfo_t userinfo;
aim_rxcallback_t userfunc;
aim_info_extract(od, bs, &userinfo);
if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
ret = userfunc(od, conn, frame, &userinfo);
if (snac->subtype == SNAC_SUBTYPE_BUDDY_ONCOMING &&
userinfo.capabilities & OSCAR_CAPABILITY_XTRAZ) {
PurpleAccount *account = purple_connection_get_account(od->gc);
PurpleBuddy *buddy = purple_find_buddy(account, userinfo.bn);
if (buddy) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
if (purple_presence_is_status_primitive_active(presence, PURPLE_STATUS_MOOD))
icq_im_xstatus_request(od, userinfo.bn);
}
}
aim_info_free(&userinfo);
return ret;
}
static void buddy_add_input(PurpleConnection *gc, guint32 uid, gchar *reason)
{
PurpleAccount *account = purple_connection_get_account(gc);
qq_buddy_req *add_req;
gchar *who;
g_return_if_fail(uid != 0 && reason != NULL);
purple_debug_info("QQ", "Buddy %u request adding, msg: %s\n", uid, reason);
add_req = g_new0(qq_buddy_req, 1);
add_req->gc = gc;
add_req->uid = uid;
if (purple_prefs_get_bool("/plugins/prpl/qq/auto_get_authorize_info")) {
qq_request_buddy_info(gc, add_req->uid, 0, QQ_BUDDY_INFO_DISPLAY);
}
who = uid_to_purple_name(add_req->uid);
purple_account_request_authorization(account,
who, NULL,
NULL, reason,
purple_find_buddy(account, who) != NULL,
buddy_add_authorize_cb,
buddy_add_deny_cb,
add_req);
g_free(who);
}
static void plainprpl_get_info(PurpleConnection *gc, const char *buddy_name)
{
PurpleBuddy *buddy;
plain_buddy_state *bstate;
PurpleNotifyUserInfo *info;
const char *addr_str;
buddy = purple_find_buddy(gc->account, buddy_name);
bstate = purple_buddy_get_protocol_data(buddy);
info = purple_notify_user_info_new();
if (bstate) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const char *status_name = purple_status_get_name(status);
purple_notify_user_info_add_pair(info, "Status", status_name);
addr_str = purple_blist_node_get_string(PURPLE_BLIST_NODE(buddy), "addr_str");
purple_notify_user_info_add_pair(info, "Address", addr_str);
if (bstate->state == BUDDY_STATE_RESOLVE) {
/* The IP address has not been resolved yet */
purple_notify_user_info_add_pair(info, "Resolved", "Unknown");
} else {
purple_notify_user_info_add_pair(info, "Resolved", str_addr(&bstate->addr));
}
purple_notify_user_info_add_pair(info, "Last Seen", str_time(bstate->time_recv));
} else {
purple_notify_user_info_add_pair(info, "Info", "Missing Data");
}
/* Show a buddy's user info in a nice dialog box */
purple_notify_userinfo(gc, buddy_name, info, NULL, NULL);
}
void
translate_receiving_message_cb(const gchar *original_phrase, const gchar *translated_phrase, const gchar *detected_language, gpointer userdata)
{
struct TranslateConvMessage *convmsg = userdata;
PurpleBuddy *buddy;
gchar *html_text;
const gchar *stored_lang = "";
const gchar *language_name = NULL;
gchar *message;
if (detected_language)
{
buddy = purple_find_buddy(convmsg->account, convmsg->sender);
stored_lang = purple_blist_node_get_string((PurpleBlistNode *)buddy, DEST_LANG_SETTING);
purple_blist_node_set_string((PurpleBlistNode *)buddy, DEST_LANG_SETTING, detected_language);
language_name = get_language_name(detected_language);
if (language_name != NULL)
{
message = g_strdup_printf("Now translating to %s (auto-detected)", language_name);
purple_conversation_write(convmsg->conv, NULL, message, PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG, time(NULL));
g_free(message);
}
}
html_text = purple_strdup_withhtml(translated_phrase);
purple_conversation_write(convmsg->conv, convmsg->sender, html_text, convmsg->flags, time(NULL));
g_free(html_text);
g_free(convmsg->sender);
g_free(convmsg);
}
static void
translate_conversation_created(PurpleConversation *conv)
{
PurpleBlistNode *node = NULL;
gchar *message;
const gchar *language_key;
const gchar *language_name;
if (conv->type == PURPLE_CONV_TYPE_IM)
node = (PurpleBlistNode *) purple_find_buddy(conv->account, conv->name);
else if (conv->type == PURPLE_CONV_TYPE_CHAT)
node = (PurpleBlistNode *) purple_blist_find_chat(conv->account, conv->name);
if (node != NULL)
{
language_key = purple_blist_node_get_string(node, DEST_LANG_SETTING);
if (language_key != NULL)
{
language_name = get_language_name(language_key);
message = g_strdup_printf(_("Now translating to %s"), language_name);
purple_conversation_write(conv, NULL, message, PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG, time(NULL));
g_free(message);
}
}
}
static gboolean fx_send_attention(PurpleConnection *gc, const gchar *who, guint UNUSED(type))
{
PurpleBuddy *buddy;
PurplePresence *presence;
PurpleStatus *status;
const gchar *status_id;
fetion_account *sec;
fetion_account *ac = purple_connection_get_protocol_data(gc);
if(!(buddy = purple_find_buddy(ac->account, who))) return 0;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_active_status(presence);
status_id = purple_status_get_id(status);
/* online,need invite */
if(strcmp(status_id, "Offline") != 0) {
if(!(sec = session_find(who)))
new_chat(ac, who, (gchar*)0);
else
fetion_send_nudge(sec, who);
return TRUE;
}
return FALSE;
}
static void
bonjour_xfer_init(PurpleXfer *xfer)
{
PurpleBuddy *buddy;
BonjourBuddy *bb;
XepXfer *xf;
xf = (XepXfer*)xfer->data;
if(xf == NULL)
return;
purple_debug_info("bonjour", "Bonjour-xfer-init.\n");
buddy = purple_find_buddy(xfer->account, xfer->who);
/* this buddy is offline. */
if (buddy == NULL || (bb = purple_buddy_get_protocol_data(buddy)) == NULL)
return;
/* Assume it is the first IP. We could do something like keep track of which one is in use or something. */
if (bb->ips)
xf->buddy_ip = g_strdup(bb->ips->data);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) {
/* initiate file transfer, send SI offer. */
purple_debug_info("bonjour", "Bonjour xfer type is PURPLE_XFER_SEND.\n");
xep_ft_si_offer(xfer, xfer->who);
} else {
/* accept file transfer request, send SI result. */
xep_ft_si_result(xfer, xfer->who);
purple_debug_info("bonjour", "Bonjour xfer type is PURPLE_XFER_RECEIVE.\n");
}
}
static void om_login(PurpleAccount *account)
{
PurpleBuddy *bud;
OmegleAccount *oma;
//make sure there's an Omegle buddy on the buddy list
bud = purple_find_buddy(account, "omegle");
if (bud == NULL)
{
bud = purple_buddy_new(account, "omegle", "Omegle");
purple_blist_add_buddy(bud, NULL, NULL, NULL);
}
purple_prpl_got_user_status(account, "omegle", purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE), NULL);
oma = g_new0(OmegleAccount, 1);
oma->account = account;
oma->pc = purple_account_get_connection(account);
oma->cookie_table = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, g_free);
oma->hostname_ip_cache = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, g_free);
account->gc->proto_data = oma;
//No such thing as a login
purple_connection_set_state(purple_account_get_connection(account), PURPLE_CONNECTED);
}
static char *
purplemot_status_text(PurpleBuddy *buddy) {
purple_debug_info("purplemot", "getting %s's status text for %s\n",
buddy->name, buddy->account->username);
if (purple_find_buddy(buddy->account, buddy->name)) {
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
const char *name = purple_status_get_name(status);
const char *message = purple_status_get_attr_string(status, "message");
char *text;
if (message && strlen(message) > 0)
text = g_strdup_printf("%s: %s", name, message);
else
text = g_strdup(name);
purple_debug_info("purplemot", "%s's status text is %s\n", buddy->name, text);
return text;
} else {
purple_debug_info("purplemot", "...but %s is not logged in\n", buddy->name);
return g_strdup("Not logged in");
}
}
qq_buddy_data *qq_room_buddy_find_or_new(PurpleConnection *gc, qq_room_data *rmd, guint32 member_uid)
{
qq_buddy_data *member, *bd;
PurpleBuddy *buddy;
gchar * member_name;
g_return_val_if_fail(rmd != NULL && member_uid > 0, NULL);
member = qq_room_buddy_find(rmd, member_uid);
if (member == NULL) { /* first appear during my session */
member = g_new0(qq_buddy_data, 1);
member->uid = member_uid;
member_name = uid_to_purple_name(member_uid);
buddy = purple_find_buddy(purple_connection_get_account(gc), member_name);
g_free(member_name);
if (buddy != NULL) {
const gchar *alias = NULL;
bd = purple_buddy_get_protocol_data(buddy);
if (bd != NULL && bd->nickname != NULL)
member->nickname = g_strdup(bd->nickname);
else if ((alias = purple_buddy_get_alias(buddy)) != NULL)
member->nickname = g_strdup(alias);
}
rmd->members = g_list_append(rmd->members, member);
}
return member;
}
/*------------------------------------------------------------------------
* Request profile information for another MXit contact.
*
* @param gc The connection object
* @param who The username of the contact.
*/
static void mxit_get_info( PurpleConnection *gc, const char *who )
{
PurpleBuddy* buddy;
struct contact* contact;
struct MXitSession* session = purple_connection_get_protocol_data( gc );
const char* profilelist[] = { CP_PROFILE_BIRTHDATE, CP_PROFILE_GENDER, CP_PROFILE_FULLNAME,
CP_PROFILE_FIRSTNAME, CP_PROFILE_LASTNAME, CP_PROFILE_REGCOUNTRY, CP_PROFILE_LASTSEEN,
CP_PROFILE_STATUS, CP_PROFILE_AVATAR, CP_PROFILE_WHEREAMI, CP_PROFILE_ABOUTME, CP_PROFILE_RELATIONSHIP };
purple_debug_info( MXIT_PLUGIN_ID, "mxit_get_info: '%s'\n", who );
/* find the buddy information for this contact (reference: "libpurple/blist.h") */
buddy = purple_find_buddy( session->acc, who );
if ( buddy ) {
/* user is in our contact-list, so it's not an invite */
contact = purple_buddy_get_protocol_data( buddy );
if ( !contact )
return;
/* only MXit users have profiles */
if ( contact->type != MXIT_TYPE_MXIT ) {
mxit_popup( PURPLE_NOTIFY_MSG_WARNING, _( "No profile available" ), _( "This contact does not have a profile." ) );
return;
}
}
/* send profile request */
mxit_send_extprofile_request( session, who, ARRAY_SIZE( profilelist ), profilelist );
}
static void close_offline_tabs_cb(GtkWidget *w, GObject *menu)
{
GList *iter;
PidginConversation *gtkconv, *gconv;
PidginWindow *win;
PurpleConversation *purpconv;
PurpleAccount *account;
PurpleBuddy *buddy;
gtkconv = g_object_get_data(menu, "clicked_tab");
if (!gtkconv)
return;
win = pidgin_conv_get_window(gtkconv);
for (iter = pidgin_conv_window_get_gtkconvs(win); iter; )
{
gconv = iter->data;
iter = iter->next;
purpconv = gconv->active_conv;
account = purpconv->account;
buddy = purple_find_buddy(account, purpconv->name);
if(!PURPLE_BUDDY_IS_ONLINE(buddy)){
close_conv_cb(NULL, gconv);
}
}
}
/* when you are added by a person, QQ server will send sys message */
static void server_buddy_added(PurpleConnection *gc, gchar *from, gchar *to,
guint8 *data, gint data_len)
{
PurpleAccount *account = purple_connection_get_account(gc);
PurpleBuddy *buddy;
guint32 uid;
qq_buddy_req *add_req;
gchar *who;
gchar *primary;
g_return_if_fail(from != NULL && to != NULL);
uid = strtoul(from, NULL, 10);
who = uid_to_purple_name(uid);
buddy = purple_find_buddy(account, who);
if (buddy != NULL) {
purple_account_notify_added(account, from, to, NULL, NULL);
}
add_req = g_new0(qq_buddy_req, 1);
add_req->gc = gc;
add_req->uid = uid; /* only need to get value */
primary = g_strdup_printf(_("You have been added by %s"), from);
purple_request_action(gc, NULL, primary,
_("Would you like to add him?"),
PURPLE_DEFAULT_ACTION_NONE,
purple_connection_get_account(gc), who, NULL,
add_req, 2,
_("Add"), G_CALLBACK(add_buddy_no_auth_cb),
_("Cancel"), G_CALLBACK(buddy_req_cancel_cb));
g_free(who);
g_free(primary);
}
/*
* From libpurple/prpl.h:
*
* This PRPL function should return a positive value on success.
* If the message is too big to be sent, return -E2BIG. If
* the account is not connected, return -ENOTCONN. If the
* PRPL is unable to send the message for another reason, return
* some other negative value. You can use one of the valid
* errno values, or just big something. If the message should
* not be echoed to the conversation window, return 0.
*/
static int plainprpl_send_im(PurpleConnection *gc, const char *who, const char *msg, PurpleMessageFlags flags)
{
purple_debug_info("plainprpl", "Try to send message of %d bytes to %s\n", strlen(msg), who);
plain_buddy_state *bstate;
plain_plugin_state *pstate;
PurpleBuddy *buddy;
/*
if (strlen(msg) > MAX_MESSAGE_SIZE) {
purple_debug_info("plainprpl", "Message too long. Cannot send %d bytes to %s\n", strlen(msg), who);
serv_got_im(gc, who, "The messag was too long to be send.", PURPLE_MESSAGE_SYSTEM, time(NULL));
return -E2BIG;
}
*/
buddy = purple_find_buddy(gc->account, who);
if (buddy == NULL) {
return -999;
}
bstate = purple_buddy_get_protocol_data(buddy);
if (bstate == NULL) {
return -999;
}
pstate = purple_connection_get_protocol_data(gc);
if (send_msg(pstate, bstate, msg) < 0) {
return -999;
}
return 1;
}
/*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);
}
void twitter_conv_icon_got_user_icon(PurpleAccount * account, const char *user_name, const gchar * url, time_t icon_time)
{
/* look local icon cache for the requested icon */
PurpleConnection *gc = purple_account_get_connection(account);
TwitterConnectionData *twitter = gc->proto_data;
TwitterConvIcon *conv_icon = NULL;
GHashTable *hash = twitter->icons;
if (!hash)
return;
/* since this function is called after mark_icon_for_user(), data
* must exist here. */
conv_icon = twitter_conv_icon_find(account, user_name);
if (!conv_icon) {
conv_icon = twitter_conv_icon_new(account, user_name);
g_hash_table_insert(hash, g_strdup(purple_normalize(account, user_name)), conv_icon);
conv_icon->mtime = icon_time;
} else {
//A new icon is one posted with a tweet later than the current saved icon time
//and with a different url
gboolean new_icon = !conv_icon->icon_url || (strcmp(url, conv_icon->icon_url) && icon_time > conv_icon->mtime);
purple_debug_info(PLUGIN_ID, "Have icon %s (%lld) for user %s, looking for %s (%lld)\n", conv_icon->icon_url, (long long int) conv_icon->mtime, user_name, url, (long long int) icon_time);
if (icon_time > conv_icon->mtime)
conv_icon->mtime = icon_time;
//Return if the image is cached already and it's the same one
if (conv_icon->pixbuf && !new_icon)
return;
/* Return if user's icon has been requested already. */
if (conv_icon->requested && !new_icon)
return;
//If we're already requesting, but it's a different url, cancel the fetch
if (conv_icon->fetch_data)
purple_util_fetch_url_cancel(conv_icon->fetch_data);
conv_icon_clear(conv_icon);
}
conv_icon->icon_url = g_strdup(url);
//For buddies, we don't want to retrieve the icon here, we'll
//let the twitter_buddy fetch the icon and let us know when it's done
if (purple_find_buddy(account, user_name))
return;
conv_icon->requested = TRUE;
/* Create the URL for an user's icon. */
if (url) {
BuddyIconContext *ctx = twitter_buddy_icon_context_new(account, user_name, url);
purple_debug_info(PLUGIN_ID, "requesting %s for %s\n", url, user_name);
conv_icon->fetch_data = purple_util_fetch_url_request_len_with_account(account, url, TRUE, NULL, FALSE, NULL, TRUE, -1, got_page_cb, ctx);
}
}
PurpleBuddyIcon *
purple_buddy_icons_find(PurpleAccount *account, const char *username)
{
GHashTable *icon_cache;
PurpleBuddyIcon *icon = NULL;
g_return_val_if_fail(account != NULL, NULL);
g_return_val_if_fail(username != NULL, NULL);
icon_cache = g_hash_table_lookup(account_cache, account);
if ((icon_cache == NULL) || ((icon = g_hash_table_lookup(icon_cache, username)) == NULL))
{
PurpleBuddy *b = purple_find_buddy(account, username);
const char *protocol_icon_file;
const char *dirname;
gboolean caching;
guchar *data;
size_t len;
if (!b)
return NULL;
protocol_icon_file = purple_blist_node_get_string((PurpleBlistNode*)b, "buddy_icon");
if (protocol_icon_file == NULL)
return NULL;
dirname = purple_buddy_icons_get_cache_dir();
caching = purple_buddy_icons_is_caching();
/* By disabling caching temporarily, we avoid a loop
* and don't have to add special code through several
* functions. */
purple_buddy_icons_set_caching(FALSE);
if (protocol_icon_file != NULL)
{
char *path = g_build_filename(dirname, protocol_icon_file, NULL);
if (read_icon_file(path, &data, &len))
{
const char *checksum;
icon = purple_buddy_icon_create(account, username);
icon->img = NULL;
checksum = purple_blist_node_get_string((PurpleBlistNode*)b, "icon_checksum");
purple_buddy_icon_set_data(icon, data, len, checksum);
}
else
delete_buddy_icon_settings((PurpleBlistNode*)b, "buddy_icon");
g_free(path);
}
purple_buddy_icons_set_caching(caching);
}
return (icon ? purple_buddy_icon_ref(icon) : NULL);
}
PurpleBuddy *p2tgl_buddy_find (struct tgl_state *TLS, tgl_peer_id_t user) {
gchar *name = peer_strdup_id(user);
PurpleBuddy *b = purple_find_buddy (tg_get_acc(TLS), name);
g_free (name);
return b;
}
/*check if the msn user is online*/
gboolean
msn_user_is_online(PurpleAccount *account, const char *name)
{
PurpleBuddy *buddy;
buddy = purple_find_buddy(account, name);
return PURPLE_BUDDY_IS_ONLINE(buddy);
}
static int fx_im_send(PurpleConnection *gc, const gchar *who, const gchar *what, PurpleMessageFlags UNUSED(flags))
{
PurpleBuddy *buddy;
PurplePresence *presence;
PurpleStatus *status;
const gchar *status_id;
fetion_account *sec;
PurpleConversation *conv;
fetion_account *ac = purple_connection_get_protocol_data(gc);
Contact *cnt;
gint shutdown = 0;
if(!(buddy = purple_find_buddy(ac->account, who))) return 0;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_active_status(presence);
status_id = purple_status_get_id(status);
cnt = fetion_contact_list_find_by_userid(ac->user->contactList, who);
if(cnt->relationStatus == RELATION_STATUS_UNAUTHENTICATED) {
if(!(conv = purple_find_conversation_with_account(
PURPLE_CONV_TYPE_ANY, who, ac->account))) return -1;
purple_conversation_write(conv, NULL,
_("Failed to send message: Unverified Buddy!"),
PURPLE_MESSAGE_ERROR, time(NULL));
return -1;
}
if(cnt->serviceStatus == BASIC_SERVICE_ABNORMAL){
if(cnt->carrierStatus == CARRIER_STATUS_CLOSED){
shutdown = 1;
}else{
if((cnt->carrier[0] != '\0' && cnt->mobileno[0] == '\0') || cnt->carrier[0] == '\0')
shutdown = 1;
}
}else if(cnt->carrierStatus == CARRIER_STATUS_DOWN)
if(cnt->carrier[0] != '\0') shutdown = 1;
if(shutdown) {
if(!(conv = purple_find_conversation_with_account(
PURPLE_CONV_TYPE_ANY, who, ac->account))) return -1;
purple_conversation_write(conv, NULL,
_("Fail to send message: Buddy has cancled Fetion service!"),
PURPLE_MESSAGE_ERROR, time(NULL));
return -1;
}
/* online,need invite */
if(strcmp(status_id, "Offline") != 0) {
if(!(sec = session_find(who))) new_chat(ac, who, what);
else fetion_send_sms(sec, who, what);
return 1;
}
fetion_send_sms(ac, who, what);
return 1;
}
static VALUE has_buddy(VALUE self, VALUE buddy)
{
PurpleAccount *account;
Data_Get_Struct(self, PurpleAccount, account);
if (purple_find_buddy(account, RSTRING_PTR(buddy)) != NULL) {
return Qtrue;
} else {
return Qfalse;
}
}
void jabber_roster_alias_change(PurpleConnection *gc, const char *name, const char *alias)
{
PurpleBuddy *b = purple_find_buddy(gc->account, name);
if(b != NULL) {
purple_blist_alias_buddy(b, alias);
jabber_roster_update(gc->proto_data, name, NULL);
}
}
struct groupchat *purple_chat_with(struct im_connection *ic, char *who)
{
/* No, "of course" this won't work this way. Or in fact, it almost
does, but it only lets you send msgs to it, you won't receive
any. Instead, we have to click the virtual menu item.
PurpleAccount *pa = ic->proto_data;
PurpleConversation *pc;
PurpleConvChat *pcc;
struct groupchat *gc;
gc = imcb_chat_new( ic, "BitlBee-libpurple groupchat" );
gc->data = pc = purple_conversation_new( PURPLE_CONV_TYPE_CHAT, pa, "BitlBee-libpurple groupchat" );
pc->ui_data = gc;
pcc = PURPLE_CONV_CHAT( pc );
purple_conv_chat_add_user( pcc, ic->acc->user, "", 0, TRUE );
purple_conv_chat_invite_user( pcc, who, "Please join my chat", FALSE );
//purple_conv_chat_add_user( pcc, who, "", 0, TRUE );
*/
/* There went my nice afternoon. :-( */
struct purple_data *pd = ic->proto_data;
PurplePlugin *prpl = purple_plugins_find_with_id(pd->account->protocol_id);
PurplePluginProtocolInfo *pi = prpl->info->extra_info;
PurpleBuddy *pb = purple_find_buddy(pd->account, who);
PurpleMenuAction *mi;
GList *menu;
void (*callback)(PurpleBlistNode *, gpointer); /* FFFFFFFFFFFFFUUUUUUUUUUUUUU */
if (!pb || !pi || !pi->blist_node_menu) {
return NULL;
}
menu = pi->blist_node_menu(&pb->node);
while (menu) {
mi = menu->data;
if (purple_menu_cmp(mi->label, "initiate chat") ||
purple_menu_cmp(mi->label, "initiate conference")) {
break;
}
menu = menu->next;
}
if (menu == NULL) {
return NULL;
}
/* Call the f****r. */
callback = (void *) mi->callback;
callback(&pb->node, mi->data);
return NULL;
}
