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);
}
/*------------------------------------------------------------------------
* This gets called when a new chat conversation is opened by the user
*
* @param conv The conversation object
* @param session The MXit session object
*/
static void mxit_cb_chat_created( PurpleConversation* conv, struct MXitSession* session )
{
PurpleConnection* gc;
struct contact* contact;
PurpleBuddy* buddy;
const char* who;
char* tmp;
gc = purple_conversation_get_connection( conv );
if ( session->con != gc ) {
/* not our conversation */
return;
}
else if ( !PURPLE_IS_IM_CONVERSATION( conv ) ) {
/* wrong type of conversation */
return;
}
/* get the contact name */
who = purple_conversation_get_name( conv );
if ( !who )
return;
purple_debug_info( MXIT_PLUGIN_ID, "Conversation started with '%s'\n", who );
/* find the buddy object */
buddy = purple_blist_find_buddy( session->acc, who );
if ( !buddy )
return;
contact = purple_buddy_get_protocol_data( buddy );
if ( !contact )
return;
/* we ignore all conversations with which we have chatted with in this session */
if ( find_active_chat( session->active_chats, who ) )
return;
/* determine if this buddy is a MXit service */
switch ( contact->type ) {
case MXIT_TYPE_BOT :
case MXIT_TYPE_CHATROOM :
case MXIT_TYPE_GALLERY :
case MXIT_TYPE_INFO :
tmp = g_strdup_printf("<font color=\"#999999\">%s</font>\n", _( "Loading menu..." ));
purple_serv_got_im( session->con, who, tmp, PURPLE_MESSAGE_NOTIFY, time( NULL ) );
g_free( tmp );
mxit_send_message( session, who, " ", FALSE, FALSE );
default :
break;
}
}
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 int nullprpl_send_im(PurpleConnection *gc, const char *who,
const char *message, PurpleMessageFlags flags)
{
const char *from_username = purple_account_get_username(purple_connection_get_account(gc));
PurpleMessageFlags receive_flags = ((flags & ~PURPLE_MESSAGE_SEND)
| PURPLE_MESSAGE_RECV);
PurpleAccount *to_acct = purple_accounts_find(who, NULLPRPL_ID);
PurpleConnection *to;
purple_debug_info("nullprpl", "sending message from %s to %s: %s\n",
from_username, who, message);
/* is the sender blocked by the recipient's privacy settings? */
if (to_acct &&
!purple_account_privacy_check(to_acct, purple_account_get_username(purple_connection_get_account(gc)))) {
char *msg = g_strdup_printf(
_("Your message was blocked by %s's privacy settings."), who);
purple_debug_info("nullprpl",
"discarding; %s is blocked by %s's privacy settings\n",
from_username, who);
purple_conversation_present_error(who, purple_connection_get_account(gc), msg);
g_free(msg);
return 0;
}
/* is the recipient online? */
to = get_nullprpl_gc(who);
if (to) { /* yes, send */
purple_serv_got_im(to, from_username, message, receive_flags, time(NULL));
} else { /* nope, store as an offline message */
GOfflineMessage *offline_message;
GList *messages;
purple_debug_info("nullprpl",
"%s is offline, sending as offline message\n", who);
offline_message = g_new0(GOfflineMessage, 1);
offline_message->from = g_strdup(from_username);
offline_message->message = g_strdup(message);
offline_message->mtime = time(NULL);
offline_message->flags = receive_flags;
messages = g_hash_table_lookup(goffline_messages, who);
messages = g_list_append(messages, offline_message);
g_hash_table_insert(goffline_messages, g_strdup(who), messages);
}
return 1;
}
static void nullprpl_login(PurpleAccount *acct)
{
PurpleConnection *gc = purple_account_get_connection(acct);
GList *offline_messages;
purple_debug_info("nullprpl", "logging in %s\n", purple_account_get_username(acct));
purple_connection_update_progress(gc, _("Connecting"),
0, /* which connection step this is */
2); /* total number of steps */
purple_connection_update_progress(gc, _("Connected"),
1, /* which connection step this is */
2); /* total number of steps */
purple_connection_set_state(gc, PURPLE_CONNECTION_CONNECTED);
/* tell purple about everyone on our buddy list who's connected */
foreach_nullprpl_gc(discover_status, gc, NULL);
/* notify other nullprpl accounts */
foreach_nullprpl_gc(report_status_change, gc, NULL);
/* fetch stored offline messages */
purple_debug_info("nullprpl", "checking for offline messages for %s\n",
purple_account_get_username(acct));
offline_messages = g_hash_table_lookup(goffline_messages, purple_account_get_username(acct));
while (offline_messages) {
GOfflineMessage *message = (GOfflineMessage *)offline_messages->data;
purple_debug_info("nullprpl", "delivering offline message to %s: %s\n",
purple_account_get_username(acct), message->message);
purple_serv_got_im(gc, message->from, message->message, message->flags,
message->mtime);
offline_messages = g_list_next(offline_messages);
g_free(message->from);
g_free(message->message);
g_free(message);
}
g_list_free(offline_messages);
g_hash_table_remove(goffline_messages, purple_account_get_username(acct));
}
static void ggp_message_got_display(PurpleConnection *gc,
ggp_message_got_data *msg)
{
if (msg->type == GGP_MESSAGE_GOT_TYPE_IM) {
purple_serv_got_im(gc, ggp_uin_to_str(msg->user), msg->text,
PURPLE_MESSAGE_RECV, msg->time);
}
#if GGP_ENABLE_GG11
else if (msg->type == GGP_MESSAGE_GOT_TYPE_CHAT) {
ggp_chat_got_message(gc, msg->chat_id, msg->text, msg->time,
msg->user);
}
#endif
else if (msg->type == GGP_MESSAGE_GOT_TYPE_MULTILOGON) {
PurpleIMConversation *im = ggp_message_get_conv(gc, msg->user);
const gchar *me = purple_account_get_username(
purple_connection_get_account(gc));
purple_conversation_write(PURPLE_CONVERSATION(im), me, msg->text,
PURPLE_MESSAGE_SEND, msg->time);
} else
purple_debug_error("gg", "ggp_message_got_display: "
"unexpected message type: %d\n", msg->type);
}
/**************************************************************************
* 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);
}
/*Post the Offline Instant Message to User Conversation*/
static void
msn_oim_report_to_user(MsnOimRecvData *rdata, const char *msg_str)
{
MsnMessage *message;
const char *date;
const char *from;
const char *boundary;
char *decode_msg = NULL, *clean_msg = NULL;
gsize body_len;
char **tokens;
char *passport = NULL;
time_t stamp;
const char *charset = NULL;
message = msn_message_new(MSN_MSG_UNKNOWN);
msn_message_parse_payload(message, msg_str, strlen(msg_str),
MSG_OIM_LINE_DEM, MSG_OIM_BODY_DEM);
purple_debug_info("msn", "oim body:{%s}\n", message->body);
boundary = msn_message_get_header_value(message, "boundary");
if (boundary != NULL) {
char *bounds;
char **part;
bounds = g_strdup_printf("--%s" MSG_OIM_LINE_DEM, boundary);
tokens = g_strsplit(message->body, bounds, 0);
/* tokens+1 to skip the "This is a multipart message..." text */
for (part = tokens+1; *part != NULL; part++) {
MsnMessage *multipart;
const char *type;
multipart = msn_message_new(MSN_MSG_UNKNOWN);
msn_message_parse_payload(multipart, *part, strlen(*part),
MSG_OIM_LINE_DEM, MSG_OIM_BODY_DEM);
type = msn_message_get_content_type(multipart);
if (type && !strcmp(type, "text/plain")) {
decode_msg = (char *)purple_base64_decode(multipart->body, &body_len);
charset = msn_message_get_charset(multipart);
msn_message_unref(multipart);
break;
}
msn_message_unref(multipart);
}
g_strfreev(tokens);
g_free(bounds);
if (decode_msg == NULL) {
purple_debug_error("msn", "Couldn't find text/plain OIM message.\n");
msn_message_unref(message);
return;
}
} else {
decode_msg = (char *)purple_base64_decode(message->body, &body_len);
charset = msn_message_get_charset(message);
}
if (charset && !((g_ascii_strncasecmp(charset, "UTF-8", 5) == 0) || (g_ascii_strncasecmp(charset, "UTF8", 4) == 0))) {
clean_msg = g_convert(decode_msg, body_len, "UTF-8", charset, NULL, NULL, NULL);
if (!clean_msg) {
char *clean = purple_utf8_salvage(decode_msg);
purple_debug_error("msn", "Failed to convert charset from %s to UTF-8 for OIM message: %s\n", charset, clean);
clean_msg = g_strdup_printf(_("%s (There was an error receiving this message. "
"Converting the encoding from %s to UTF-8 failed.)"),
clean, charset);
g_free(clean);
}
g_free(decode_msg);
} else if (!g_utf8_validate(decode_msg, body_len, NULL)) {
char *clean = purple_utf8_salvage(decode_msg);
purple_debug_error("msn", "Received an OIM message that is not UTF-8,"
" and no encoding specified: %s\n", clean);
if (charset) {
clean_msg = g_strdup_printf(_("%s (There was an error receiving this message."
" The charset was %s, but it was not valid UTF-8.)"),
clean, charset);
} else {
clean_msg = g_strdup_printf(_("%s (There was an error receiving this message."
" The charset was missing, but it was not valid UTF-8.)"),
clean);
}
g_free(clean);
g_free(decode_msg);
} else {
clean_msg = decode_msg;
}
from = msn_message_get_header_value(message, "X-OIM-originatingSource");
/* Match number to user's mobile number, FROM is a phone number
if the other side pages you using your phone number */
if (from && !strncmp(from, "tel:+", 5)) {
MsnUser *user = msn_userlist_find_user_with_mobile_phone(
rdata->oim->session->userlist, from + 4);
if (user && user->passport)
passport = g_strdup(user->passport);
}
if (passport == NULL) {
char *start, *end;
from = msn_message_get_header_value(message, "From");
tokens = g_strsplit(from, " ", 2);
if (tokens[1] != NULL)
from = (const char *)tokens[1];
start = strchr(from, '<');
if (start != NULL) {
start++;
end = strchr(from, '>');
if (end != NULL)
passport = g_strndup(start, end - start);
}
if (passport == NULL)
passport = g_strdup(_("Unknown"));
g_strfreev(tokens);
}
date = msn_message_get_header_value(message, "Date");
stamp = msn_oim_parse_timestamp(date);
purple_debug_info("msn", "oim Date:{%s},passport{%s}\n",
date, passport);
purple_serv_got_im(purple_account_get_connection(rdata->oim->session->account), passport, clean_msg, 0,
stamp);
/*Now get the oim message ID from the oim_list.
* and append to read list to prepare for deleting the Offline Message when sign out
*/
msn_oim_post_delete_msg(rdata);
g_free(passport);
g_free(clean_msg);
msn_message_unref(message);
}
