int yahoo_c_send(PurpleConnection *gc, int id, PurpleMessage *msg)
{
PurpleChatConversation *c;
int ret;
YahooData *yd;
const gchar *what = purple_message_get_contents(msg);
PurpleMessageFlags flags = purple_message_get_flags(msg);
yd = purple_connection_get_protocol_data(gc);
if (!yd)
return -1;
c = purple_conversations_find_chat(gc, id);
if (!c)
return -1;
if (id != YAHOO_CHAT_ID) {
GList *users;
users = purple_chat_conversation_get_users(c);
ret = yahoo_conf_send(gc,
purple_connection_get_display_name(gc),
purple_conversation_get_name(PURPLE_CONVERSATION(c)),
users, what);
g_list_free(users);
} else {
ret = yahoo_chat_send(gc, purple_connection_get_display_name(gc),
purple_conversation_get_name(PURPLE_CONVERSATION(c)), what, flags);
if (!ret)
purple_serv_got_chat_in(gc, purple_chat_conversation_get_id(c),
purple_connection_get_display_name(gc), flags, what, time(NULL));
}
return ret;
}
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);
}
void yahoo_c_leave(PurpleConnection *gc, int id)
{
YahooData *yd = purple_connection_get_protocol_data(gc);
PurpleChatConversation *c;
if (!yd)
return;
c = purple_conversations_find_chat(gc, id);
if (!c)
return;
if (id != YAHOO_CHAT_ID) {
GList *users;
users = purple_chat_conversation_get_users(c);
yahoo_conf_leave(yd,
purple_conversation_get_name(PURPLE_CONVERSATION(c)),
purple_connection_get_display_name(gc), users);
g_list_free(users);
yd->confs = g_slist_remove(yd->confs, c);
} else {
yahoo_chat_leave(gc, purple_conversation_get_name(PURPLE_CONVERSATION(c)),
purple_connection_get_display_name(gc), TRUE);
}
purple_serv_got_chat_left(gc, id);
}
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
datacast_inform_user(MsnSwitchBoard *swboard, const char *who,
const char *msg, const char *filename)
{
char *username, *str;
PurpleAccount *account;
PurpleBuddy *b;
PurpleConnection *pc;
gboolean chat;
account = swboard->session->account;
pc = purple_account_get_connection(account);
if ((b = purple_blist_find_buddy(account, who)) != NULL)
username = g_markup_escape_text(purple_buddy_get_alias(b), -1);
else
username = g_markup_escape_text(who, -1);
str = g_strdup_printf(msg, username, filename);
g_free(username);
swboard->flag |= MSN_SB_FLAG_IM;
if (swboard->current_users > 1)
chat = TRUE;
else
chat = FALSE;
if (swboard->conv == NULL) {
if (chat)
swboard->conv = PURPLE_CONVERSATION(purple_conversations_find_chat(
purple_account_get_connection(account), swboard->chat_id));
else {
swboard->conv = PURPLE_CONVERSATION(purple_conversations_find_im_with_account(
who, account));
if (swboard->conv == NULL)
swboard->conv = PURPLE_CONVERSATION(purple_im_conversation_new(account, who));
}
}
if (chat)
purple_serv_got_chat_in(pc,
purple_chat_conversation_get_id(PURPLE_CHAT_CONVERSATION(swboard->conv)),
who, PURPLE_MESSAGE_RECV|PURPLE_MESSAGE_SYSTEM, str,
time(NULL));
else
purple_serv_got_im(pc, who, str, PURPLE_MESSAGE_RECV|PURPLE_MESSAGE_SYSTEM,
time(NULL));
g_free(str);
}
void yahoo_c_invite(PurpleConnection *gc, int id, const char *msg, const char *name)
{
PurpleChatConversation *c;
c = purple_conversations_find_chat(gc, id);
if (!c || !purple_conversation_get_name(PURPLE_CONVERSATION(c)))
return;
if (id != YAHOO_CHAT_ID) {
yahoo_conf_invite(gc, c, purple_connection_get_display_name(gc), name,
purple_conversation_get_name(PURPLE_CONVERSATION(c)), msg);
} else {
yahoo_chat_invite(gc, purple_connection_get_display_name(gc), name,
purple_conversation_get_name(PURPLE_CONVERSATION(c)), msg);
}
}
void
fb_util_serv_got_im(PurpleConnection *gc, const gchar *who, const gchar *text,
PurpleMessageFlags flags, guint64 timestamp)
{
const gchar *name;
PurpleAccount *acct;
PurpleIMConversation *conv;
PurpleMessage *msg;
if (!(flags & PURPLE_MESSAGE_SEND)) {
purple_serv_got_im(gc, who, text, flags, timestamp);
return;
}
acct = purple_connection_get_account(gc);
conv = purple_conversations_find_im_with_account(who, acct);
if (conv == NULL) {
conv = purple_im_conversation_new(acct, who);
}
name = purple_account_get_username(acct);
msg = purple_message_new_outgoing(name, text, flags);
purple_message_set_time(msg, timestamp);
purple_conversation_write_message(PURPLE_CONVERSATION(conv), msg);
}
void yahoo_process_chat_exit(PurpleConnection *gc, struct yahoo_packet *pkt)
{
char *who = NULL;
char *room = NULL;
GSList *l;
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
if (pair->key == 104) {
g_free(room);
room = yahoo_string_decode(gc, pair->value, TRUE);
} else if (pair->key == 109) {
if (g_utf8_validate(pair->value, -1, NULL)) {
who = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_chat_exit "
"got non-UTF-8 string for key %d\n", pair->key);
}
}
}
if (who && room) {
PurpleChatConversation *c = purple_conversations_find_chat(gc, YAHOO_CHAT_ID);
if (c && !purple_utf8_strcasecmp(purple_conversation_get_name(
PURPLE_CONVERSATION(c)), room))
purple_chat_conversation_remove_user(c, who, NULL);
}
g_free(room);
}
static void
chat_sent_im(PurpleAccount *account, PurpleMessage *msg, int id)
{
PurpleChatConversation *chat = NULL;
chat = purple_conversations_find_chat(purple_account_get_connection(account), id);
unalert(PURPLE_CONVERSATION(chat));
}
static void ggp_chat_left(ggp_chat_local_info *chat, uin_t uin)
{
uin_t me;
int idx = ggp_chat_participant_find(chat, uin);
if (idx < 0) {
purple_debug_warning("gg", "ggp_chat_joined: "
"user %u isn't present in chat %" G_GUINT64_FORMAT "\n",
uin, chat->id);
return;
}
chat->participants[idx] =
chat->participants[chat->participants_count - 1];
chat->participants_count--;
chat->participants = g_realloc(chat->participants,
sizeof(uin) * chat->participants_count);
if (chat->conv == NULL)
return;
me = ggp_str_to_uin(purple_account_get_username(
purple_connection_get_account(chat->gc)));
if (me == uin) {
purple_conversation_write_system_message(
PURPLE_CONVERSATION(chat->conv),
_("You have left the chat"), 0);
purple_serv_got_chat_left(chat->gc, chat->local_id);
chat->conv = NULL;
chat->left = TRUE;
}
purple_chat_conversation_remove_user(chat->conv, ggp_uin_to_str(uin), NULL);
}
static void
chat_user_left_cb(PurpleChatConversation *chat, const char *name,
const char *reason, PurpleSoundEventID event)
{
if (!chat_nick_matches_name(chat, name))
play_conv_event(PURPLE_CONVERSATION(chat), event);
}
void ggp_chat_got_message(PurpleConnection *gc, uint64_t chat_id,
const char *message, time_t time, uin_t who)
{
ggp_chat_local_info *chat;
uin_t me;
me = ggp_str_to_uin(purple_account_get_username(
purple_connection_get_account(gc)));
chat = ggp_chat_get(gc, chat_id);
if (!chat) {
purple_debug_error("gg", "ggp_chat_got_message: "
"chat %" G_GUINT64_FORMAT " doesn't exists\n", chat_id);
return;
}
ggp_chat_open_conv(chat);
if (who == me) {
PurpleMessage *pmsg;
pmsg = purple_message_new_outgoing(
ggp_uin_to_str(who), message, 0);
purple_message_set_time(pmsg, time);
purple_conversation_write_message(
PURPLE_CONVERSATION(chat->conv), pmsg);
} else {
purple_serv_got_chat_in(gc, chat->local_id, ggp_uin_to_str(who),
PURPLE_MESSAGE_RECV, message, time);
}
}
static void
received_im_msg(PurpleAccount *account, const char *sender, const char *msg,
PurpleIMConversation *im, PurpleMessageFlags flags, gpointer null)
{
if (purple_prefs_get_bool(PREFS_EVENT_IM_MSG))
notify(PURPLE_CONVERSATION(im), _("%s sent you a message"), sender);
}
int ggp_chat_send(PurpleConnection *gc, int local_id, PurpleMessage *msg)
{
GGPInfo *info = purple_connection_get_protocol_data(gc);
PurpleChatConversation *conv;
ggp_chat_local_info *chat;
gboolean succ = TRUE;
const gchar *me;
gchar *gg_msg;
chat = ggp_chat_get_local(gc, local_id);
if (!chat) {
purple_debug_error("gg", "ggp_chat_send: "
"chat %u doesn't exists\n", local_id);
return -1;
}
conv = purple_conversations_find_chat_with_account(
ggp_chat_get_name_from_id(chat->id),
purple_connection_get_account(gc));
gg_msg = ggp_message_format_to_gg(PURPLE_CONVERSATION(conv),
purple_message_get_contents(msg));
if (gg_chat_send_message(info->session, chat->id, gg_msg, TRUE) < 0)
succ = FALSE;
g_free(gg_msg);
me = purple_account_get_username(purple_connection_get_account(gc));
purple_serv_got_chat_in(gc, chat->local_id, me,
purple_message_get_flags(msg),
purple_message_get_contents(msg),
purple_message_get_time(msg));
return succ ? 0 : -1;
}
static void
chat_user_join_cb(PurpleChatConversation *chat, const char *name,
PurpleChatUserFlags flags, gboolean new_arrival,
PurpleSoundEventID event)
{
if (new_arrival && !chat_nick_matches_name(chat, name))
play_conv_event(PURPLE_CONVERSATION(chat), event);
}
static void
im_msg_sent_cb(PurpleAccount *account, PurpleMessage *msg,
PurpleSoundEventID event)
{
PurpleIMConversation *im = purple_conversations_find_im_with_account(
purple_message_get_recipient(msg), account);
play_conv_event(PURPLE_CONVERSATION(im), event);
}
static void
im_msg_sent_cb(PurpleAccount *account, const char *receiver,
const char *message, PurpleSoundEventID event)
{
PurpleConversation *conv = PURPLE_CONVERSATION(
purple_conversations_find_im_with_account(receiver, account));
play_conv_event(conv, event);
}
static void
im_sent_im(PurpleAccount *account, PurpleMessage *msg, gpointer _unused)
{
PurpleIMConversation *im = NULL;
im = purple_conversations_find_im_with_account(
purple_message_get_recipient(msg), account);
unalert(PURPLE_CONVERSATION(im));
}
static void nullprpl_chat_leave(PurpleConnection *gc, int id) {
PurpleChatConversation *chat = purple_conversations_find_chat(gc, id);
purple_debug_info("nullprpl", "%s is leaving chat room %s\n",
purple_account_get_username(purple_connection_get_account(gc)),
purple_conversation_get_name(PURPLE_CONVERSATION(chat)));
/* tell everyone that we left */
foreach_gc_in_chat(left_chat_room, gc, id, NULL);
}
static void nullprpl_get_cb_info(PurpleConnection *gc, int id, const char *who) {
PurpleChatConversation *chat = purple_conversations_find_chat(gc, id);
purple_debug_info("nullprpl",
"retrieving %s's info for %s in chat room %s\n", who,
purple_account_get_username(purple_connection_get_account(gc)),
purple_conversation_get_name(PURPLE_CONVERSATION(chat)));
nullprpl_get_info(gc, who);
}
static void set_chat_topic_fn(PurpleChatConversation *from, PurpleChatConversation *to,
int id, const char *room, gpointer userdata) {
const char *topic = (const char *)userdata;
const char *username = purple_account_get_username(purple_conversation_get_account(PURPLE_CONVERSATION(from)));
char *msg;
purple_chat_conversation_set_topic(to, username, topic);
if (topic && *topic)
msg = g_strdup_printf(_("%s sets topic to: %s"), username, topic);
else
msg = g_strdup_printf(_("%s clears topic"), username);
purple_conversation_write_message(PURPLE_CONVERSATION(to), username, msg,
PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG,
time(NULL));
g_free(msg);
}
static void
chat_sent_im(PurpleAccount *account, const char *message, int id)
{
PurpleChatConversation *chat = NULL;
if (purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_send")) {
chat = purple_conversations_find_chat(purple_account_get_connection(account), id);
unnotify(PURPLE_CONVERSATION(chat), TRUE);
}
}
static void
im_sent_im(PurpleAccount *account, const char *receiver, const char *message)
{
PurpleIMConversation *im = NULL;
if (purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_send")) {
im = purple_conversations_find_im_with_account(receiver, account);
unnotify(PURPLE_CONVERSATION(im), TRUE);
}
}
/* put Message to User Conversation
*
* passport - the one want to talk to you
*/
void
msn_session_report_user(MsnSession *session,const char *passport,const char *msg,PurpleMessageFlags flags)
{
PurpleIMConversation * im;
if ((im = msn_session_get_im(session,passport)) != NULL){
purple_conversation_write_system_message(
PURPLE_CONVERSATION(im), msg, flags);
}
}
static void call_chat_func(gpointer data, gpointer userdata) {
PurpleConnection *to = (PurpleConnection *)data;
ChatFuncData *cfdata = (ChatFuncData *)userdata;
int id = purple_chat_conversation_get_id(cfdata->from_chat);
PurpleChatConversation *chat = purple_conversations_find_chat(to, id);
if (chat)
cfdata->fn(cfdata->from_chat, chat, id,
purple_conversation_get_name(PURPLE_CONVERSATION(chat)), cfdata->userdata);
}
static void
chat_msg_sent_cb(PurpleAccount *account, PurpleMessage *msg, int id,
PurpleSoundEventID event)
{
PurpleConnection *conn = purple_account_get_connection(account);
PurpleChatConversation *chat = NULL;
if (conn!=NULL)
chat = purple_conversations_find_chat(conn, id);
play_conv_event(PURPLE_CONVERSATION(chat), event);
}
static void
chat_msg_sent_cb(PurpleAccount *account, const char *message,
int id, PurpleSoundEventID event)
{
PurpleConnection *conn = purple_account_get_connection(account);
PurpleConversation *conv = NULL;
if (conn!=NULL)
conv = PURPLE_CONVERSATION(purple_conversations_find_chat(conn,id));
play_conv_event(conv, event);
}
static void
chat_msg_received_cb(PurpleAccount *account, char *sender,
char *message, PurpleChatConversation *chat,
PurpleMessageFlags flags, PurpleSoundEventID event)
{
if (flags & PURPLE_MESSAGE_DELAYED)
return;
g_return_if_fail(chat != NULL);
if (purple_chat_conversation_is_ignored_user(chat, sender))
return;
if (chat_nick_matches_name(chat, sender))
return;
if (flags & PURPLE_MESSAGE_NICK || purple_utf8_has_word(message, purple_chat_conversation_get_nick(chat)))
play_conv_event(PURPLE_CONVERSATION(chat), PURPLE_SOUND_CHAT_NICK);
else
play_conv_event(PURPLE_CONVERSATION(chat), event);
}
static void
skypeweb_join_chat(PurpleConnection *pc, GHashTable *data)
{
SkypeWebAccount *sa = purple_connection_get_protocol_data(pc);
gchar *chatname;
gchar *post;
GString *url;
PurpleChatConversation *chatconv;
chatname = (gchar *)g_hash_table_lookup(data, "chatname");
if (chatname == NULL)
{
return;
}
chatconv = purple_conversations_find_chat_with_account(chatname, sa->account);
if (chatconv != NULL) {
purple_conversation_present(PURPLE_CONVERSATION(chatconv));
return;
}
url = g_string_new("/v1/threads/");
g_string_append_printf(url, "%s", purple_url_encode(chatname));
g_string_append(url, "/members/");
g_string_append_printf(url, "8:%s", purple_url_encode(sa->username));
post = "{\"role\":\"User\"}";
skypeweb_post_or_get(sa, SKYPEWEB_METHOD_PUT | SKYPEWEB_METHOD_SSL, sa->messages_host, url->str, post, NULL, NULL, TRUE);
g_string_free(url, TRUE);
skypeweb_get_conversation_history(sa, chatname);
skypeweb_get_thread_users(sa, chatname);
chatconv = purple_serv_got_joined_chat(pc, g_str_hash(chatname), chatname);
purple_conversation_set_data(PURPLE_CONVERSATION(chatconv), "chatname", g_strdup(chatname));
purple_conversation_present(PURPLE_CONVERSATION(chatconv));
}
static gboolean xmpp_uri_handler(const char *proto, const char *user, GHashTable *params)
{
char *acct_id = params ? g_hash_table_lookup(params, "account") : NULL;
PurpleAccount *acct;
if (g_ascii_strcasecmp(proto, "xmpp"))
return FALSE;
acct = find_acct(purple_plugin_get_id(my_protocol), acct_id);
if (!acct)
return FALSE;
/* xmpp:[email protected]?message;subject=Test%20Message;body=Here%27s%20a%20test%20message */
/* params is NULL if the URI has no '?' (or anything after it) */
if (!params || g_hash_table_lookup_extended(params, "message", NULL, NULL)) {
char *body = g_hash_table_lookup(params, "body");
if (user && *user) {
PurpleIMConversation *im =
purple_im_conversation_new(acct, user);
purple_conversation_present(PURPLE_CONVERSATION(im));
if (body && *body)
purple_conversation_send_confirm(PURPLE_CONVERSATION(im), body);
}
} else if (g_hash_table_lookup_extended(params, "roster", NULL, NULL)) {
char *name = g_hash_table_lookup(params, "name");
if (user && *user)
purple_blist_request_add_buddy(acct, user, NULL, name);
} else if (g_hash_table_lookup_extended(params, "join", NULL, NULL)) {
PurpleConnection *gc = purple_account_get_connection(acct);
if (user && *user) {
GHashTable *params = jabber_chat_info_defaults(gc, user);
jabber_chat_join(gc, params);
}
return TRUE;
}
return FALSE;
}
