Mercurial > pidgin
view libpurple/server.c @ 19598:339c7c8c0e08
If MSIM_CHECK_NEWER_VERSION is defined (off by default), run (incomplete)
code to check for a newer official client. Incomplete because libpurple
keeps redirecting because MySpace's servers always send Content-Location header.
author | Jeffrey Connelly <jaconnel@calpoly.edu> |
---|---|
date | Tue, 04 Sep 2007 05:01:25 +0000 |
parents | b17bd24fca8d |
children | 44b4e8bd759b |
line wrap: on
line source
/* * purple * * Purple is the legal property of its developers, whose names are too numerous * to list here. Please refer to the COPYRIGHT file distributed with this * source distribution. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ /* This file is the fullcrap */ #include "internal.h" #include "blist.h" #include "conversation.h" #include "debug.h" #include "log.h" #include "notify.h" #include "prefs.h" #include "privacy.h" #include "prpl.h" #include "request.h" #include "signals.h" #include "server.h" #include "status.h" #include "util.h" #define SECS_BEFORE_RESENDING_AUTORESPONSE 600 #define SEX_BEFORE_RESENDING_AUTORESPONSE "Only after you're married" unsigned int serv_send_typing(PurpleConnection *gc, const char *name, PurpleTypingState state) { PurplePluginProtocolInfo *prpl_info = NULL; if (gc != NULL && gc->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); if (prpl_info && prpl_info->send_typing) return prpl_info->send_typing(gc, name, state); return 0; } static GSList *last_auto_responses = NULL; struct last_auto_response { PurpleConnection *gc; char name[80]; time_t sent; }; static gboolean expire_last_auto_responses(gpointer data) { GSList *tmp, *cur; struct last_auto_response *lar; tmp = last_auto_responses; while (tmp) { cur = tmp; tmp = tmp->next; lar = (struct last_auto_response *)cur->data; if ((time(NULL) - lar->sent) > SECS_BEFORE_RESENDING_AUTORESPONSE) { last_auto_responses = g_slist_remove(last_auto_responses, lar); g_free(lar); } } return FALSE; /* do not run again */ } static struct last_auto_response * get_last_auto_response(PurpleConnection *gc, const char *name) { GSList *tmp; struct last_auto_response *lar; /* because we're modifying or creating a lar, schedule the * function to expire them as the pref dictates */ purple_timeout_add_seconds((SECS_BEFORE_RESENDING_AUTORESPONSE + 1), expire_last_auto_responses, NULL); tmp = last_auto_responses; while (tmp) { lar = (struct last_auto_response *)tmp->data; if (gc == lar->gc && !strncmp(name, lar->name, sizeof(lar->name))) return lar; tmp = tmp->next; } lar = (struct last_auto_response *)g_new0(struct last_auto_response, 1); g_snprintf(lar->name, sizeof(lar->name), "%s", name); lar->gc = gc; lar->sent = 0; last_auto_responses = g_slist_prepend(last_auto_responses, lar); return lar; } int serv_send_im(PurpleConnection *gc, const char *name, const char *message, PurpleMessageFlags flags) { PurpleConversation *conv; PurpleAccount *account; PurplePresence *presence; PurplePluginProtocolInfo *prpl_info; int val = -EINVAL; const gchar *auto_reply_pref; g_return_val_if_fail(gc != NULL, val); g_return_val_if_fail(gc->prpl != NULL, val); prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); account = purple_connection_get_account(gc); presence = purple_account_get_presence(account); conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, name, gc->account); if (prpl_info && prpl_info->send_im) val = prpl_info->send_im(gc, name, message, flags); /* * XXX - If "only auto-reply when away & idle" is set, then shouldn't * this only reset lar->sent if we're away AND idle? */ auto_reply_pref = purple_prefs_get_string("/purple/away/auto_reply"); if ((gc->flags & PURPLE_CONNECTION_AUTO_RESP) && !purple_presence_is_available(presence) && strcmp(auto_reply_pref, "never")) { struct last_auto_response *lar; lar = get_last_auto_response(gc, name); lar->sent = time(NULL); } if (conv && purple_conv_im_get_send_typed_timeout(PURPLE_CONV_IM(conv))) purple_conv_im_stop_send_typed_timeout(PURPLE_CONV_IM(conv)); return val; } void serv_get_info(PurpleConnection *gc, const char *name) { PurplePluginProtocolInfo *prpl_info = NULL; if (gc != NULL && gc->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); if (gc && prpl_info && prpl_info->get_info) prpl_info->get_info(gc, name); } void serv_set_info(PurpleConnection *gc, const char *info) { PurplePluginProtocolInfo *prpl_info = NULL; PurpleAccount *account; if (gc != NULL && gc->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); if (prpl_info && prpl_info->set_info) { account = purple_connection_get_account(gc); if (purple_signal_emit_return_1(purple_accounts_get_handle(), "account-setting-info", account, info)) return; prpl_info->set_info(gc, info); purple_signal_emit(purple_accounts_get_handle(), "account-set-info", account, info); } } /* * Set buddy's alias on server roster/list */ void serv_alias_buddy(PurpleBuddy *b) { PurplePluginProtocolInfo *prpl_info = NULL; if (b != NULL && b->account->gc && b->account->gc->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(b->account->gc->prpl); if (b && prpl_info && prpl_info->alias_buddy) { prpl_info->alias_buddy(b->account->gc, b->name, b->alias); } } void serv_got_alias(PurpleConnection *gc, const char *who, const char *alias) { PurpleAccount *account = purple_connection_get_account(gc); GSList *buddies = purple_find_buddies(account, who); PurpleBuddy *b; PurpleConversation *conv; while (buddies != NULL) { b = buddies->data; buddies = g_slist_delete_link(buddies, buddies); if ((b->server_alias == NULL && alias == NULL) || (b->server_alias && alias && !strcmp(b->server_alias, alias))) { continue; } purple_blist_server_alias_buddy(b, alias); conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, b->name, account); if (conv != NULL && alias != NULL && strcmp(alias, who)) { char *tmp = g_strdup_printf(_("%s is now known as %s.\n"), who, alias); purple_conversation_write(conv, NULL, tmp, PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LINKIFY, time(NULL)); g_free(tmp); } } } PurpleAttentionType *purple_get_attention_type_from_code(PurpleAccount *account, guint type_code) { PurplePlugin *prpl; PurpleAttentionType* attn; GList *(*get_attention_types)(PurpleAccount *); g_return_val_if_fail(account != NULL, NULL); prpl = purple_find_prpl(purple_account_get_protocol_id(account)); /* Lookup the attention type in the protocol's attention_types list, if any. */ get_attention_types = PURPLE_PLUGIN_PROTOCOL_INFO(prpl)->attention_types; if (get_attention_types) { GList *attention_types; attention_types = get_attention_types(account); attn = (PurpleAttentionType *)g_list_nth_data(attention_types, type_code); } else { attn = NULL; } return attn; } void serv_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); 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 (attn && attn->outgoing_description) { description = g_strdup_printf(_("Attention! %s %s."), attn->outgoing_description, who); } else { description = g_strdup(_("Attention!")); } 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); g_free(description); } void serv_got_attention(PurpleConnection *gc, const char *who, guint type_code) { PurpleMessageFlags flags; PurpleAttentionType *attn; gchar *description; time_t mtime; mtime = time(NULL); attn = purple_get_attention_type_from_code(gc->account, type_code); /* PURPLE_MESSAGE_NOTIFY is for attention messages. */ flags = PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NOTIFY | PURPLE_MESSAGE_RECV; /* TODO: if (attn->icon_name) is non-null, use it to lookup an emoticon and display * it next to the attention command. And if it is null, display a generic icon. */ if (attn && attn->incoming_description) { description = g_strdup_printf(_("Attention! You have been %s."), attn->incoming_description); } else { description = g_strdup(_("Attention!")); } purple_debug_info("server", "serv_got_attention: got '%s' from %s\n", description, who); serv_got_im(gc, who, description, flags, mtime); /* TODO: sounds (depending on PurpleAttentionType), shaking, etc. */ g_free(description); } /* * Move a buddy from one group to another on server. * * Note: For now we'll not deal with changing gc's at the same time, but * it should be possible. Probably needs to be done, someday. Although, * the UI for that would be difficult, because groups are Purple-wide. */ void serv_move_buddy(PurpleBuddy *b, PurpleGroup *og, PurpleGroup *ng) { PurplePluginProtocolInfo *prpl_info = NULL; g_return_if_fail(b != NULL); g_return_if_fail(og != NULL); g_return_if_fail(ng != NULL); if (b->account->gc != NULL && b->account->gc->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(b->account->gc->prpl); if (b->account->gc && og && ng) { if (prpl_info && prpl_info->group_buddy) { prpl_info->group_buddy(b->account->gc, b->name, og->name, ng->name); } } } void serv_add_permit(PurpleConnection *g, const char *name) { PurplePluginProtocolInfo *prpl_info = NULL; if (g != NULL && g->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(g->prpl); if (prpl_info && prpl_info->add_permit) prpl_info->add_permit(g, name); } void serv_add_deny(PurpleConnection *g, const char *name) { PurplePluginProtocolInfo *prpl_info = NULL; if (g != NULL && g->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(g->prpl); if (prpl_info && prpl_info->add_deny) prpl_info->add_deny(g, name); } void serv_rem_permit(PurpleConnection *g, const char *name) { PurplePluginProtocolInfo *prpl_info = NULL; if (g != NULL && g->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(g->prpl); if (prpl_info && prpl_info->rem_permit) prpl_info->rem_permit(g, name); } void serv_rem_deny(PurpleConnection *g, const char *name) { PurplePluginProtocolInfo *prpl_info = NULL; if (g != NULL && g->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(g->prpl); if (prpl_info && prpl_info->rem_deny) prpl_info->rem_deny(g, name); } void serv_set_permit_deny(PurpleConnection *g) { PurplePluginProtocolInfo *prpl_info = NULL; if (g != NULL && g->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(g->prpl); /* * this is called when either you import a buddy list, and make lots * of changes that way, or when the user toggles the permit/deny mode * in the prefs. In either case you should probably be resetting and * resending the permit/deny info when you get this. */ if (prpl_info && prpl_info->set_permit_deny) prpl_info->set_permit_deny(g); } void serv_join_chat(PurpleConnection *g, GHashTable *data) { PurplePluginProtocolInfo *prpl_info = NULL; if (g != NULL && g->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(g->prpl); if (prpl_info && prpl_info->join_chat) prpl_info->join_chat(g, data); } void serv_reject_chat(PurpleConnection *g, GHashTable *data) { PurplePluginProtocolInfo *prpl_info = NULL; if (g != NULL && g->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(g->prpl); if (prpl_info && prpl_info->reject_chat) prpl_info->reject_chat(g, data); } void serv_chat_invite(PurpleConnection *g, int id, const char *message, const char *name) { PurplePluginProtocolInfo *prpl_info = NULL; PurpleConversation *conv; char *buffy = message && *message ? g_strdup(message) : NULL; conv = purple_find_chat(g, id); if (conv == NULL) return; if (g != NULL && g->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(g->prpl); purple_signal_emit(purple_conversations_get_handle(), "chat-inviting-user", conv, name, &buffy); if (prpl_info && prpl_info->chat_invite) prpl_info->chat_invite(g, id, buffy, name); purple_signal_emit(purple_conversations_get_handle(), "chat-invited-user", conv, name, buffy); g_free(buffy); } /* Ya know, nothing uses this except purple_conversation_destroy(), * I think I'll just merge it into that later... * Then again, something might want to use this, from outside prpl-land * to leave a chat without destroying the conversation. */ void serv_chat_leave(PurpleConnection *g, int id) { PurplePluginProtocolInfo *prpl_info = NULL; if (g->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(g->prpl); if (prpl_info && prpl_info->chat_leave) prpl_info->chat_leave(g, id); } void serv_chat_whisper(PurpleConnection *g, int id, const char *who, const char *message) { PurplePluginProtocolInfo *prpl_info = NULL; if (g != NULL && g->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(g->prpl); if (prpl_info && prpl_info->chat_whisper) prpl_info->chat_whisper(g, id, who, message); } int serv_chat_send(PurpleConnection *gc, int id, const char *message, PurpleMessageFlags flags) { int val = -EINVAL; PurplePluginProtocolInfo *prpl_info = NULL; if (gc->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); if (prpl_info && prpl_info->chat_send) val = prpl_info->chat_send(gc, id, message, flags); return val; } /* * woo. i'm actually going to comment this function. isn't that fun. make * sure to follow along, kids */ void serv_got_im(PurpleConnection *gc, const char *who, const char *msg, PurpleMessageFlags flags, time_t mtime) { PurpleAccount *account; PurpleConversation *cnv; char *message, *name; char *angel, *buffy; int plugin_return; g_return_if_fail(msg != NULL); account = purple_connection_get_account(gc); if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->set_permit_deny == NULL) { /* protocol does not support privacy, handle it ourselves */ if (!purple_privacy_check(account, who)) return; } /* * We should update the conversation window buttons and menu, * if it exists. */ cnv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, who, gc->account); /* * Plugin stuff. we pass a char ** but we don't want to pass what's * been given us by the prpls. So we create temp holders and pass * those instead. It's basically just to avoid segfaults. */ /* TODO: MAX(message, BUF_LONG) is pretty ugly. */ buffy = g_malloc(MAX(strlen(msg) + 1, BUF_LONG)); strcpy(buffy, msg); angel = g_strdup(who); plugin_return = GPOINTER_TO_INT( purple_signal_emit_return_1(purple_conversations_get_handle(), "receiving-im-msg", gc->account, &angel, &buffy, cnv, &flags)); if (!buffy || !angel || plugin_return) { g_free(buffy); g_free(angel); return; } name = angel; message = buffy; purple_signal_emit(purple_conversations_get_handle(), "received-im-msg", gc->account, name, message, cnv, flags); /* search for conversation again in case it was created by received-im-msg handler */ if (cnv == NULL) cnv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, name, gc->account); /* * XXX: Should we be setting this here, or relying on prpls to set it? */ flags |= PURPLE_MESSAGE_RECV; if (cnv == NULL) cnv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, name); purple_conv_im_write(PURPLE_CONV_IM(cnv), NULL, message, flags, mtime); g_free(message); /* * Don't autorespond if: * * - it's not supported on this connection * - we are available * - or it's disabled * - or we're not idle and the 'only auto respond if idle' pref * is set */ if (gc->flags & PURPLE_CONNECTION_AUTO_RESP) { PurplePresence *presence; PurpleStatus *status; PurpleStatusType *status_type; PurpleStatusPrimitive primitive; const gchar *auto_reply_pref; const char *away_msg = NULL; auto_reply_pref = purple_prefs_get_string("/purple/away/auto_reply"); presence = purple_account_get_presence(account); status = purple_presence_get_active_status(presence); status_type = purple_status_get_type(status); primitive = purple_status_type_get_primitive(status_type); if ((primitive == PURPLE_STATUS_AVAILABLE) || (primitive == PURPLE_STATUS_INVISIBLE) || (primitive == PURPLE_STATUS_MOBILE) || !strcmp(auto_reply_pref, "never") || (!purple_presence_is_idle(presence) && !strcmp(auto_reply_pref, "awayidle"))) { g_free(name); return; } away_msg = purple_value_get_string( purple_status_get_attr_value(status, "message")); if ((away_msg != NULL) && (*away_msg != '\0')) { struct last_auto_response *lar; time_t now = time(NULL); /* * This used to be based on the conversation window. But um, if * you went away, and someone sent you a message and got your * auto-response, and then you closed the window, and then they * sent you another one, they'd get the auto-response back too * soon. Besides that, we need to keep track of this even if we've * got a queue. So the rest of this block is just the auto-response, * if necessary. */ lar = get_last_auto_response(gc, name); if ((now - lar->sent) >= SECS_BEFORE_RESENDING_AUTORESPONSE) { /* * We don't want to send an autoresponse in response to the other user's * autoresponse. We do, however, not want to then send one in response to the * _next_ message, so we still set lar->sent to now. */ lar->sent = now; if (!(flags & PURPLE_MESSAGE_AUTO_RESP)) { serv_send_im(gc, name, away_msg, PURPLE_MESSAGE_AUTO_RESP); purple_conv_im_write(PURPLE_CONV_IM(cnv), NULL, away_msg, PURPLE_MESSAGE_SEND | PURPLE_MESSAGE_AUTO_RESP, mtime); } } } } g_free(name); } void serv_got_typing(PurpleConnection *gc, const char *name, int timeout, PurpleTypingState state) { PurpleConversation *conv; PurpleConvIm *im = NULL; conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, name, gc->account); if (conv != NULL) { im = PURPLE_CONV_IM(conv); purple_conv_im_set_typing_state(im, state); purple_conv_im_update_typing(im); } else { switch (state) { case PURPLE_TYPING: purple_signal_emit(purple_conversations_get_handle(), "buddy-typing", gc->account, name); break; case PURPLE_TYPED: purple_signal_emit(purple_conversations_get_handle(), "buddy-typed", gc->account, name); break; case PURPLE_NOT_TYPING: purple_signal_emit(purple_conversations_get_handle(), "buddy-typing-stopped", gc->account, name); break; } } if (conv != NULL && timeout > 0) purple_conv_im_start_typing_timeout(im, timeout); } void serv_got_typing_stopped(PurpleConnection *gc, const char *name) { PurpleConversation *conv; PurpleConvIm *im; conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, name, gc->account); if (conv != NULL) { im = PURPLE_CONV_IM(conv); if (im->typing_state == PURPLE_NOT_TYPING) return; purple_conv_im_stop_typing_timeout(im); purple_conv_im_set_typing_state(im, PURPLE_NOT_TYPING); purple_conv_im_update_typing(im); } else { purple_signal_emit(purple_conversations_get_handle(), "buddy-typing-stopped", gc->account, name); } } struct chat_invite_data { PurpleConnection *gc; GHashTable *components; }; static void chat_invite_data_free(struct chat_invite_data *cid) { if (cid->components) g_hash_table_destroy(cid->components); g_free(cid); } static void chat_invite_reject(struct chat_invite_data *cid) { serv_reject_chat(cid->gc, cid->components); chat_invite_data_free(cid); } static void chat_invite_accept(struct chat_invite_data *cid) { serv_join_chat(cid->gc, cid->components); chat_invite_data_free(cid); } void serv_got_chat_invite(PurpleConnection *gc, const char *name, const char *who, const char *message, GHashTable *data) { PurpleAccount *account; char buf2[BUF_LONG]; struct chat_invite_data *cid = g_new0(struct chat_invite_data, 1); int plugin_return; account = purple_connection_get_account(gc); if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->set_permit_deny == NULL) { /* protocol does not support privacy, handle it ourselves */ if (!purple_privacy_check(account, who)) return; } plugin_return = GPOINTER_TO_INT(purple_signal_emit_return_1( purple_conversations_get_handle(), "chat-invited", account, who, name, message, data)); cid->gc = gc; cid->components = data; if (plugin_return == 0) { if (message != NULL) { g_snprintf(buf2, sizeof(buf2), _("%s has invited %s to the chat room %s:\n%s"), who, purple_account_get_username(account), name, message); } else g_snprintf(buf2, sizeof(buf2), _("%s has invited %s to the chat room %s\n"), who, purple_account_get_username(account), name); purple_request_accept_cancel(gc, NULL, _("Accept chat invitation?"), buf2, PURPLE_DEFAULT_ACTION_NONE, account, who, NULL, cid, G_CALLBACK(chat_invite_accept), G_CALLBACK(chat_invite_reject)); } else if (plugin_return > 0) chat_invite_accept(cid); else chat_invite_reject(cid); } PurpleConversation *serv_got_joined_chat(PurpleConnection *gc, int id, const char *name) { PurpleConversation *conv; PurpleConvChat *chat; PurpleAccount *account; account = purple_connection_get_account(gc); conv = purple_conversation_new(PURPLE_CONV_TYPE_CHAT, account, name); chat = PURPLE_CONV_CHAT(conv); if (!g_slist_find(gc->buddy_chats, conv)) gc->buddy_chats = g_slist_append(gc->buddy_chats, conv); purple_conv_chat_set_id(chat, id); purple_signal_emit(purple_conversations_get_handle(), "chat-joined", conv); return conv; } void serv_got_chat_left(PurpleConnection *g, int id) { GSList *bcs; PurpleConversation *conv = NULL; PurpleConvChat *chat = NULL; for (bcs = g->buddy_chats; bcs != NULL; bcs = bcs->next) { conv = (PurpleConversation *)bcs->data; chat = PURPLE_CONV_CHAT(conv); if (purple_conv_chat_get_id(chat) == id) break; conv = NULL; } if (!conv) return; purple_debug(PURPLE_DEBUG_INFO, "server", "Leaving room: %s\n", purple_conversation_get_name(conv)); g->buddy_chats = g_slist_remove(g->buddy_chats, conv); purple_conv_chat_left(PURPLE_CONV_CHAT(conv)); purple_signal_emit(purple_conversations_get_handle(), "chat-left", conv); } void serv_got_chat_in(PurpleConnection *g, int id, const char *who, PurpleMessageFlags flags, const char *message, time_t mtime) { GSList *bcs; PurpleConversation *conv = NULL; PurpleConvChat *chat = NULL; char *buffy, *angel; int plugin_return; g_return_if_fail(who != NULL); g_return_if_fail(message != NULL); for (bcs = g->buddy_chats; bcs != NULL; bcs = bcs->next) { conv = (PurpleConversation *)bcs->data; chat = PURPLE_CONV_CHAT(conv); if (purple_conv_chat_get_id(chat) == id) break; conv = NULL; } if (!conv) return; /* * Plugin stuff. We pass a char ** but we don't want to pass what's * been given us by the prpls. so we create temp holders and pass those * instead. It's basically just to avoid segfaults. Of course, if the * data is binary, plugins don't see it. Bitch all you want; i really * don't want you to be dealing with it. */ /* TODO: MAX(message, BUF_LONG) is pretty ugly. */ buffy = g_malloc(MAX(strlen(message) + 1, BUF_LONG)); strcpy(buffy, message); angel = g_strdup(who); plugin_return = GPOINTER_TO_INT( purple_signal_emit_return_1(purple_conversations_get_handle(), "receiving-chat-msg", g->account, &angel, &buffy, conv, &flags)); if (!buffy || !angel || plugin_return) { g_free(buffy); g_free(angel); return; } who = angel; message = buffy; purple_signal_emit(purple_conversations_get_handle(), "received-chat-msg", g->account, who, message, conv, flags); purple_conv_chat_write(chat, who, message, flags, mtime); g_free(angel); g_free(buffy); } void serv_send_file(PurpleConnection *gc, const char *who, const char *file) { PurplePluginProtocolInfo *prpl_info = NULL; if (gc != NULL && gc->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); if (prpl_info && prpl_info->send_file) { if (!prpl_info->can_receive_file || prpl_info->can_receive_file(gc, who)) { prpl_info->send_file(gc, who, file); } } }