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);
}
}
}
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);
}
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;
}
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 ycht_progress_chatmsg(YchtConn *ycht, YchtPkt *pkt)
{
char *who, *what, *msg;
PurpleChatConversation *c;
PurpleConnection *gc = ycht->gc;
who = g_list_nth_data(pkt->data, 1);
what = g_list_nth_data(pkt->data, 2);
if (!who || !what)
return;
c = purple_conversations_find_chat(gc, YAHOO_CHAT_ID);
if (!c)
return;
msg = yahoo_string_decode(gc, what, 1);
what = yahoo_codes_to_html(msg);
g_free(msg);
if (pkt->service == YCHT_SERVICE_CHATMSG_EMOTE) {
char *tmp = g_strdup_printf("/me %s", what);
g_free(what);
what = tmp;
}
purple_serv_got_chat_in(gc, YAHOO_CHAT_ID, who, 0, what, time(NULL));
g_free(what);
}
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 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 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 foreach_gc_in_chat(ChatFunc fn, PurpleConnection *from,
int id, gpointer userdata) {
PurpleChatConversation *chat = purple_conversations_find_chat(from, id);
ChatFuncData cfdata = { fn,
chat,
userdata };
g_list_foreach(purple_connections_get_all(), call_chat_func,
&cfdata);
}
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 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 nullprpl_chat_whisper(PurpleConnection *gc, int id, const char *who,
const char *message) {
const char *username = purple_account_get_username(purple_connection_get_account(gc));
PurpleChatConversation *chat = purple_conversations_find_chat(gc, id);
purple_debug_info("nullprpl",
"%s receives whisper from %s in chat room %s: %s\n",
username, who, purple_conversation_get_name(PURPLE_CONVERSATION(chat)),
message);
/* receive whisper on recipient's account */
purple_serv_got_chat_in(gc, id, who, PURPLE_MESSAGE_RECV | PURPLE_MESSAGE_WHISPER,
message, time(NULL));
}
static void ycht_process_chatpart(YchtConn *ycht, YchtPkt *pkt)
{
char *room, *who;
room = g_list_nth_data(pkt->data, 0);
who = g_list_nth_data(pkt->data, 1);
if (who && room) {
PurpleChatConversation *c = purple_conversations_find_chat(ycht->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);
}
}
static void ycht_process_chatjoin(YchtConn *ycht, YchtPkt *pkt)
{
char *room, *topic;
PurpleConnection *gc = ycht->gc;
PurpleChatConversation *c = NULL;
gboolean new_room = FALSE;
char **members;
int i;
room = g_list_nth_data(pkt->data, 0);
topic = g_list_nth_data(pkt->data, 1);
if (!g_list_nth_data(pkt->data, 4))
return;
if (!room)
return;
members = g_strsplit(g_list_nth_data(pkt->data, 4), "\001", 0);
for (i = 0; members[i]; i++) {
char *tmp = strchr(members[i], '\002');
if (tmp)
*tmp = '\0';
}
if (g_list_length(pkt->data) > 5)
new_room = TRUE;
if (new_room && ycht->changing_rooms) {
purple_serv_got_chat_left(gc, YAHOO_CHAT_ID);
ycht->changing_rooms = FALSE;
c = purple_serv_got_joined_chat(gc, YAHOO_CHAT_ID, room);
} else {
c = purple_conversations_find_chat(gc, YAHOO_CHAT_ID);
}
if (topic)
purple_chat_conversation_set_topic(c, NULL, topic);
for (i = 0; members[i]; i++) {
if (new_room) {
/*if (!strcmp(members[i], purple_connection_get_display_name(ycht->gc)))
continue;*/
purple_chat_conversation_add_user(c, members[i], NULL, PURPLE_CHAT_USER_NONE, TRUE);
} else {
yahoo_chat_add_user(c, members[i], NULL);
}
}
g_strfreev(members);
}
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);
}
static void yahoo_chat_leave(PurpleConnection *gc, const char *room, const char *dn, gboolean logout)
{
YahooData *yd = purple_connection_get_protocol_data(gc);
struct yahoo_packet *pkt;
char *eroom;
if (yd->wm) {
g_return_if_fail(yd->ycht != NULL);
ycht_chat_leave(yd->ycht, room, logout);
return;
}
eroom = yahoo_string_encode(gc, room, TRUE);
pkt = yahoo_packet_new(YAHOO_SERVICE_CHATEXIT, YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "sss", 104, eroom, 109, dn, 108, "1");
yahoo_packet_hash_str(pkt, 112, "0"); /* what does this one mean? */
yahoo_packet_send_and_free(pkt, yd);
yd->in_chat = 0;
if (yd->chat_name) {
g_free(yd->chat_name);
yd->chat_name = NULL;
}
if (purple_conversations_find_chat(gc, YAHOO_CHAT_ID) != NULL)
purple_serv_got_chat_left(gc, YAHOO_CHAT_ID);
if (!logout)
return;
pkt = yahoo_packet_new(YAHOO_SERVICE_CHATLOGOUT,
YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash_str(pkt, 1, dn);
yahoo_packet_send_and_free(pkt, yd);
yd->chat_online = FALSE;
g_free(yd->pending_chat_room);
yd->pending_chat_room = NULL;
g_free(yd->pending_chat_id);
yd->pending_chat_id = NULL;
g_free(yd->pending_chat_topic);
yd->pending_chat_topic = NULL;
g_free(yd->pending_chat_goto);
yd->pending_chat_goto = NULL;
g_free(eroom);
}
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);
}
}
static void nullprpl_set_chat_topic(PurpleConnection *gc, int id,
const char *topic) {
PurpleChatConversation *chat = purple_conversations_find_chat(gc, id);
const char *last_topic;
if (!chat)
return;
purple_debug_info("nullprpl", "%s sets topic of chat room '%s' to '%s'\n",
purple_account_get_username(purple_connection_get_account(gc)),
purple_conversation_get_name(PURPLE_CONVERSATION(chat)), topic);
last_topic = purple_chat_conversation_get_topic(chat);
if ((!topic && !last_topic) ||
(topic && last_topic && !strcmp(topic, last_topic)))
return; /* topic is unchanged, this is a noop */
foreach_gc_in_chat(set_chat_topic_fn, gc, id, (gpointer)topic);
}
static int nullprpl_chat_send(PurpleConnection *gc, int id, const char *message,
PurpleMessageFlags flags) {
const char *username = purple_account_get_username(purple_connection_get_account(gc));
PurpleChatConversation *chat = purple_conversations_find_chat(gc, id);
if (chat) {
purple_debug_info("nullprpl",
"%s is sending message to chat room %s: %s\n", username,
purple_conversation_get_name(PURPLE_CONVERSATION(chat)), message);
/* send message to everyone in the chat room */
foreach_gc_in_chat(receive_chat_message, gc, id, (gpointer)message);
return 0;
} else {
purple_debug_info("nullprpl",
"tried to send message from %s to chat room #%d: %s\n"
"but couldn't find chat room",
username, id, message);
return -1;
}
}
static void nullprpl_join_chat(PurpleConnection *gc, GHashTable *components) {
const char *username = purple_account_get_username(purple_connection_get_account(gc));
const char *room = g_hash_table_lookup(components, "room");
int chat_id = g_str_hash(room);
purple_debug_info("nullprpl", "%s is joining chat room %s\n", username, room);
if (!purple_conversations_find_chat(gc, chat_id)) {
purple_serv_got_joined_chat(gc, chat_id, room);
/* tell everyone that we joined, and add them if they're already there */
foreach_gc_in_chat(joined_chat, gc, chat_id, NULL);
} else {
char *tmp = g_strdup_printf(_("%s is already in chat room %s."),
username,
room);
purple_debug_info("nullprpl", "%s is already in chat room %s\n", username,
room);
purple_notify_info(gc, _("Join chat"), _("Join chat"), tmp,
purple_request_cpar_from_connection(gc));
g_free(tmp);
}
}
void
fb_util_serv_got_chat_in(PurpleConnection *gc, gint id, const gchar *who,
const gchar *text, PurpleMessageFlags flags,
guint64 timestamp)
{
const gchar *name;
PurpleAccount *acct;
PurpleChatConversation *conv;
PurpleMessage *msg;
if (!(flags & PURPLE_MESSAGE_SEND)) {
purple_serv_got_chat_in(gc, id, who, flags, text, timestamp);
return;
}
acct = purple_connection_get_account(gc);
conv = purple_conversations_find_chat(gc, id);
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_join(PurpleConnection *gc, struct yahoo_packet *pkt)
{
PurpleAccount *account = purple_connection_get_account(gc);
YahooData *yd = purple_connection_get_protocol_data(gc);
PurpleChatConversation *c = NULL;
GSList *l;
GList *members = NULL;
GList *roomies = NULL;
char *room = NULL;
char *topic = NULL;
if (pkt->status == -1) {
/* We can't join */
struct yahoo_pair *pair = pkt->hash->data;
gchar const *failed_to_join = _("Failed to join chat");
switch (atoi(pair->value)) {
case 0xFFFFFFFA: /* -6 */
purple_notify_error(gc, NULL, failed_to_join,
_("Unknown room"),
purple_request_cpar_from_connection(gc));
break;
case 0xFFFFFFF1: /* -15 */
purple_notify_error(gc, NULL, failed_to_join,
_("Maybe the room is full"),
purple_request_cpar_from_connection(gc));
break;
case 0xFFFFFFDD: /* -35 */
purple_notify_error(gc, NULL, failed_to_join,
_("Not available"),
purple_request_cpar_from_connection(gc));
break;
default:
purple_notify_error(gc, NULL, failed_to_join,
_("Unknown error. You may need to "
"logout and wait five minutes before "
"being able to rejoin a chatroom"),
purple_request_cpar_from_connection(gc));
}
return;
}
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
switch (pair->key) {
case 104:
g_free(room);
room = yahoo_string_decode(gc, pair->value, TRUE);
break;
case 105:
g_free(topic);
topic = yahoo_string_decode(gc, pair->value, TRUE);
break;
case 128: /* some id */
break;
case 108: /* number of joiners */
break;
case 129: /* some other id */
break;
case 130: /* some base64 or hash or something */
break;
case 126: /* some negative number */
break;
case 13: /* this is 1. maybe its the type of room? (normal, user created, private, etc?) */
break;
case 61: /*this looks similar to 130 */
break;
/* the previous section was just room info. this next section is
info about individual room members, (including us) */
case 109: /* the yahoo id */
if (g_utf8_validate(pair->value, -1, NULL)) {
members = g_list_append(members, pair->value);
} else {
purple_debug_warning("yahoo", "yahoo_process_chat_join "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 110: /* age */
break;
case 141: /* nickname */
break;
case 142: /* location */
break;
case 113: /* bitmask */
break;
}
}
if (room && yd->chat_name && purple_utf8_strcasecmp(room, yd->chat_name))
yahoo_chat_leave(gc, room,
purple_connection_get_display_name(gc), FALSE);
c = purple_conversations_find_chat(gc, YAHOO_CHAT_ID);
if (room && (!c || purple_chat_conversation_has_left(c)) &&
members && (members->next ||
!g_ascii_strcasecmp(members->data, purple_connection_get_display_name(gc)))) {
GList *l;
GList *flags = NULL;
for (l = members; l; l = l->next)
flags = g_list_prepend(flags, GINT_TO_POINTER(PURPLE_CHAT_USER_NONE));
if (c && purple_chat_conversation_has_left(c)) {
/* this might be a hack, but oh well, it should nicely */
char *tmpmsg;
purple_conversation_set_name(PURPLE_CONVERSATION(c), room);
c = purple_serv_got_joined_chat(gc, YAHOO_CHAT_ID, room);
if (topic) {
purple_chat_conversation_set_topic(c, NULL, topic);
/* Also print the topic to the backlog so that the captcha link is clickable */
purple_conversation_write_system_message(PURPLE_CONVERSATION(c), topic, 0);
}
yd->in_chat = 1;
yd->chat_name = g_strdup(room);
purple_chat_conversation_add_users(c, members, NULL, flags, FALSE);
tmpmsg = g_strdup_printf(_("You are now chatting in %s."), room);
purple_conversation_write_system_message(PURPLE_CONVERSATION(c), tmpmsg, 0);
g_free(tmpmsg);
} else {
c = purple_serv_got_joined_chat(gc, YAHOO_CHAT_ID, room);
if (topic) {
purple_chat_conversation_set_topic(c, NULL, topic);
/* Also print the topic to the backlog so that the captcha link is clickable */
purple_conversation_write_system_message(PURPLE_CONVERSATION(c), topic, 0);
}
yd->in_chat = 1;
yd->chat_name = g_strdup(room);
purple_chat_conversation_add_users(c, members, NULL, flags, FALSE);
}
g_list_free(flags);
} else if (c) {
if (topic) {
const char *cur_topic = purple_chat_conversation_get_topic(c);
if (cur_topic == NULL || strcmp(cur_topic, topic) != 0)
purple_chat_conversation_set_topic(c, NULL, topic);
}
yahoo_chat_add_users(c, members);
}
if (purple_account_privacy_get_denied(account) && c) {
PurpleConversationUiOps *ops = purple_conversation_get_ui_ops(PURPLE_CONVERSATION(c));
for (l = purple_account_privacy_get_denied(account); l != NULL; l = l->next) {
for (roomies = members; roomies; roomies = roomies->next) {
if (!purple_utf8_strcasecmp((char *)l->data, roomies->data)) {
purple_debug_info("yahoo", "Ignoring room member %s in room %s\n" , (char *)roomies->data, room ? room : "");
purple_chat_conversation_ignore(c,roomies->data);
ops->chat_update_user(purple_chat_conversation_find_user(c, roomies->data));
}
}
}
}
g_list_free(roomies);
g_list_free(members);
g_free(room);
g_free(topic);
}
/**************************************************************************
* Message Handlers
**************************************************************************/
void
msn_plain_msg(MsnCmdProc *cmdproc, MsnMessage *msg)
{
PurpleConnection *gc;
const char *body;
char *body_enc;
char *body_final;
size_t body_len;
const char *passport;
const char *value;
gc = purple_account_get_connection(cmdproc->session->account);
body = msn_message_get_bin_data(msg, &body_len);
body_enc = g_markup_escape_text(body, body_len);
passport = msg->remote_user;
if (!strcmp(passport, "*****@*****.**") &&
strstr(body, "immediate security update"))
{
return;
}
#if 0
if ((value = msn_message_get_header_value(msg, "User-Agent")) != NULL)
{
purple_debug_misc("msn", "User-Agent = '%s'\n", value);
}
#endif
if ((value = msn_message_get_header_value(msg, "X-MMS-IM-Format")) != NULL)
{
char *pre, *post;
msn_parse_format(value, &pre, &post);
body_final = g_strdup_printf("%s%s%s", pre ? pre : "",
body_enc ? body_enc : "", post ? post : "");
g_free(pre);
g_free(post);
g_free(body_enc);
}
else
{
body_final = body_enc;
}
if (cmdproc->servconn->type == MSN_SERVCONN_SB) {
MsnSwitchBoard *swboard = cmdproc->data;
swboard->flag |= MSN_SB_FLAG_IM;
if (swboard->current_users > 1 ||
((swboard->conv != NULL) &&
PURPLE_IS_CHAT_CONVERSATION(swboard->conv)))
{
/* If current_users is always ok as it should then there is no need to
* check if this is a chat. */
if (swboard->current_users <= 1)
purple_debug_misc("msn", "plain_msg: current_users(%d)\n",
swboard->current_users);
purple_serv_got_chat_in(gc, swboard->chat_id, passport, 0, body_final,
time(NULL));
if (swboard->conv == NULL)
{
swboard->conv = PURPLE_CONVERSATION(purple_conversations_find_chat(gc, swboard->chat_id));
swboard->flag |= MSN_SB_FLAG_IM;
}
}
else if (!g_str_equal(passport, purple_account_get_username(purple_connection_get_account(gc))))
{
/* Don't im ourselves ... */
purple_serv_got_im(gc, passport, body_final, 0, time(NULL));
if (swboard->conv == NULL)
{
swboard->conv = PURPLE_CONVERSATION(purple_conversations_find_im_with_account(
passport, purple_connection_get_account(gc)));
swboard->flag |= MSN_SB_FLAG_IM;
}
}
} else {
purple_serv_got_im(gc, passport, body_final, 0, time(NULL));
}
g_free(body_final);
}
void yahoo_process_chat_message(PurpleConnection *gc, struct yahoo_packet *pkt)
{
char *room = NULL, *who = NULL, *msg = NULL, *msg2;
int msgtype = 1, utf8 = 1; /* default to utf8 */
PurpleChatConversation *c = NULL;
GSList *l;
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
switch (pair->key) {
case 97:
utf8 = strtol(pair->value, NULL, 10);
break;
case 104:
g_free(room);
room = yahoo_string_decode(gc, pair->value, TRUE);
break;
case 109:
if (g_utf8_validate(pair->value, -1, NULL)) {
who = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_chat_message "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 117:
if (g_utf8_validate(pair->value, -1, NULL)) {
msg = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_chat_message "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 124:
msgtype = strtol(pair->value, NULL, 10);
break;
}
}
c = purple_conversations_find_chat(gc, YAHOO_CHAT_ID);
if (!who || !c) {
if (room)
g_free(room);
/* we still get messages after we part, funny that */
return;
}
if (!msg) {
purple_debug_misc("yahoo", "Got a message packet with no message.\nThis probably means something important, but we're ignoring it.\n");
return;
}
msg2 = yahoo_string_decode(gc, msg, utf8);
msg = yahoo_codes_to_html(msg2);
g_free(msg2);
if (msgtype == 2 || msgtype == 3) {
char *tmp;
tmp = g_strdup_printf("/me %s", msg);
g_free(msg);
msg = tmp;
}
purple_serv_got_chat_in(gc, YAHOO_CHAT_ID, who,
PURPLE_MESSAGE_RECV, msg, time(NULL));
g_free(msg);
g_free(room);
}
