static void
profile_msg(MsnCmdProc *cmdproc, MsnMessage *msg)
{
MsnSession *session;
const char *value;
session = cmdproc->session;
if (strcmp(msg->remote_user, "Hotmail"))
{
pecan_warning ("unofficial message");
return;
}
if ((value = msn_message_get_attr(msg, "kv")) != NULL)
{
g_free(session->passport_info.kv);
session->passport_info.kv = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "sid")) != NULL)
{
g_free(session->passport_info.sid);
session->passport_info.sid = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "MSPAuth")) != NULL)
{
g_free(session->passport_info.mspauth);
session->passport_info.mspauth = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "ClientIP")) != NULL)
{
g_free(session->passport_info.client_ip);
session->passport_info.client_ip = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "ClientPort")) != NULL)
session->passport_info.client_port = g_ntohs(atoi(value));
if ((value = msn_message_get_attr(msg, "LoginTime")) != NULL)
session->passport_info.sl = atol(value);
if ((value = msn_message_get_attr(msg, "EmailEnabled")) != NULL)
session->passport_info.email_enabled = atol(value);
}
static void
control_msg(MsnCmdProc *cmdproc, MsnMessage *msg)
{
GaimConnection *gc;
MsnSwitchBoard *swboard;
char *passport;
gc = cmdproc->session->account->gc;
swboard = cmdproc->data;
passport = msg->remote_user;
if (swboard->current_users == 1 &&
msn_message_get_attr(msg, "TypingUser") != NULL)
{
serv_got_typing(gc, passport, MSN_TYPING_RECV_TIMEOUT,
GAIM_TYPING);
}
}
static void
profile_msg(MsnCmdProc *cmdproc, MsnMessage *msg)
{
MsnSession *session;
const char *value;
session = cmdproc->session;
if (strcmp(msg->remote_user, "Hotmail"))
/* This isn't an official message. */
return;
if ((value = msn_message_get_attr(msg, "kv")) != NULL)
{
if (session->passport_info.kv != NULL)
g_free(session->passport_info.kv);
session->passport_info.kv = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "sid")) != NULL)
{
if (session->passport_info.sid != NULL)
g_free(session->passport_info.sid);
session->passport_info.sid = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "MSPAuth")) != NULL)
{
if (session->passport_info.mspauth != NULL)
g_free(session->passport_info.mspauth);
session->passport_info.mspauth = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "ClientIP")) != NULL)
{
if (session->passport_info.client_ip != NULL)
g_free(session->passport_info.client_ip);
session->passport_info.client_ip = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "ClientPort")) != NULL)
session->passport_info.client_port = ntohs(atoi(value));
if ((value = msn_message_get_attr(msg, "LoginTime")) != NULL)
session->passport_info.sl = atol(value);
}
void
msn_message_set_attr(MsnMessage *msg, const char *attr, const char *value)
{
const char *temp;
char *new_attr;
g_return_if_fail(msg != NULL);
g_return_if_fail(attr != NULL);
temp = msn_message_get_attr(msg, attr);
if (value == NULL)
{
if (temp != NULL)
{
GList *l;
for (l = msg->attr_list; l != NULL; l = l->next)
{
if (!g_ascii_strcasecmp(l->data, attr))
{
msg->attr_list = g_list_remove(msg->attr_list, l->data);
break;
}
}
g_hash_table_remove(msg->attr_table, attr);
}
return;
}
new_attr = g_strdup(attr);
g_hash_table_insert(msg->attr_table, new_attr, g_strdup(value));
if (temp == NULL)
msg->attr_list = g_list_append(msg->attr_list, new_attr);
}
static void
msg_error_helper(MsnCmdProc *cmdproc, MsnMessage *msg, MsnMsgErrorType error)
{
MsnSwitchBoard *swboard;
g_return_if_fail(cmdproc != NULL);
g_return_if_fail(msg != NULL);
if ((error != MSN_MSG_ERROR_SB) && (msg->nak_cb != NULL))
msg->nak_cb(msg, msg->ack_data);
swboard = cmdproc->data;
/* This is not good, and should be fixed somewhere else. */
g_return_if_fail(swboard != NULL);
if (msg->type == MSN_MSG_TEXT)
{
const char *format, *str_reason;
char *body_str, *body_enc, *pre, *post;
#if 0
if (swboard->conv == NULL)
{
if (msg->ack_ref)
msn_message_unref(msg);
return;
}
#endif
if (error == MSN_MSG_ERROR_TIMEOUT)
{
str_reason = _("Message may have not been sent "
"because a timeout occurred:");
}
else if (error == MSN_MSG_ERROR_SB)
{
MsnSession *session = swboard->session;
if (!session->destroying && msg->retries && swboard->im_user &&
(swboard->error == MSN_SB_ERROR_CONNECTION ||
swboard->error == MSN_SB_ERROR_UNKNOWN)) {
MsnSwitchBoard *new_sw = msn_session_find_swboard(session,
swboard->im_user);
if (new_sw == NULL || new_sw->reconn_timeout_h == 0) {
new_sw = msn_switchboard_new(session);
new_sw->im_user = g_strdup(swboard->im_user);
new_sw->reconn_timeout_h = purple_timeout_add_seconds(3, msg_resend_cb, new_sw);
new_sw->flag |= MSN_SB_FLAG_IM;
}
body_str = msn_message_to_string(msg);
body_enc = g_markup_escape_text(body_str, -1);
g_free(body_str);
purple_debug_info("msn", "queuing unsent message to %s: %s\n",
swboard->im_user, body_enc);
g_free(body_enc);
msn_send_im_message(session, msg);
msg->retries--;
return;
}
switch (swboard->error)
{
case MSN_SB_ERROR_OFFLINE:
str_reason = _("Message could not be sent, "
"not allowed while invisible:");
break;
case MSN_SB_ERROR_USER_OFFLINE:
str_reason = _("Message could not be sent "
"because the user is offline:");
break;
case MSN_SB_ERROR_CONNECTION:
str_reason = _("Message could not be sent "
"because a connection error occurred:");
break;
case MSN_SB_ERROR_TOO_FAST:
str_reason = _("Message could not be sent "
"because we are sending too quickly:");
break;
case MSN_SB_ERROR_AUTHFAILED:
str_reason = _("Message could not be sent "
"because we were unable to establish a "
"session with the server. This is "
"likely a server problem, try again in "
"a few minutes:");
break;
default:
str_reason = _("Message could not be sent "
"because an error with "
"the switchboard occurred:");
break;
}
}
else
{
str_reason = _("Message may have not been sent "
"because an unknown error occurred:");
}
body_str = msn_message_to_string(msg);
body_enc = g_markup_escape_text(body_str, -1);
g_free(body_str);
format = msn_message_get_attr(msg, "X-MMS-IM-Format");
msn_parse_format(format, &pre, &post);
body_str = g_strdup_printf("%s%s%s", pre ? pre : "",
body_enc ? body_enc : "", post ? post : "");
g_free(body_enc);
g_free(pre);
g_free(post);
msn_switchboard_report_user(swboard, PURPLE_MESSAGE_ERROR,
str_reason);
msn_switchboard_report_user(swboard, PURPLE_MESSAGE_RAW,
body_str);
g_free(body_str);
}
/* If a timeout occures we will want the msg around just in case we
* receive the ACK after the timeout. */
if (msg->ack_ref && error != MSN_MSG_ERROR_TIMEOUT)
{
swboard->ack_list = g_list_remove(swboard->ack_list, msg);
msn_message_unref(msg);
}
}
/*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;
gsize body_len;
char **tokens;
char *passport = NULL;
time_t stamp;
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_attr(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);
msn_message_destroy(multipart);
break;
}
msn_message_destroy(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_destroy(message);
return;
}
} else {
decode_msg = (char *)purple_base64_decode(message->body, &body_len);
}
from = msn_message_get_attr(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_attr(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_attr(message, "Date");
stamp = msn_oim_parse_timestamp(date);
purple_debug_info("msn", "oim Date:{%s},passport{%s}\n",
date, passport);
serv_got_im(rdata->oim->session->account->gc, passport, decode_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(decode_msg);
msn_message_destroy(message);
}
void
msn_cmdproc_process_msg(MsnCmdProc *cmdproc, MsnMessage *msg)
{
MsnMsgTypeCb cb;
const char *messageId = NULL;
/* Multi-part messages */
if ((messageId = msn_message_get_attr(msg, "Message-ID")) != NULL) {
const char *chunk_text = msn_message_get_attr(msg, "Chunks");
guint chunk;
if (chunk_text != NULL) {
chunk = strtol(chunk_text, NULL, 10);
/* 1024 chunks of ~1300 bytes is ~1MB, which seems OK to prevent
some random client causing pidgin to hog a ton of memory.
Probably should figure out the maximum that the official client
actually supports, though. */
if (chunk > 0 && chunk < 1024) {
msg->total_chunks = chunk;
msg->received_chunks = 1;
g_hash_table_insert(cmdproc->multiparts, (gpointer)messageId, msn_message_ref(msg));
purple_debug_info("msn", "Received chunked message, messageId: '%s', total chunks: %d\n",
messageId, chunk);
} else {
purple_debug_error("msn", "MessageId '%s' has too many chunks: %d\n", messageId, chunk);
}
return;
} else {
chunk_text = msn_message_get_attr(msg, "Chunk");
if (chunk_text != NULL) {
MsnMessage *first = g_hash_table_lookup(cmdproc->multiparts, messageId);
chunk = strtol(chunk_text, NULL, 10);
if (first == NULL) {
purple_debug_error("msn",
"Unable to find first chunk of messageId '%s' to correspond with chunk %d.\n",
messageId, chunk+1);
} else if (first->received_chunks == chunk) {
/* Chunk is from 1 to total-1 (doesn't count first one) */
purple_debug_info("msn", "Received chunk %d of %d, messageId: '%s'\n",
chunk+1, first->total_chunks, messageId);
first->body = g_realloc(first->body, first->body_len + msg->body_len);
memcpy(first->body + first->body_len, msg->body, msg->body_len);
first->body_len += msg->body_len;
first->received_chunks++;
if (first->received_chunks != first->total_chunks)
return;
else
/* We're done! Send it along... The caller takes care of
freeing the old one. */
msg = first;
} else {
/* TODO: Can you legitimately receive chunks out of order? */
g_hash_table_remove(cmdproc->multiparts, messageId);
return;
}
} else {
purple_debug_error("msn", "Received MessageId '%s' with no chunk number!\n", messageId);
}
}
}
if (msn_message_get_content_type(msg) == NULL)
{
purple_debug_misc("msn", "failed to find message content\n");
return;
}
cb = g_hash_table_lookup(cmdproc->cbs_table->msgs,
msn_message_get_content_type(msg));
if (cb != NULL)
cb(cmdproc, msg);
else
purple_debug_warning("msn", "Unhandled content-type '%s'\n",
msn_message_get_content_type(msg));
if (messageId != NULL)
g_hash_table_remove(cmdproc->multiparts, messageId);
}
void
msn_message_show_readable(MsnMessage *msg, const char *info,
gboolean text_body)
{
GString *str;
size_t body_len;
const char *body;
GList *l;
g_return_if_fail(msg != NULL);
str = g_string_new(NULL);
/* Standard header. */
if (msg->charset == NULL)
{
g_string_append_printf(str,
"MIME-Version: 1.0\r\n"
"Content-Type: %s\r\n",
msg->content_type);
}
else
{
g_string_append_printf(str,
"MIME-Version: 1.0\r\n"
"Content-Type: %s; charset=%s\r\n",
msg->content_type, msg->charset);
}
for (l = msg->attr_list; l; l = l->next)
{
char *key;
const char *value;
key = l->data;
value = msn_message_get_attr(msg, key);
g_string_append_printf(str, "%s: %s\r\n", key, value);
}
g_string_append(str, "\r\n");
body = msn_message_get_bin_data(msg, &body_len);
if (msg->msnslp_message)
{
g_string_append_printf(str, "Session ID: %u\r\n", msg->msnslp_header.session_id);
g_string_append_printf(str, "ID: %u\r\n", msg->msnslp_header.id);
g_string_append_printf(str, "Offset: %" G_GUINT64_FORMAT "\r\n", msg->msnslp_header.offset);
g_string_append_printf(str, "Total size: %" G_GUINT64_FORMAT "\r\n", msg->msnslp_header.total_size);
g_string_append_printf(str, "Length: %u\r\n", msg->msnslp_header.length);
g_string_append_printf(str, "Flags: 0x%x\r\n", msg->msnslp_header.flags);
g_string_append_printf(str, "ACK ID: %u\r\n", msg->msnslp_header.ack_id);
g_string_append_printf(str, "SUB ID: %u\r\n", msg->msnslp_header.ack_sub_id);
g_string_append_printf(str, "ACK Size: %" G_GUINT64_FORMAT "\r\n", msg->msnslp_header.ack_size);
#ifdef MSN_DEBUG_SLP_VERBOSE
if (body != NULL)
{
if (text_body)
{
g_string_append_len(str, body, body_len);
if (body[body_len - 1] == '\0')
{
str->len--;
g_string_append(str, " 0x00");
}
g_string_append(str, "\r\n");
}
else
{
int i;
for (i = 0; i < msg->body_len; i++)
{
g_string_append_printf(str, "%.2hhX ", body[i]);
if ((i % 16) == 15)
g_string_append(str, "\r\n");
}
g_string_append(str, "\r\n");
}
}
#endif
g_string_append_printf(str, "Footer: %u\r\n", msg->msnslp_footer.value);
}
else
{
if (body != NULL)
{
g_string_append_len(str, body, body_len);
g_string_append(str, "\r\n");
}
}
purple_debug_info("msn", "Message %s:\n{%s}\n", info, str->str);
g_string_free(str, TRUE);
}
char *
msn_message_gen_payload(MsnMessage *msg, size_t *ret_size)
{
GList *l;
char *n, *base, *end;
int len;
size_t body_len = 0;
const void *body;
g_return_val_if_fail(msg != NULL, NULL);
len = MSN_BUF_LEN;
base = n = end = g_malloc(len + 1);
end += len;
/* Standard header. */
if (msg->charset == NULL)
{
g_snprintf(n, len,
"MIME-Version: 1.0\r\n"
"Content-Type: %s\r\n",
msg->content_type);
}
else
{
g_snprintf(n, len,
"MIME-Version: 1.0\r\n"
"Content-Type: %s; charset=%s\r\n",
msg->content_type, msg->charset);
}
n += strlen(n);
for (l = msg->attr_list; l != NULL; l = l->next)
{
const char *key;
const char *value;
key = l->data;
value = msn_message_get_attr(msg, key);
g_snprintf(n, end - n, "%s: %s\r\n", key, value);
n += strlen(n);
}
n += g_strlcpy(n, "\r\n", end - n);
body = msn_message_get_bin_data(msg, &body_len);
if (msg->msnslp_message)
{
MsnSlpHeader header;
MsnSlpFooter footer;
header.session_id = GUINT32_TO_LE(msg->msnslp_header.session_id);
header.id = GUINT32_TO_LE(msg->msnslp_header.id);
header.offset = GUINT64_TO_LE(msg->msnslp_header.offset);
header.total_size = GUINT64_TO_LE(msg->msnslp_header.total_size);
header.length = GUINT32_TO_LE(msg->msnslp_header.length);
header.flags = GUINT32_TO_LE(msg->msnslp_header.flags);
header.ack_id = GUINT32_TO_LE(msg->msnslp_header.ack_id);
header.ack_sub_id = GUINT32_TO_LE(msg->msnslp_header.ack_sub_id);
header.ack_size = GUINT64_TO_LE(msg->msnslp_header.ack_size);
memcpy(n, &header, 48);
n += 48;
if (body != NULL)
{
memcpy(n, body, body_len);
n += body_len;
}
footer.value = GUINT32_TO_BE(msg->msnslp_footer.value);
memcpy(n, &footer, 4);
n += 4;
}
else
{
if (body != NULL)
{
memcpy(n, body, body_len);
n += body_len;
}
}
if (ret_size != NULL)
{
*ret_size = n - base;
if (*ret_size > 1664)
*ret_size = 1664;
}
return base;
}
/**************************************************************************
* 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
msg_error_helper(MsnCmdProc *cmdproc, MsnMessage *msg, MsnMsgErrorType error)
{
MsnSwitchBoard *swboard;
g_return_if_fail(cmdproc != NULL);
g_return_if_fail(msg != NULL);
if ((error != MSN_MSG_ERROR_SB) && (msg->nak_cb != NULL))
msg->nak_cb(msg, msg->ack_data);
swboard = cmdproc->data;
/* This is not good, and should be fixed somewhere else. */
g_return_if_fail(swboard != NULL);
if (msg->type == MSN_MSG_TEXT)
{
const char *format, *str_reason;
char *body_str, *body_enc, *pre, *post;
#if 0
if (swboard->conv == NULL)
{
if (msg->ack_ref)
msn_message_unref(msg);
return;
}
#endif
if (error == MSN_MSG_ERROR_TIMEOUT)
{
str_reason = _("Message may have not been sent "
"because a timeout occurred:");
}
else if (error == MSN_MSG_ERROR_SB)
{
switch (swboard->error)
{
case MSN_SB_ERROR_OFFLINE:
str_reason = _("Message could not be sent, "
"not allowed while invisible:");
break;
case MSN_SB_ERROR_USER_OFFLINE:
str_reason = _("Message could not be sent "
"because the user is offline:");
break;
case MSN_SB_ERROR_CONNECTION:
str_reason = _("Message could not be sent "
"because a connection error occurred:");
break;
case MSN_SB_ERROR_TOO_FAST:
str_reason = _("Message could not be sent "
"because we are sending too quickly:");
break;
default:
str_reason = _("Message could not be sent "
"because an error with "
"the switchboard occurred:");
break;
}
}
else
{
str_reason = _("Message may have not been sent "
"because an unknown error occurred:");
}
body_str = msn_message_to_string(msg);
body_enc = g_markup_escape_text(body_str, -1);
g_free(body_str);
format = msn_message_get_attr(msg, "X-MMS-IM-Format");
msn_parse_format(format, &pre, &post);
body_str = g_strdup_printf("%s%s%s", pre ? pre : "",
body_enc ? body_enc : "", post ? post : "");
g_free(body_enc);
g_free(pre);
g_free(post);
msn_switchboard_report_user(swboard, GAIM_MESSAGE_ERROR,
str_reason);
msn_switchboard_report_user(swboard, GAIM_MESSAGE_RAW,
body_str);
g_free(body_str);
}
/* If a timeout occures we will want the msg around just in case we
* receive the ACK after the timeout. */
if (msg->ack_ref && error != MSN_MSG_ERROR_TIMEOUT)
{
swboard->ack_list = g_list_remove(swboard->ack_list, msg);
msn_message_unref(msg);
}
}
