gboolean
msn_slp_session_msg_received(MsnSlpSession *slpsession, MsnMessage *msg)
{
const char *body;
g_return_val_if_fail(slpsession != NULL, TRUE);
g_return_val_if_fail(msg != NULL, TRUE);
g_return_val_if_fail(msg->msnslp_message, TRUE);
g_return_val_if_fail(!strcmp(msn_message_get_content_type(msg),
"application/x-msnmsgrp2p"), TRUE);
body = msn_message_get_body(msg);
if (strlen(body) == 0)
{
/* ACK. Ignore it. */
gaim_debug_info("msn", "Received MSNSLP ACK\n");
return FALSE;
}
/* Now send an ack, since we got this. */
msn_slp_session_send_ack(slpsession, msg);
return FALSE;
}
void
msn_cmdproc_process_msg(MsnCmdProc *cmdproc, MsnMessage *msg)
{
MsnMsgTypeCb cb;
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)
{
purple_debug_warning("msn", "Unhandled content-type '%s'\n",
msn_message_get_content_type(msg));
return;
}
cb(cmdproc, 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_message_parse_payload(MsnMessage *msg,
const char *payload, size_t payload_len,
const char *line_dem,const char *body_dem)
{
char *tmp_base, *tmp;
const char *content_type;
char *end;
char **elems, **cur, **tokens;
g_return_if_fail(payload != NULL);
tmp_base = tmp = g_malloc(payload_len + 1);
memcpy(tmp_base, payload, payload_len);
tmp_base[payload_len] = '\0';
/* Find the end of the headers */
end = strstr(tmp, body_dem);
/* TODO? some clients use \r delimiters instead of \r\n, the official client
* doesn't send such messages, but does handle receiving them. We'll just
* avoid crashing for now */
if (end == NULL) {
g_free(tmp_base);
g_return_if_reached();
}
/* NUL-terminate the end of the headers - it'll get skipped over below */
*end = '\0';
/* Split the headers and parse each one */
elems = g_strsplit(tmp, line_dem, 0);
for (cur = elems; *cur != NULL; cur++)
{
const char *key, *value;
/* If this line starts with whitespace, it's been folded from the
previous line and won't have ':'. */
if ((**cur == ' ') || (**cur == '\t')) {
tokens = g_strsplit(g_strchug(*cur), "=\"", 2);
key = tokens[0];
value = tokens[1];
/* The only one I care about is 'boundary' (which is folded from
the key 'Content-Type'), so only process that. */
if (!strcmp(key, "boundary") && value) {
char *end = strchr(value, '\"');
if (end) {
*end = '\0';
msn_message_set_header(msg, key, value);
}
}
g_strfreev(tokens);
continue;
}
tokens = g_strsplit(*cur, ": ", 2);
key = tokens[0];
value = tokens[1];
if (!strcmp(key, "MIME-Version"))
{
/* Ignore MIME-Version header */
}
else if (!strcmp(key, "Content-Type"))
{
char *charset, *c;
if (value && (c = strchr(value, ';')) != NULL)
{
if ((charset = strchr(c, '=')) != NULL)
{
charset++;
msn_message_set_charset(msg, charset);
}
*c = '\0';
}
msn_message_set_content_type(msg, value);
}
else
{
msn_message_set_header(msg, key, value);
}
g_strfreev(tokens);
}
g_strfreev(elems);
/* Proceed to the end of the "\r\n\r\n" */
tmp = end + strlen(body_dem);
/* Now we *should* be at the body. */
content_type = msn_message_get_content_type(msg);
if (payload_len - (tmp - tmp_base) > 0) {
msg->body_len = payload_len - (tmp - tmp_base);
g_free(msg->body);
msg->body = g_malloc(msg->body_len + 1);
memcpy(msg->body, tmp, msg->body_len);
msg->body[msg->body_len] = '\0';
}
if (msg->body && content_type && purple_str_has_prefix(content_type, "text/")) {
char *body = NULL;
if (msg->charset == NULL || g_str_equal(msg->charset, "UTF-8")) {
/* Charset is UTF-8 */
if (!g_utf8_validate(msg->body, msg->body_len, NULL)) {
purple_debug_warning("msn", "Message contains invalid "
"UTF-8. Attempting to salvage.\n");
body = purple_utf8_salvage(msg->body);
payload_len = strlen(body);
}
} else {
/* Charset is something other than UTF-8 */
GError *err = NULL;
body = g_convert(msg->body, msg->body_len, "UTF-8",
msg->charset, NULL, &payload_len, &err);
if (!body || err) {
purple_debug_warning("msn", "Unable to convert message from "
"%s to UTF-8: %s\n", msg->charset,
err ? err->message : "Unknown error");
if (err)
g_error_free(err);
/* Fallback to ISO-8859-1 */
g_free(body);
body = g_convert(msg->body, msg->body_len, "UTF-8",
"ISO-8859-1", NULL, &payload_len, NULL);
if (!body) {
g_free(msg->body);
msg->body = NULL;
msg->body_len = 0;
}
}
}
if (body) {
g_free(msg->body);
msg->body = body;
msg->body_len = payload_len;
msn_message_set_charset(msg, "UTF-8");
}
}
g_free(tmp_base);
}
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_parse_payload(MsnMessage *msg,
const char *payload, size_t payload_len)
{
char *tmp_base, *tmp;
const char *content_type;
char *end;
char **elems, **cur, **tokens;
g_return_if_fail(payload != NULL);
tmp_base = tmp = g_malloc0(payload_len + 1);
memcpy(tmp_base, payload, payload_len);
/* Parse the attributes. */
end = strstr(tmp, "\r\n\r\n");
/* TODO? some clients use \r delimiters instead of \r\n, the official client
* doesn't send such messages, but does handle receiving them. We'll just
* avoid crashing for now */
if (end == NULL) {
g_free(tmp_base);
g_return_if_reached();
}
*end = '\0';
elems = g_strsplit(tmp, "\r\n", 0);
for (cur = elems; *cur != NULL; cur++)
{
const char *key, *value;
tokens = g_strsplit(*cur, ": ", 2);
key = tokens[0];
value = tokens[1];
if (!strcmp(key, "MIME-Version"))
{
g_strfreev(tokens);
continue;
}
if (!strcmp(key, "Content-Type"))
{
char *charset, *c;
if ((c = strchr(value, ';')) != NULL)
{
if ((charset = strchr(c, '=')) != NULL)
{
charset++;
msn_message_set_charset(msg, charset);
}
*c = '\0';
}
msn_message_set_content_type(msg, value);
}
else
{
msn_message_set_attr(msg, key, value);
}
g_strfreev(tokens);
}
g_strfreev(elems);
/* Proceed to the end of the "\r\n\r\n" */
tmp = end + 4;
/* Now we *should* be at the body. */
content_type = msn_message_get_content_type(msg);
if (content_type != NULL &&
!strcmp(content_type, "application/x-msnmsgrp2p"))
{
MsnSlpHeader header;
MsnSlpFooter footer;
int body_len;
if (payload_len - (tmp - tmp_base) < sizeof(header)) {
g_free(tmp_base);
g_return_if_reached();
}
msg->msnslp_message = TRUE;
/* Import the header. */
memcpy(&header, tmp, sizeof(header));
tmp += sizeof(header);
msg->msnslp_header.session_id = GUINT32_FROM_LE(header.session_id);
msg->msnslp_header.id = GUINT32_FROM_LE(header.id);
msg->msnslp_header.offset = GUINT64_FROM_LE(header.offset);
msg->msnslp_header.total_size = GUINT64_FROM_LE(header.total_size);
msg->msnslp_header.length = GUINT32_FROM_LE(header.length);
msg->msnslp_header.flags = GUINT32_FROM_LE(header.flags);
msg->msnslp_header.ack_id = GUINT32_FROM_LE(header.ack_id);
msg->msnslp_header.ack_sub_id = GUINT32_FROM_LE(header.ack_sub_id);
msg->msnslp_header.ack_size = GUINT64_FROM_LE(header.ack_size);
body_len = payload_len - (tmp - tmp_base) - sizeof(footer);
/* Import the body. */
if (body_len > 0) {
msg->body_len = body_len;
msg->body = g_malloc0(msg->body_len + 1);
memcpy(msg->body, tmp, msg->body_len);
tmp += body_len;
}
/* Import the footer. */
if (body_len >= 0) {
memcpy(&footer, tmp, sizeof(footer));
tmp += sizeof(footer);
msg->msnslp_footer.value = GUINT32_FROM_BE(footer.value);
}
}
else
{
if (payload_len - (tmp - tmp_base) > 0) {
msg->body_len = payload_len - (tmp - tmp_base);
msg->body = g_malloc0(msg->body_len + 1);
memcpy(msg->body, tmp, msg->body_len);
}
}
g_free(tmp_base);
}
/*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);
}
