void
gaim_buddy_icon_update(GaimBuddyIcon *icon)
{
GaimConversation *conv;
GaimAccount *account;
const char *username;
GSList *sl;
g_return_if_fail(icon != NULL);
account = gaim_buddy_icon_get_account(icon);
username = gaim_buddy_icon_get_username(icon);
for (sl = gaim_find_buddies(account, username); sl != NULL; sl = sl->next)
{
GaimBuddy *buddy = (GaimBuddy *)sl->data;
gaim_buddy_set_icon(buddy, icon);
}
conv = gaim_find_conversation_with_account(username, account);
if (conv != NULL && gaim_conversation_get_type(conv) == GAIM_CONV_IM)
gaim_im_set_icon(GAIM_IM(conv), icon);
}
/* GaimConversation *ggp_confer_find_by_name(GaimConnection *gc, const gchar *name) {{{ */
GaimConversation *ggp_confer_find_by_name(GaimConnection *gc, const gchar *name)
{
g_return_val_if_fail(gc != NULL, NULL);
g_return_val_if_fail(name != NULL, NULL);
return gaim_find_conversation_with_account(GAIM_CONV_TYPE_CHAT, name,
gaim_connection_get_account(gc));
}
void update_buddy_typing_cb(GaimAccount *account, const char *who)
{
GaimConversation *gConv = NULL;
gConv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, who, account);
if (!gConv)
return;
GaimChatMngr::UpdateBuddyTyping(gConv, gaim_conv_im_get_typing_state(GAIM_CONV_IM(gConv)));
}
static void dequeue_message(GtkTreeIter *iter)
{
gchar *name;
GSList *templist;
GaimConversation *cnv;
gboolean orig_while_away;
orig_while_away = gaim_prefs_get_bool("/core/sound/while_away");
if (orig_while_away)
gaim_prefs_set_bool("/core/sound/while_away", FALSE);
gtk_tree_model_get(GTK_TREE_MODEL(awayqueuestore), iter, 0, &name, -1);
gaim_debug(GAIM_DEBUG_INFO, "away", "Dequeueing messages from %s.\n",
name);
templist = message_queue;
while (templist) {
struct queued_message *qm = templist->data;
if (templist->data) {
if (!gaim_utf8_strcasecmp(qm->name, name)) {
GaimAccount *account = NULL;
if (g_list_index(gaim_accounts_get_all(), qm->account) >= 0)
account = qm->account;
cnv = gaim_find_conversation_with_account(name, account);
if (!cnv)
cnv = gaim_conversation_new(GAIM_CONV_IM, account, qm->name);
else
gaim_conversation_set_account(cnv, account);
gaim_conv_im_write(GAIM_CONV_IM(cnv), NULL, qm->message,
qm->flags, qm->tm);
g_free(qm->message);
g_free(qm);
templist = message_queue = g_slist_remove(message_queue, qm);
} else {
templist = templist->next;
}
}
}
g_free(name);
/* In GTK 2.2, _store_remove actually returns whether iter is valid or not
* after the remove, but in GTK 2.0 it is a void function. */
gtk_list_store_remove(awayqueuestore, iter);
if (orig_while_away)
gaim_prefs_set_bool("/core/sound/while_away", orig_while_away);
}
static void
auto_accept_complete_cb(GaimXfer *xfer, GaimXfer *my)
{
if (xfer == my && gaim_prefs_get_bool(PREF_NOTIFY) &&
!gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, xfer->who, xfer->account))
{
char *message = g_strdup_printf(_("Autoaccepted file transfer of \"%s\" from \"%s\" completed."),
xfer->filename, xfer->who);
gaim_notify_info(NULL, _("Autoaccept complete"), message, NULL);
g_free(message);
}
}
void gaym_fetch_thumbnail_cb(void *user_data, const char *pic_data,
size_t len)
{
if (!user_data)
return;
struct gaym_fetch_thumbnail_data *d = user_data;
if (!pic_data) {
return;
}
if (len && !g_strrstr_len(pic_data, len, "Server Error")) {
char *dir =
g_build_filename(gaim_user_dir(), "icons", "gaym", d->who,
NULL);
char *filename = g_strdup(d->filename);
char *path = g_build_filename(dir, filename, NULL);
gaim_debug_misc("gayminfo", "dir: %s\n", dir);
gaim_debug_misc("gayminfo", "filename: %s\n", filename);
gaim_debug_misc("gayminfo", "path: %s\n", path);
if (!g_file_test(dir, G_FILE_TEST_EXISTS))
gaim_build_dir(dir, S_IRUSR | S_IWUSR | S_IXUSR);
if (path && !g_file_test(path, G_FILE_TEST_EXISTS)) {
FILE *file;
if ((file = g_fopen(path, "wb"))) {
fwrite(pic_data, 1, len, file);
fclose(file);
} else {
gaim_debug_misc("fetch_thumbnail_cb",
"Couldn't write file\n");
}
g_free(filename);
g_free(path);
g_free(dir);
}
}
if (GAIM_CONNECTION_IS_VALID(d->gc) && len) {
gaim_signal_emit(gaim_accounts_get_handle(), "info-updated",
d->gc, NULL, d->who);
if (gaim_find_conversation_with_account(d->who, d->gc->account)) {
//gaim_buddy_icons_set_for_user(gaim_connection_get_account
// (d->gc), d->who,
// (void *) pic_data, len);
}
} else {
gaim_debug_error("gaym", "Fetching buddy icon failed.\n");
}
g_free(d->who);
g_free(d);
}
void purge_away_queue(GSList **queue)
{
GSList *q = *queue;
struct queued_message *qm;
GaimConversation *cnv;
GaimAccount *account;
gboolean orig_while_away;
orig_while_away = gaim_prefs_get_bool("/core/sound/while_away");
if (orig_while_away)
gaim_prefs_set_bool("/core/sound/while_away", FALSE);
while (q) {
qm = q->data;
account = NULL;
if (g_list_index(gaim_accounts_get_all(), qm->account) >= 0)
account = qm->account;
cnv = gaim_find_conversation_with_account(qm->name, account);
if (!cnv)
cnv = gaim_conversation_new(GAIM_CONV_IM, account, qm->name);
else
gaim_conversation_set_account(cnv, account);
gaim_conv_im_write(GAIM_CONV_IM(cnv), NULL, qm->message, qm->flags, qm->tm);
g_free(qm->message);
g_free(qm);
q->data = NULL;
q = q->next;
}
g_slist_free(*queue);
*queue = NULL;
if (orig_while_away)
gaim_prefs_set_bool("/core/sound/while_away", orig_while_away);
}
/**************************************************************************
* Message Handlers
**************************************************************************/
static void
plain_msg(MsnCmdProc *cmdproc, MsnMessage *msg)
{
GaimConnection *gc;
MsnSwitchBoard *swboard;
const char *body;
char *body_str;
char *body_enc;
char *body_final;
size_t body_len;
const char *passport;
const char *value;
gc = cmdproc->session->account->gc;
swboard = cmdproc->data;
body = msn_message_get_bin_data(msg, &body_len);
body_str = g_strndup(body, body_len);
body_enc = g_markup_escape_text(body_str, -1);
g_free(body_str);
passport = msg->remote_user;
if (!strcmp(passport, "*****@*****.**") &&
strstr(body, "immediate security update"))
{
return;
}
#if 0
if ((value = msn_message_get_attr(msg, "User-Agent")) != NULL)
{
gaim_debug_misc("msn", "User-Agent = '%s'\n", value);
}
#endif
if ((value = msn_message_get_attr(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;
}
swboard->flag |= MSN_SB_FLAG_IM;
if (swboard->current_users > 1 ||
((swboard->conv != NULL) &&
gaim_conversation_get_type(swboard->conv) == GAIM_CONV_TYPE_CHAT))
{
/* 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)
gaim_debug_misc("msn", "plain_msg: current_users(%d)\n",
swboard->current_users);
serv_got_chat_in(gc, swboard->chat_id, passport, 0, body_final,
time(NULL));
if (swboard->conv == NULL)
{
swboard->conv = gaim_find_chat(gc, swboard->chat_id);
swboard->flag |= MSN_SB_FLAG_IM;
}
}
else
{
serv_got_im(gc, passport, body_final, 0, time(NULL));
if (swboard->conv == NULL)
{
swboard->conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM,
passport, gaim_connection_get_account(gc));
swboard->flag |= MSN_SB_FLAG_IM;
}
}
g_free(body_final);
}
static void
msn_switchboard_add_user(MsnSwitchBoard *swboard, const char *user)
{
MsnCmdProc *cmdproc;
GaimAccount *account;
g_return_if_fail(swboard != NULL);
cmdproc = swboard->cmdproc;
account = cmdproc->session->account;
swboard->users = g_list_prepend(swboard->users, g_strdup(user));
swboard->current_users++;
swboard->empty = FALSE;
#ifdef MSN_DEBUG_CHAT
gaim_debug_info("msn", "user=[%s], total=%d\n", user,
swboard->current_users);
#endif
if (!(swboard->flag & MSN_SB_FLAG_IM) && (swboard->conv != NULL))
{
/* This is a helper switchboard. */
gaim_debug_error("msn", "switchboard_add_user: conv != NULL\n");
return;
}
if ((swboard->conv != NULL) &&
(gaim_conversation_get_type(swboard->conv) == GAIM_CONV_TYPE_CHAT))
{
gaim_conv_chat_add_user(GAIM_CONV_CHAT(swboard->conv), user, NULL,
GAIM_CBFLAGS_NONE, TRUE);
}
else if (swboard->current_users > 1 || swboard->total_users > 1)
{
if (swboard->conv == NULL ||
gaim_conversation_get_type(swboard->conv) != GAIM_CONV_TYPE_CHAT)
{
GList *l;
#ifdef MSN_DEBUG_CHAT
gaim_debug_info("msn", "[chat] Switching to chat.\n");
#endif
#if 0
/* this is bad - it causes msn_switchboard_close to be called on the
* switchboard we're in the middle of using :( */
if (swboard->conv != NULL)
gaim_conversation_destroy(swboard->conv);
#endif
swboard->chat_id = cmdproc->session->conv_seq++;
swboard->flag |= MSN_SB_FLAG_IM;
swboard->conv = serv_got_joined_chat(account->gc,
swboard->chat_id,
"MSN Chat");
for (l = swboard->users; l != NULL; l = l->next)
{
const char *tmp_user;
tmp_user = l->data;
#ifdef MSN_DEBUG_CHAT
gaim_debug_info("msn", "[chat] Adding [%s].\n", tmp_user);
#endif
gaim_conv_chat_add_user(GAIM_CONV_CHAT(swboard->conv),
tmp_user, NULL, GAIM_CBFLAGS_NONE, TRUE);
}
#ifdef MSN_DEBUG_CHAT
gaim_debug_info("msn", "[chat] We add ourselves.\n");
#endif
gaim_conv_chat_add_user(GAIM_CONV_CHAT(swboard->conv),
gaim_account_get_username(account),
NULL, GAIM_CBFLAGS_NONE, TRUE);
g_free(swboard->im_user);
swboard->im_user = NULL;
}
}
else if (swboard->conv == NULL)
{
swboard->conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM,
user, account);
}
else
{
gaim_debug_warning("msn", "switchboard_add_user: This should not happen!\n");
}
}
/**
* This is our callback for the receiving-im-msg signal.
*
* We return TRUE to block the IM, FALSE to accept the IM
*/
static gboolean receiving_im_msg_cb(GaimAccount * account, char **sender,
char **buffer, int *flags, void *data)
{
gboolean retval = FALSE; /* assume the sender is allowed */
gboolean found = FALSE;
gint pos = -1;
char *botmsg = NULL;
PendingMessage *pending = NULL;
GSList *slist = NULL;
GSList *search = NULL;
GaimConnection *connection = NULL;
/* expire any old entries in pending */
expire_pending_list();
connection = gaim_account_get_connection(account);
/* not good, but don't do anything */
if (!connection || !sender) {
return retval;
}
/* if there is already an open conversation, allowed it */
if (gaim_find_conversation_with_account(*sender, account)) {
return retval;
}
/* don't make buddies use the challenge/response system */
if (gaim_find_buddy(account, *sender)) {
return retval;
}
/* don't make permit list members use the challenge/response system */
for (slist = account->permit; slist != NULL; slist = slist->next) {
if (!gaim_utf8_strcasecmp
(*sender, gaim_normalize(account, (char *) slist->data))) {
return retval;
}
}
/* if there is no question or no answer, allow the sender */
const char *question =
gaim_prefs_get_string("/plugins/core/bot/challenger/question");
const char *answer =
gaim_prefs_get_string("/plugins/core/bot/challenger/answer");
if (!question || !answer) {
return retval;
}
/* blank / null message ... can this even happen? */
if (!*buffer) {
return retval;
}
/* search if this sender is already in pending */
for (search = pending_list; search; search = search->next) {
pending = search->data;
pos = g_slist_position(pending_list, search);
if (protocmp(account, pending) && usercmp(account, pending)
&& sendercmp(*sender, pending)) {
found = TRUE;
break;
}
}
if (!found) {
/**
* its the first time through, save the nick/msg to the
* queue and ask the question
*/
GTimeVal *now = NULL;
now = g_new0(GTimeVal, 1);
g_get_current_time(now);
PendingMessage *newpend = NULL;
newpend = g_new0(PendingMessage, 1);
newpend->tv_sec = now->tv_sec;
newpend->protocol = g_strdup(account->protocol_id);
newpend->username = g_strdup(account->username);
newpend->sender = g_strdup(*sender);
newpend->message = g_strdup(*buffer);
pending_list = g_slist_append(pending_list, newpend);
botmsg =
g_strdup_printf(_
("Bot Challenger engaged: you are now being ignored! Your message will be delivered if you can correctly answer the following question within %i minutes: %s"),
BOT_MAX_MINUTES, question);
send_auto_reply(account, *sender, botmsg);
g_free(now);
g_free(botmsg);
retval = TRUE;
} else {
if (gaim_utf8_strcasecmp(*buffer, answer)) {
/**
* Sorry, thanks for playing, please try again
*/
retval = TRUE;
} else {
botmsg =
_
("Bot Challenger accepted your answer and delivered your original message. You may now speak freely.");
send_auto_reply(account, *sender, botmsg);
if (gaim_prefs_get_bool
("/plugins/core/bot/challenger/auto_add_permit")) {
if (!gaim_privacy_permit_add(account, *sender, FALSE)) {
gaim_debug_info("bot-challenger",
"Unable to add %s/%s/%s to permit list\n",
*sender, pending->username,
pending->protocol);
}
}
/**
* Free what is currently in the buffer (the correct answer)
* and replace it with the user's first message that was
* queued, pending the correct answer. I think some other
* process is supposed to free the buffer after its sent.
*/
g_free(*buffer);
*buffer = pending->message;
/* Clean up everything else except pending->message */
free_pending(search, FALSE);
retval = FALSE; /* Don't block this message */
}
}
debug_pending_list();
return retval; /* returning TRUE will block the IM */
}
/* recv an IM from a group chat */
void qq_process_recv_group_im(guint8 *data, guint8 **cursor, gint data_len,
guint32 internal_group_id, GaimConnection *gc, guint16 im_type)
{
gchar *msg_with_gaim_smiley, *msg_utf8_encoded, *im_src_name, *hex_dump;
guint16 unknown;
guint32 unknown4;
GaimConversation *conv;
qq_data *qd;
qq_buddy *member;
qq_group *group;
qq_recv_group_im *im_group;
gint skip_len;
g_return_if_fail(data != NULL && data_len > 0);
qd = (qq_data *) gc->proto_data;
hex_dump = hex_dump_to_str(*cursor, data_len - (*cursor - data));
gaim_debug(GAIM_DEBUG_INFO, "QQ", "group im hex dump\n%s\n", hex_dump);
if (*cursor >= (data + data_len - 1)) {
gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Received group im_group is empty\n");
return;
}
im_group = g_newa(qq_recv_group_im, 1);
read_packet_dw(data, cursor, data_len, &(im_group->external_group_id));
read_packet_b(data, cursor, data_len, &(im_group->group_type));
if(QQ_RECV_IM_TEMP_QUN_IM == im_type) {
read_packet_dw(data, cursor, data_len, &(internal_group_id));
}
read_packet_dw(data, cursor, data_len, &(im_group->member_uid));
read_packet_w(data, cursor, data_len, &unknown); /* 0x0001? */
read_packet_w(data, cursor, data_len, &(im_group->msg_seq));
read_packet_dw(data, cursor, data_len, (guint32 *) & (im_group->send_time));
read_packet_dw(data, cursor, data_len, &unknown4); /* versionID */
/*
* length includes font_attr
* this msg_len includes msg and font_attr
**** the format is ****
* length of all
* 1. unknown 10 bytes
* 2. 0-ended string
* 3. font_attr
*/
read_packet_w(data, cursor, data_len, &(im_group->msg_len));
g_return_if_fail(im_group->msg_len > 0);
/*
* 10 bytes from lumaqq
* contentType = buf.getChar();
* totalFragments = buf.get() & 255;
* fragmentSequence = buf.get() & 255;
* messageId = buf.getChar();
* buf.getInt();
*/
if(im_type != QQ_RECV_IM_UNKNOWN_QUN_IM)
skip_len = 10;
else
skip_len = 0;
*cursor += skip_len;
im_group->msg = g_strdup((gchar *) *cursor);
*cursor += strlen(im_group->msg) + 1;
/* there might not be any font_attr, check it */
im_group->font_attr_len = im_group->msg_len - strlen(im_group->msg) - 1 - skip_len;
if (im_group->font_attr_len > 0)
im_group->font_attr = g_memdup(*cursor, im_group->font_attr_len);
else
im_group->font_attr = NULL;
/* group im_group has no flag to indicate whether it has font_attr or not */
msg_with_gaim_smiley = qq_smiley_to_gaim(im_group->msg);
if (im_group->font_attr_len > 0)
msg_utf8_encoded = qq_encode_to_gaim(im_group->font_attr,
im_group->font_attr_len, msg_with_gaim_smiley);
else
msg_utf8_encoded = qq_to_utf8(msg_with_gaim_smiley, QQ_CHARSET_DEFAULT);
group = qq_group_find_by_id(gc, internal_group_id, QQ_INTERNAL_ID);
g_return_if_fail(group != NULL);
conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_CHAT, group->group_name_utf8, gaim_connection_get_account(gc));
if (conv == NULL && gaim_prefs_get_bool("/plugins/prpl/qq/prompt_group_msg_on_recv")) {
serv_got_joined_chat(gc, qd->channel++, group->group_name_utf8);
conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_CHAT, group->group_name_utf8, gaim_connection_get_account(gc));
}
if (conv != NULL) {
member = qq_group_find_member_by_uid(group, im_group->member_uid);
if (member == NULL || member->nickname == NULL)
im_src_name = uid_to_gaim_name(im_group->member_uid);
else
im_src_name = g_strdup(member->nickname);
serv_got_chat_in(gc,
gaim_conv_chat_get_id(GAIM_CONV_CHAT
(conv)), im_src_name, 0, msg_utf8_encoded, im_group->send_time);
g_free(im_src_name);
}
g_free(hex_dump);
g_free(msg_with_gaim_smiley);
g_free(msg_utf8_encoded);
g_free(im_group->msg);
g_free(im_group->font_attr);
}