* 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 * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA /* This file is the fullcrap */ #include "conversation.h" #define SECS_BEFORE_RESENDING_AUTORESPONSE 600 #define SEX_BEFORE_RESENDING_AUTORESPONSE "Only after you're married" purple_serv_send_typing(PurpleConnection *gc, const char *name, PurpleIMTypingState state) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); return purple_protocol_im_iface_send_typing(protocol, gc, name, state); static GSList *last_auto_responses = NULL; struct last_auto_response { expire_last_auto_responses(gpointer data) struct last_auto_response *lar; tmp = last_auto_responses; lar = (struct last_auto_response *)cur->data; if ((time(NULL) - lar->sent) > SECS_BEFORE_RESENDING_AUTORESPONSE) { last_auto_responses = g_slist_delete_link(last_auto_responses, cur); return FALSE; /* do not run again */ static struct last_auto_response * get_last_auto_response(PurpleConnection *gc, const char *name) struct last_auto_response *lar; /* because we're modifying or creating a lar, schedule the * function to expire them as the pref dictates */ g_timeout_add_seconds((SECS_BEFORE_RESENDING_AUTORESPONSE + 1), expire_last_auto_responses, NULL); tmp = last_auto_responses; lar = (struct last_auto_response *)tmp->data; if (gc == lar->gc && !strncmp(name, lar->name, sizeof(lar->name))) lar = g_new0(struct last_auto_response, 1); g_snprintf(lar->name, sizeof(lar->name), "%s", name); last_auto_responses = g_slist_prepend(last_auto_responses, lar); int purple_serv_send_im(PurpleConnection *gc, PurpleMessage *msg) PurpleIMConversation *im = NULL; PurpleAccount *account = NULL; PurplePresence *presence = NULL; PurpleProtocol *protocol = NULL; const gchar *auto_reply_pref = NULL; g_return_val_if_fail(gc != NULL, val); g_return_val_if_fail(msg != NULL, val); protocol = purple_connection_get_protocol(gc); g_return_val_if_fail(protocol != NULL, val); g_return_val_if_fail(PURPLE_IS_PROTOCOL_IM(protocol), val); account = purple_connection_get_account(gc); presence = purple_account_get_presence(account); recipient = purple_message_get_recipient(msg); im = purple_conversations_find_im_with_account(recipient, account); if (PURPLE_PROTOCOL_IMPLEMENTS(protocol, IM, send)) val = purple_protocol_im_iface_send(protocol, gc, msg); * 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((purple_connection_get_flags(gc) & PURPLE_CONNECTION_FLAG_AUTO_RESP) && !purple_presence_is_available(presence) && !purple_strequal(auto_reply_pref, "never")) { struct last_auto_response *lar; lar = get_last_auto_response(gc, recipient); if(im && purple_im_conversation_get_send_typed_timeout(im)) purple_im_conversation_stop_send_typed_timeout(im); void purple_serv_get_info(PurpleConnection *gc, const char *name) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); purple_protocol_server_iface_get_info(protocol, gc, name); void purple_serv_set_info(PurpleConnection *gc, const char *info) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); if (PURPLE_PROTOCOL_IMPLEMENTS(protocol, SERVER, set_info)) { account = purple_connection_get_account(gc); purple_signal_emit(purple_accounts_get_handle(), "account-setting-info", account, info); purple_protocol_server_iface_set_info(protocol, gc, info); purple_signal_emit(purple_accounts_get_handle(), "account-set-info", account, info); * Set buddy's alias on server roster/list void purple_serv_alias_buddy(PurpleBuddy *b) PurpleProtocol *protocol; account = purple_buddy_get_account(b); gc = purple_account_get_connection(account); protocol = purple_connection_get_protocol(gc); purple_protocol_server_iface_alias_buddy(protocol, gc, purple_buddy_get_name(b), purple_buddy_get_local_alias(b)); purple_serv_got_alias(PurpleConnection *gc, const char *who, const char *alias) PurpleIMConversation *im; account = purple_connection_get_account(gc); buddies = purple_blist_find_buddies(account, who); const char *server_alias; buddies = g_slist_delete_link(buddies, buddies); server_alias = purple_buddy_get_server_alias(b); if (purple_strequal(server_alias, alias)) purple_buddy_set_server_alias(b, alias); im = purple_conversations_find_im_with_account(purple_buddy_get_name(b), account); if (im != NULL && alias != NULL && !purple_strequal(alias, who)) char *escaped = g_markup_escape_text(who, -1); char *escaped2 = g_markup_escape_text(alias, -1); char *tmp = g_strdup_printf(_("%s is now known as %s.\n"), purple_conversation_write_system_message( PURPLE_CONVERSATION(im), tmp, PURPLE_MESSAGE_NO_LINKIFY); purple_serv_got_private_alias(PurpleConnection *gc, const char *who, const char *alias) PurpleAccount *account = NULL; account = purple_connection_get_account(gc); buddies = purple_blist_find_buddies(account, who); buddies = g_slist_delete_link(buddies, buddies); balias = purple_buddy_get_local_alias(b); if (purple_strequal(balias, alias)) purple_buddy_set_local_alias(b, alias); PurpleAttentionType *purple_get_attention_type_from_code(PurpleAccount *account, guint type_code) PurpleProtocol *protocol; PurpleAttentionType* attn; g_return_val_if_fail(account != NULL, NULL); protocol = purple_protocols_find(purple_account_get_protocol_id(account)); /* Lookup the attention type in the protocol's attention_types list, if any. */ if (PURPLE_IS_PROTOCOL_ATTENTION(protocol)) { attention_types = purple_protocol_attention_get_types( PURPLE_PROTOCOL_ATTENTION(protocol), account); attn = (PurpleAttentionType *)g_list_nth_data(attention_types, type_code); * 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 purple_serv_move_buddy(PurpleBuddy *buddy, PurpleGroup *orig, PurpleGroup *dest) PurpleProtocol *protocol; g_return_if_fail(buddy != NULL); g_return_if_fail(orig != NULL); g_return_if_fail(dest != NULL); account = purple_buddy_get_account(buddy); gc = purple_account_get_connection(account); protocol = purple_connection_get_protocol(gc); purple_protocol_server_iface_group_buddy(protocol, gc, purple_buddy_get_name(buddy), purple_group_get_name(orig), purple_group_get_name(dest)); void purple_serv_add_permit(PurpleConnection *gc, const char *name) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); purple_protocol_privacy_iface_add_permit(protocol, gc, name); void purple_serv_add_deny(PurpleConnection *gc, const char *name) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); purple_protocol_privacy_iface_add_deny(protocol, gc, name); void purple_serv_rem_permit(PurpleConnection *gc, const char *name) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); purple_protocol_privacy_iface_rem_permit(protocol, gc, name); void purple_serv_rem_deny(PurpleConnection *gc, const char *name) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); purple_protocol_privacy_iface_rem_deny(protocol, gc, name); void purple_serv_set_permit_deny(PurpleConnection *gc) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); * 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. purple_protocol_privacy_iface_set_permit_deny(protocol, gc); void purple_serv_join_chat(PurpleConnection *gc, GHashTable *data) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); purple_protocol_chat_iface_join(protocol, gc, data); void purple_serv_reject_chat(PurpleConnection *gc, GHashTable *data) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); purple_protocol_chat_iface_reject(protocol, gc, data); void purple_serv_chat_invite(PurpleConnection *gc, int id, const char *message, const char *name) PurpleProtocol *protocol = NULL; PurpleChatConversation *chat; chat = purple_conversations_find_chat(gc, id); protocol = purple_connection_get_protocol(gc); buffy = message && *message ? g_strdup(message) : NULL; purple_signal_emit(purple_conversations_get_handle(), "chat-inviting-user", purple_protocol_chat_iface_invite(protocol, gc, id, buffy, name); purple_signal_emit(purple_conversations_get_handle(), "chat-invited-user", /* Ya know, nothing uses this except purple_chat_conversation_finalize(), * I think I'll just merge it into that later... * Then again, something might want to use this, from outside protocol-land * to leave a chat without destroying the conversation. void purple_serv_chat_leave(PurpleConnection *gc, int id) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); purple_protocol_chat_iface_leave(protocol, gc, id); int purple_serv_chat_send(PurpleConnection *gc, int id, PurpleMessage *msg) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); g_return_val_if_fail(msg != NULL, -EINVAL); if (PURPLE_PROTOCOL_IMPLEMENTS(protocol, CHAT, send)) return purple_protocol_chat_iface_send(protocol, gc, id, msg); * woo. i'm actually going to comment this function. isn't that fun. make * sure to follow along, kids void purple_serv_got_im(PurpleConnection *gc, const char *who, const char *msg, PurpleMessageFlags flags, time_t mtime) PurpleIMConversation *im; g_return_if_fail(msg != NULL); account = purple_connection_get_account(gc); purple_debug_error("server", "purple_serv_got_im ignoring negative timestamp\n"); /* TODO: Would be more appropriate to use a value that indicates that the timestamp is unknown, and surface that in the UI. */ * XXX: Should we be setting this here, or relying on protocols to set it? flags |= PURPLE_MESSAGE_RECV; if (!purple_account_privacy_check(account, who)) { purple_signal_emit(purple_conversations_get_handle(), "blocked-im-msg", account, who, msg, flags, (unsigned int)mtime); * We should update the conversation window buttons and menu, im = purple_conversations_find_im_with_account(who, purple_connection_get_account(gc)); * Make copies of the message and the sender in case plugins want * to free these strings and replace them with a modifed version. plugin_return = GPOINTER_TO_INT( purple_signal_emit_return_1(purple_conversations_get_handle(), "receiving-im-msg", purple_connection_get_account(gc), &angel, &buffy, im, &flags)); if (!buffy || !angel || plugin_return) { purple_signal_emit(purple_conversations_get_handle(), "received-im-msg", purple_connection_get_account(gc), name, message, im, flags); /* search for conversation again in case it was created by received-im-msg handler */ im = purple_conversations_find_im_with_account(name, purple_connection_get_account(gc)); im = purple_im_conversation_new(account, name); pmsg = purple_message_new_incoming(name, message, flags, mtime); purple_conversation_write_message(PURPLE_CONVERSATION(im), pmsg); * - it's not supported on this connection * - or we're not idle and the 'only auto respond if idle' pref if (purple_connection_get_flags(gc) & PURPLE_CONNECTION_FLAG_AUTO_RESP) PurplePresence *presence; 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_status_type(status); primitive = purple_status_type_get_primitive(status_type); mobile = purple_presence_is_status_primitive_active(presence, PURPLE_STATUS_MOBILE); if ((primitive == PURPLE_STATUS_AVAILABLE) || (primitive == PURPLE_STATUS_INVISIBLE) || purple_strequal(auto_reply_pref, "never") || (!purple_presence_is_idle(presence) && purple_strequal(auto_reply_pref, "awayidle"))) away_msg = g_value_get_string( purple_status_get_attr_value(status, "message")); if ((away_msg != NULL) && (*away_msg != '\0')) { struct last_auto_response *lar; * 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, 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. if (!(flags & PURPLE_MESSAGE_AUTO_RESP)) msg = purple_message_new_outgoing(name, away_msg, PURPLE_MESSAGE_AUTO_RESP); purple_serv_send_im(gc, msg); purple_conversation_write_message(PURPLE_CONVERSATION(im), msg); void purple_serv_got_typing(PurpleConnection *gc, const char *name, int timeout, PurpleIMTypingState state) { PurpleIMConversation *im; im = purple_conversations_find_im_with_account(name, purple_connection_get_account(gc)); purple_im_conversation_set_typing_state(im, state); purple_signal_emit(purple_conversations_get_handle(), "buddy-typing", purple_connection_get_account(gc), name); purple_signal_emit(purple_conversations_get_handle(), "buddy-typed", purple_connection_get_account(gc), name); case PURPLE_IM_NOT_TYPING: purple_signal_emit(purple_conversations_get_handle(), "buddy-typing-stopped", purple_connection_get_account(gc), name); if (im != NULL && timeout > 0) purple_im_conversation_start_typing_timeout(im, timeout); void purple_serv_got_typing_stopped(PurpleConnection *gc, const char *name) { PurpleIMConversation *im; im = purple_conversations_find_im_with_account(name, purple_connection_get_account(gc)); if (purple_im_conversation_get_typing_state(im) == PURPLE_IM_NOT_TYPING) purple_im_conversation_stop_typing_timeout(im); purple_im_conversation_set_typing_state(im, PURPLE_IM_NOT_TYPING); purple_signal_emit(purple_conversations_get_handle(), "buddy-typing-stopped", purple_connection_get_account(gc), name); struct chat_invite_data { static void chat_invite_data_free(struct chat_invite_data *cid) g_hash_table_destroy(cid->components); static void chat_invite_reject(struct chat_invite_data *cid) purple_serv_reject_chat(cid->gc, cid->components); chat_invite_data_free(cid); static void chat_invite_accept(struct chat_invite_data *cid) purple_serv_join_chat(cid->gc, cid->components); chat_invite_data_free(cid); void purple_serv_got_chat_invite(PurpleConnection *gc, const char *name, const char *who, const char *message, GHashTable *data) struct chat_invite_data *cid; g_return_if_fail(name != NULL); g_return_if_fail(who != NULL); account = purple_connection_get_account(gc); if (!purple_account_privacy_check(account, who)) { purple_signal_emit(purple_conversations_get_handle(), "chat-invite-blocked", account, who, name, message, data); cid = g_new0(struct chat_invite_data, 1); plugin_return = GPOINTER_TO_INT(purple_signal_emit_return_1( purple_conversations_get_handle(), "chat-invited", account, who, name, message, data)); _("%s has invited %s to the chat room %s:\n%s"), who, purple_account_get_username(account), name, message); _("%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, purple_request_cpar_from_connection(gc), cid, G_CALLBACK(chat_invite_accept), G_CALLBACK(chat_invite_reject)); else if (plugin_return > 0) PurpleChatConversation *purple_serv_got_joined_chat(PurpleConnection *gc, int id, const char *name) PurpleChatConversation *chat; account = purple_connection_get_account(gc); g_return_val_if_fail(account != NULL, NULL); g_return_val_if_fail(name != NULL, NULL); chat = purple_chat_conversation_new(account, name); g_return_val_if_fail(chat != NULL, NULL); if (!g_slist_find(purple_connection_get_active_chats(gc), chat)) _purple_connection_add_active_chat(gc, chat); purple_chat_conversation_set_id(chat, id); purple_signal_emit(purple_conversations_get_handle(), "chat-joined", chat); void purple_serv_got_chat_left(PurpleConnection *g, int id) PurpleChatConversation *chat = NULL; for (bcs = purple_connection_get_active_chats(g); bcs != NULL; bcs = bcs->next) { if (purple_chat_conversation_get_id( PURPLE_CHAT_CONVERSATION(bcs->data)) == id) { chat = (PurpleChatConversation *)bcs->data; purple_debug(PURPLE_DEBUG_INFO, "server", "Leaving room: %s\n", purple_conversation_get_name(PURPLE_CONVERSATION(chat))); _purple_connection_remove_active_chat(g, chat); purple_chat_conversation_leave(chat); purple_signal_emit(purple_conversations_get_handle(), "chat-left", chat); void purple_serv_got_join_chat_failed(PurpleConnection *gc, GHashTable *data) purple_signal_emit(purple_conversations_get_handle(), "chat-join-failed", void purple_serv_got_chat_in(PurpleConnection *g, int id, const char *who, PurpleMessageFlags flags, const char *message, time_t mtime) PurpleChatConversation *chat = NULL; g_return_if_fail(who != NULL); g_return_if_fail(message != NULL); purple_debug_error("server", "purple_serv_got_chat_in ignoring negative timestamp\n"); /* TODO: Would be more appropriate to use a value that indicates that the timestamp is unknown, and surface that in the UI. */ for (bcs = purple_connection_get_active_chats(g); bcs != NULL; bcs = bcs->next) { if (purple_chat_conversation_get_id( PURPLE_CHAT_CONVERSATION(bcs->data)) == id) { chat = (PurpleChatConversation *)bcs->data; /* Did I send the message? */ if (purple_strequal(purple_chat_conversation_get_nick(chat), purple_normalize(purple_conversation_get_account( PURPLE_CONVERSATION(chat)), who))) { flags |= PURPLE_MESSAGE_SEND; flags &= ~PURPLE_MESSAGE_RECV; /* Just in case some protocol sets it! */ flags |= PURPLE_MESSAGE_RECV; * Make copies of the message and the sender in case plugins want * to free these strings and replace them with a modifed version. buffy = g_strdup(message); plugin_return = GPOINTER_TO_INT( purple_signal_emit_return_1(purple_conversations_get_handle(), "receiving-chat-msg", purple_connection_get_account(g), &angel, &buffy, chat, &flags)); if (!buffy || !angel || plugin_return) { purple_signal_emit(purple_conversations_get_handle(), "received-chat-msg", purple_connection_get_account(g), who, message, chat, flags); if (flags & PURPLE_MESSAGE_RECV) pmsg = purple_message_new_incoming(who, message, flags, mtime); pmsg = purple_message_new_outgoing(who, message, flags); purple_message_set_time(pmsg, mtime); purple_conversation_write_message(PURPLE_CONVERSATION(chat), pmsg); void purple_serv_send_file(PurpleConnection *gc, const char *who, const char *file) PurpleProtocol *protocol; protocol = purple_connection_get_protocol(gc); if(PURPLE_IS_PROTOCOL_XFER(protocol)) { PurpleProtocolXfer *xfer = PURPLE_PROTOCOL_XFER(protocol); if(purple_protocol_xfer_can_receive(xfer, gc, who)) { purple_protocol_xfer_send_file(xfer,